diff --git a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp
index b8fdb96d8d..fe0fb8db2b 100644
--- a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp
@@ -1,186 +1,186 @@
 /*===================================================================
 
 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 "SimpleRenderWindowView.h"
 
 #include <QmitkRenderWindow.h>
 
 #include "org_mitk_example_gui_customviewer_views_Activator.h"
 #include <berryIBerryPreferences.h>
 #include <ctkServiceTracker.h>
 #include <mitkIRenderingManager.h>
 #include <mitkInteractionConst.h>
 
 #include <QVBoxLayout>
 #include <mitkPlaneGeometry.h>
 
 /**
  * \brief Helper class adapted from QmitkAbstractRenderEditor by defining the correct plugin context.
  *
  *  This helper class adapted from QmitkAbstractRenderEditor provides the rendering manager interface.
  */
 // //! [SimpleRenderWindowViewHelper]
 class AbstractRenderWindowViewPrivate
 {
 public:
   AbstractRenderWindowViewPrivate()
     : m_RenderingManagerInterface(mitk::MakeRenderingManagerInterface(mitk::RenderingManager::GetInstance())),
       m_PrefServiceTracker(org_mitk_example_gui_customviewer_views_Activator::GetPluginContext())
   // //! [SimpleRenderWindowViewHelper]
   {
     m_PrefServiceTracker.open();
   }
 
   ~AbstractRenderWindowViewPrivate() { delete m_RenderingManagerInterface; }
   mitk::IRenderingManager *m_RenderingManagerInterface;
   ctkServiceTracker<berry::IPreferencesService *> m_PrefServiceTracker;
   berry::IBerryPreferences::Pointer m_Prefs;
 };
 
 const std::string SimpleRenderWindowView::VIEW_ID = "org.mitk.customviewer.views.simplerenderwindowview";
 
-SimpleRenderWindowView::SimpleRenderWindowView() : m_RenderWindow(0), d(new AbstractRenderWindowViewPrivate)
+SimpleRenderWindowView::SimpleRenderWindowView() : m_RenderWindow(nullptr), d(new AbstractRenderWindowViewPrivate)
 {
 }
 
 SimpleRenderWindowView::~SimpleRenderWindowView()
 {
 }
 
 QmitkRenderWindow *SimpleRenderWindowView::GetActiveQmitkRenderWindow() const
 {
   return m_RenderWindow;
 }
 
 QHash<QString, QmitkRenderWindow *> SimpleRenderWindowView::GetRenderWindows() const
 {
   QHash<QString, QmitkRenderWindow *> wnds;
   wnds.insert("transversal", m_RenderWindow);
   return wnds;
 }
 
 QHash<QString, QmitkRenderWindow *> SimpleRenderWindowView::GetQmitkRenderWindows() const
 {
   QHash<QString, QmitkRenderWindow *> wnds;
   wnds.insert("transversal", m_RenderWindow);
   return wnds;
 }
 
 QmitkRenderWindow *SimpleRenderWindowView::GetRenderWindow(const QString &id) const
 {
   if (id == "transversal")
   {
     return m_RenderWindow;
   }
-  return 0;
+  return nullptr;
 }
 
 QmitkRenderWindow *SimpleRenderWindowView::GetQmitkRenderWindow(const QString &id) const
 {
   if (id == "transversal")
   {
     return m_RenderWindow;
   }
-  return 0;
+  return nullptr;
 }
 
 mitk::Point3D SimpleRenderWindowView::GetSelectedPosition(const QString & /*id*/) const
 {
   const mitk::PlaneGeometry *pg = m_RenderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   if (pg)
   {
     return pg->GetCenter();
   }
   else
   {
     return mitk::Point3D();
   }
 }
 
 void SimpleRenderWindowView::SetSelectedPosition(const mitk::Point3D &, const QString &)
 {
 }
 
 void SimpleRenderWindowView::EnableDecorations(bool enable, const QStringList &decorations)
 {
   if (decorations.isEmpty() || decorations.contains(DECORATION_MENU))
   {
     m_RenderWindow->ActivateMenuWidget(enable);
   }
 }
 
 bool SimpleRenderWindowView::IsDecorationEnabled(const QString &decoration) const
 {
   if (decoration == DECORATION_MENU)
   {
     return m_RenderWindow->GetActivateMenuWidgetFlag();
   }
   return false;
 }
 
 QStringList SimpleRenderWindowView::GetDecorations() const
 {
   QStringList decorations;
   decorations << DECORATION_MENU;
   return decorations;
 }
 
 void SimpleRenderWindowView::SetFocus()
 {
   m_RenderWindow->setFocus();
 }
 
 // //! [SimpleRenderWindowViewCreatePartControl]
 void SimpleRenderWindowView::CreateQtPartControl(QWidget *parent)
 {
   QVBoxLayout *layout = new QVBoxLayout(parent);
   layout->setContentsMargins(0, 0, 0, 0);
 
   m_RenderWindow = new QmitkRenderWindow(parent);
   layout->addWidget(m_RenderWindow);
 
   mitk::DataStorage::Pointer ds = this->GetDataStorage();
   m_RenderWindow->GetRenderer()->SetDataStorage(ds);
 
   this->RequestUpdate();
 }
 // //! [SimpleRenderWindowViewCreatePartControl]
 
 mitk::IRenderingManager *SimpleRenderWindowView::GetRenderingManager() const
 {
   // we use the global rendering manager here. This should maybe replaced
   // by a local one, managing only the render windows specific for the view
   return d->m_RenderingManagerInterface;
 }
 
 void SimpleRenderWindowView::RequestUpdate(mitk::RenderingManager::RequestType requestType)
 {
   if (GetRenderingManager())
     GetRenderingManager()->RequestUpdateAll(requestType);
 }
 
 void SimpleRenderWindowView::ForceImmediateUpdate(mitk::RenderingManager::RequestType requestType)
 {
   if (GetRenderingManager())
     GetRenderingManager()->ForceImmediateUpdateAll(requestType);
 }
 
 mitk::SliceNavigationController *SimpleRenderWindowView::GetTimeNavigationController() const
 {
   if (GetRenderingManager())
     return GetRenderingManager()->GetTimeNavigationController();
-  return 0;
+  return nullptr;
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/isosurface/QmitkIsoSurface.cpp b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/isosurface/QmitkIsoSurface.cpp
index 4b5e734f96..aebd4842bb 100644
--- a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/isosurface/QmitkIsoSurface.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/isosurface/QmitkIsoSurface.cpp
@@ -1,168 +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 "QmitkIsoSurface.h"
 
 // MITK headers
 #include <mitkManualSegmentationToSurfaceFilter.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkSurface.h>
 
 // Qmitk headers
 #include <QmitkSelectableGLWidget.h>
 #include <QmitkStdMultiWidget.h>
 
 // Qt-GUI headers
 #include <QApplication>
 #include <QCursor>
 #include <QMessageBox>
 
 QmitkIsoSurface::QmitkIsoSurface(QObject * /*parent*/, const char * /*name*/)
   : m_Controls(nullptr), m_MitkImage(nullptr), m_SurfaceCounter(0)
 {
 }
 
 void QmitkIsoSurface::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     m_Controls = new Ui::QmitkIsoSurfaceControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->m_ImageSelector->SetDataStorage(this->GetDataStorage());
     m_Controls->m_ImageSelector->SetPredicate(mitk::NodePredicateDataType::New("Image"));
 
     berry::IPreferences::Pointer prefs = this->GetPreferences();
     if (prefs.IsNotNull())
       m_Controls->thresholdLineEdit->setText(prefs->Get("defaultThreshold", "0"));
   }
 }
 
 void QmitkIsoSurface::SetFocus()
 {
   m_Controls->m_ImageSelector->setFocus();
 }
 
 void QmitkIsoSurface::CreateConnections()
 {
   if (m_Controls)
   {
     connect(m_Controls->m_ImageSelector,
             SIGNAL(OnSelectionChanged(const mitk::DataNode *)),
             this,
             SLOT(ImageSelected(const mitk::DataNode *)));
     connect(m_Controls->createSurfacePushButton, SIGNAL(clicked()), this, SLOT(CreateSurface()));
   }
 }
 
 void QmitkIsoSurface::ImageSelected(const mitk::DataNode *item)
 {
   // nothing selected (nullptr selection)
-  if (item == 0 || item->GetData() == 0)
+  if (item == nullptr || item->GetData() == nullptr)
     return;
 
   m_MitkImage = dynamic_cast<mitk::Image *>(item->GetData());
 }
 
 void QmitkIsoSurface::CreateSurface()
 {
   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
   if (m_MitkImage != nullptr)
   {
     // Value Gauss
     // float gsDev = 1.5;
 
     // Value for DecimatePro
     float targetReduction = 0.05;
 
     // ImageToSurface Instance
     mitk::DataNode::Pointer node = m_Controls->m_ImageSelector->GetSelectedNode();
 
     mitk::ManualSegmentationToSurfaceFilter::Pointer filter = mitk::ManualSegmentationToSurfaceFilter::New();
     if (filter.IsNull())
     {
       std::cout << "nullptr Pointer for ManualSegmentationToSurfaceFilter" << std::endl;
       return;
     }
 
     filter->SetInput(m_MitkImage);
     filter->SetGaussianStandardDeviation(0.5);
     filter->SetUseGaussianImageSmooth(true);
     filter->SetThreshold(getThreshold()); // if( Gauss ) --> TH manipulated for vtkMarchingCube
 
     filter->SetTargetReduction(targetReduction);
 
     int numOfPolys = filter->GetOutput()->GetVtkPolyData()->GetNumberOfPolys();
     if (numOfPolys > 2000000)
     {
       QApplication::restoreOverrideCursor();
       if (QMessageBox::question(nullptr,
                                 "CAUTION!!!",
                                 "The number of polygons is greater than 2 000 000. If you continue, the program might "
                                 "crash. How do you want to go on?",
                                 "Proceed anyway!",
                                 "Cancel immediately! (maybe you want to insert an other threshold)!",
                                 QString::null,
                                 0,
                                 1) == 1)
       {
         return;
       }
       QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
     }
     mitk::DataNode::Pointer surfaceNode = mitk::DataNode::New();
     surfaceNode->SetData(filter->GetOutput());
 
     int layer = 0;
 
     ++m_SurfaceCounter;
     std::ostringstream buffer;
     buffer << m_SurfaceCounter;
     std::string surfaceNodeName = "Surface " + buffer.str();
 
     node->GetIntProperty("layer", layer);
     surfaceNode->SetIntProperty("layer", layer + 1);
     surfaceNode->SetProperty("Surface", mitk::BoolProperty::New(true));
     surfaceNode->SetProperty("name", mitk::StringProperty::New(surfaceNodeName));
 
     this->GetDataStorage()->Add(surfaceNode, node);
 
     // to show surfaceContur
     surfaceNode->SetColor(m_RainbowColor.GetNextColor());
     surfaceNode->SetVisibility(true);
 
     mitk::IRenderWindowPart *renderPart = this->GetRenderWindowPart();
     if (renderPart)
     {
       renderPart->RequestUpdate();
     }
   }
 
   QApplication::restoreOverrideCursor();
 }
 
 float QmitkIsoSurface::getThreshold()
 {
   return m_Controls->thresholdLineEdit->text().toFloat();
 }
 
 QmitkIsoSurface::~QmitkIsoSurface()
 {
   berry::IPreferences::Pointer prefs = this->GetPreferences();
   if (prefs.IsNotNull())
     prefs->Put("defaultThreshold", m_Controls->thresholdLineEdit->text());
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/simplemeasurement/QmitkSimpleMeasurement.cpp b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/simplemeasurement/QmitkSimpleMeasurement.cpp
index 23d4110521..1a8c221f5c 100644
--- a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/simplemeasurement/QmitkSimpleMeasurement.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/simplemeasurement/QmitkSimpleMeasurement.cpp
@@ -1,307 +1,307 @@
 /*===================================================================
 
 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 "QmitkSimpleMeasurement.h"
 
 #include "ui_QmitkSimpleMeasurementControls.h"
 
 #include <mitkIDataStorageService.h>
 #include <mitkPointSet.h>
 #include <mitkProperties.h>
 #include <mitkStringProperty.h>
 
 #include <berryIEditorPart.h>
 #include <berryIWorkbenchPage.h>
 #include <berryPlatform.h>
 
 QmitkSimpleMeasurement::QmitkSimpleMeasurement()
 {
 }
 
 QmitkSimpleMeasurement::~QmitkSimpleMeasurement()
 {
   // remove all measurements when view is closed
   for (std::size_t i = 0; i < m_CreatedDistances.size(); i++)
   {
     this->GetDataStorage()->Remove(m_CreatedDistances.at(i));
   }
   for (std::size_t i = 0; i < m_CreatedAngles.size(); i++)
   {
     this->GetDataStorage()->Remove(m_CreatedAngles.at(i));
   }
   for (std::size_t i = 0; i < m_CreatedPaths.size(); i++)
   {
     this->GetDataStorage()->Remove(m_CreatedPaths.at(i));
   }
 
   if (m_PointSetInteractor.IsNotNull())
   {
     m_SelectedPointSetNode->SetDataInteractor(nullptr);
   }
 }
 
 void QmitkSimpleMeasurement::Activated()
 {
   this->OnSelectionChanged(berry::IWorkbenchPart::Pointer(), this->GetCurrentSelection());
 }
 
 void QmitkSimpleMeasurement::Deactivated()
 {
 }
 
 void QmitkSimpleMeasurement::Visible()
 {
 }
 
 void QmitkSimpleMeasurement::Hidden()
 {
 }
 
 void QmitkSimpleMeasurement::ActivatedZombieView(berry::SmartPointer<berry::IWorkbenchPartReference> /*zombieView*/)
 {
   // something else was selected. remove old interactor
   if (m_PointSetInteractor.IsNotNull())
   {
     m_SelectedPointSetNode->SetDataInteractor(nullptr);
   }
 }
 
 void QmitkSimpleMeasurement::AddDistanceSimpleMeasurement()
 {
   mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
 
   QString name = "Distance " + QString::number(m_CreatedDistances.size() + 1);
 
   mitk::DataNode::Pointer CurrentPointSetNode = mitk::DataNode::New();
   CurrentPointSetNode->SetData(pointSet);
   CurrentPointSetNode->SetProperty("show contour", mitk::BoolProperty::New(true));
   CurrentPointSetNode->SetProperty("name", mitk::StringProperty::New(name.toStdString()));
   CurrentPointSetNode->SetProperty("show distances", mitk::BoolProperty::New(true));
 
   // add to ds and remember as created
   m_CreatedDistances.push_back(CurrentPointSetNode);
   this->GetDataStorage()->Add(CurrentPointSetNode);
 
   // make new selection
   QList<mitk::DataNode::Pointer> selection;
   selection.push_back(CurrentPointSetNode);
   this->FireNodesSelected(selection);
   this->OnSelectionChanged(berry::IWorkbenchPart::Pointer(), selection);
 }
 
 void QmitkSimpleMeasurement::AddAngleSimpleMeasurement()
 {
   mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
 
   QString name = "Angle " + QString::number(m_CreatedAngles.size() + 1);
 
   mitk::DataNode::Pointer _CurrentPointSetNode = mitk::DataNode::New();
   _CurrentPointSetNode->SetData(pointSet);
   _CurrentPointSetNode->SetProperty("show contour", mitk::BoolProperty::New(true));
   _CurrentPointSetNode->SetProperty("name", mitk::StringProperty::New(name.toStdString()));
   _CurrentPointSetNode->SetProperty("show angles", mitk::BoolProperty::New(true));
 
   // add to ds and remember as created
   this->GetDataStorage()->Add(_CurrentPointSetNode);
   m_CreatedAngles.push_back(_CurrentPointSetNode);
 
   // make new selection
   QList<mitk::DataNode::Pointer> selection;
   selection.push_back(_CurrentPointSetNode);
   this->FireNodesSelected(selection);
   this->OnSelectionChanged(berry::IWorkbenchPart::Pointer(), selection);
 }
 
 void QmitkSimpleMeasurement::AddPathSimpleMeasurement()
 {
   mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
 
   QString name = "Path " + QString::number(m_CreatedPaths.size() + 1);
 
   mitk::DataNode::Pointer _CurrentPointSetNode = mitk::DataNode::New();
   _CurrentPointSetNode->SetData(pointSet);
   _CurrentPointSetNode->SetProperty("show contour", mitk::BoolProperty::New(true));
   _CurrentPointSetNode->SetProperty("name", mitk::StringProperty::New(name.toStdString()));
   _CurrentPointSetNode->SetProperty("show distances", mitk::BoolProperty::New(true));
   _CurrentPointSetNode->SetProperty("show angles", mitk::BoolProperty::New(true));
 
   // add to ds and remember as created
   this->GetDataStorage()->Add(_CurrentPointSetNode);
   m_CreatedPaths.push_back(_CurrentPointSetNode);
 
   // make new selection
   QList<mitk::DataNode::Pointer> selection;
   selection.push_back(_CurrentPointSetNode);
   this->FireNodesSelected(selection);
   this->OnSelectionChanged(berry::IWorkbenchPart::Pointer(), selection);
 }
 
 void QmitkSimpleMeasurement::CreateQtPartControl(QWidget *parent)
 {
   m_CreatedDistances = std::vector<mitk::DataNode::Pointer>();
   m_CreatedAngles = std::vector<mitk::DataNode::Pointer>();
   m_CreatedPaths = std::vector<mitk::DataNode::Pointer>();
 
   m_Controls = new Ui::QmitkSimpleMeasurementControls;
   m_Controls->setupUi(parent);
 
   connect(
     (QObject *)(m_Controls->pbDistance), SIGNAL(clicked()), (QObject *)this, SLOT(AddDistanceSimpleMeasurement()));
   connect((QObject *)(m_Controls->pbAngle), SIGNAL(clicked()), (QObject *)this, SLOT(AddAngleSimpleMeasurement()));
   connect((QObject *)(m_Controls->pbPath), SIGNAL(clicked()), (QObject *)this, SLOT(AddPathSimpleMeasurement()));
   connect((QObject *)(m_Controls->m_Finished), SIGNAL(clicked()), (QObject *)this, SLOT(Finished()));
 
   EndEditingMeasurement();
 }
 
 void QmitkSimpleMeasurement::SetFocus()
 {
   m_Controls->m_Finished->setFocus();
 }
 
 void QmitkSimpleMeasurement::Finished()
 {
   OnSelectionChanged(berry::IWorkbenchPart::Pointer(), QList<mitk::DataNode::Pointer>());
 }
 
 void QmitkSimpleMeasurement::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/,
                                                 const QList<mitk::DataNode::Pointer> &nodes)
 {
   mitk::DataNode::Pointer selectedNode;
   if (nodes.size() > 0)
     selectedNode = nodes.front();
 
-  mitk::PointSet *pointSet = 0;
+  mitk::PointSet *pointSet = nullptr;
   if (selectedNode.IsNotNull())
     pointSet = dynamic_cast<mitk::PointSet *>(selectedNode->GetData());
 
   // something else was selected. remove old interactor
   if (m_PointSetInteractor.IsNotNull())
   {
     m_SelectedPointSetNode->SetDataInteractor(nullptr);
   }
 
   bool pointsetCreatedByThis = false;
 
   // only go further if a pointset was selected
   if (pointSet)
   {
     // see if this pointset was created by us
     std::vector<mitk::DataNode::Pointer>::iterator it =
       std::find(m_CreatedDistances.begin(), m_CreatedDistances.end(), selectedNode);
     if (it != m_CreatedDistances.end())
       pointsetCreatedByThis = true;
 
     it = std::find(m_CreatedAngles.begin(), m_CreatedAngles.end(), selectedNode);
     if (it != m_CreatedAngles.end())
       pointsetCreatedByThis = true;
 
     it = std::find(m_CreatedPaths.begin(), m_CreatedPaths.end(), selectedNode);
     if (it != m_CreatedPaths.end())
       pointsetCreatedByThis = true;
   }
 
   // do nothing if it was not created by us or it is no pointset node or we are not activated
   if (pointsetCreatedByThis)
   {
     // otherwise: set text and add interactor for the pointset
     m_Controls->selectedPointSet->setText(QString::fromStdString(selectedNode->GetName()));
 
     m_PointSetInteractor = mitk::PointSetDataInteractor::New();
     m_PointSetInteractor->LoadStateMachine("PointSet.xml");
     m_PointSetInteractor->SetEventConfig("PointSetConfig.xml");
     m_PointSetInteractor->SetDataNode(selectedNode);
 
     float green[] = {0, 255, 0};
     float red[] = {255, 0, 0};
     selectedNode->SetColor(green);
     if (m_SelectedPointSetNode.IsNotNull())
       m_SelectedPointSetNode->SetColor(red);
     m_SelectedPointSetNode = selectedNode;
     StartEditingMeasurement();
   }
   else
   {
     EndEditingMeasurement();
   }
 }
 
 void QmitkSimpleMeasurement::NodeRemoved(const mitk::DataNode *node)
 {
   // remove a node if it is destroyed from our created array
   m_CreatedDistances.erase(std::remove(m_CreatedDistances.begin(), m_CreatedDistances.end(), node),
                            m_CreatedDistances.end());
   m_CreatedAngles.erase(std::remove(m_CreatedAngles.begin(), m_CreatedAngles.end(), node), m_CreatedAngles.end());
   m_CreatedPaths.erase(std::remove(m_CreatedPaths.begin(), m_CreatedPaths.end(), node), m_CreatedPaths.end());
 }
 
 void QmitkSimpleMeasurement::StartEditingMeasurement()
 {
   m_Controls->explain_label->setVisible(true);
   m_Controls->m_Finished->setVisible(true);
   m_Controls->pbDistance->setEnabled(false);
   m_Controls->pbAngle->setEnabled(false);
   m_Controls->pbPath->setEnabled(false);
   UpdateMeasurementList();
 }
 
 void QmitkSimpleMeasurement::EndEditingMeasurement()
 {
   m_Controls->pbDistance->setEnabled(true);
   m_Controls->pbAngle->setEnabled(true);
   m_Controls->pbPath->setEnabled(true);
   m_Controls->explain_label->setVisible(false);
   m_Controls->m_Finished->setVisible(false);
   m_Controls->selectedPointSet->setText("None");
   UpdateMeasurementList();
 }
 
 void QmitkSimpleMeasurement::UpdateMeasurementList()
 {
   m_Controls->m_MeasurementList->clear();
 
   for (std::size_t i = 0; i < m_CreatedDistances.size(); i++)
   {
     QListWidgetItem *newItem = new QListWidgetItem;
     QString distance;
     mitk::PointSet::Pointer points = dynamic_cast<mitk::PointSet *>(m_CreatedDistances.at(i)->GetData());
     if (points->GetSize() < 2)
     {
       distance = "not available";
     }
     else
     {
       distance = QString::number(points->GetPoint(0).EuclideanDistanceTo(points->GetPoint(1))) + " mm";
     }
     QString name = QString(m_CreatedDistances.at(i)->GetName().c_str()) + " (" + distance + ")";
     newItem->setText(name);
     m_Controls->m_MeasurementList->insertItem(m_Controls->m_MeasurementList->count(), newItem);
   }
   for (std::size_t i = 0; i < m_CreatedAngles.size() && i < m_CreatedDistances.size(); i++)
   {
     QListWidgetItem *newItem = new QListWidgetItem;
     QString name = m_CreatedDistances.at(i)->GetName().c_str();
     newItem->setText(name);
     m_Controls->m_MeasurementList->insertItem(m_Controls->m_MeasurementList->count(), newItem);
   }
   for (std::size_t i = 0; i < m_CreatedPaths.size() && i < m_CreatedDistances.size(); i++)
   {
     QListWidgetItem *newItem = new QListWidgetItem;
     QString name = m_CreatedDistances.at(i)->GetName().c_str();
     newItem->setText(name);
     m_Controls->m_MeasurementList->insertItem(m_Controls->m_MeasurementList->count(), newItem);
   }
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.opencv/src/internal/videoplayer/QmitkVideoPlayer.cpp b/Examples/Plugins/org.mitk.example.gui.opencv/src/internal/videoplayer/QmitkVideoPlayer.cpp
index 36639630d4..87c4a48908 100644
--- a/Examples/Plugins/org.mitk.example.gui.opencv/src/internal/videoplayer/QmitkVideoPlayer.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.opencv/src/internal/videoplayer/QmitkVideoPlayer.cpp
@@ -1,64 +1,64 @@
 /*===================================================================
 
 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 "QmitkVideoPlayer.h"
 #include <QVBoxLayout>
 #include <QmitkOpenCVVideoControls.h>
 #include <QmitkStdMultiWidget.h>
 #include <QmitkVideoBackground.h>
 
-QmitkVideoPlayer::QmitkVideoPlayer() : m_VideoSource(0), m_VideoBackground(new QmitkVideoBackground(m_VideoSource))
+QmitkVideoPlayer::QmitkVideoPlayer() : m_VideoSource(nullptr), m_VideoBackground(new QmitkVideoBackground(m_VideoSource))
 {
 }
 
 QmitkVideoPlayer::~QmitkVideoPlayer()
 {
   // save video preferences
 }
 
 void QmitkVideoPlayer::CreateQtPartControl(QWidget *parent)
 {
   // retrieve old preferences
   m_VideoSource = mitk::OpenCVVideoSource::New();
   m_VideoBackground = new QmitkVideoBackground(m_VideoSource);
   m_VideoBackground->setParent(parent);
 
   QVBoxLayout *layout = new QVBoxLayout;
   QmitkRenderWindow *renderWindow = nullptr;
   if (this->GetRenderWindowPart())
   {
     renderWindow = this->GetRenderWindowPart()->GetActiveQmitkRenderWindow();
   }
   m_OpenCVVideoControls = new QmitkOpenCVVideoControls(m_VideoBackground, renderWindow);
   layout->addWidget(m_OpenCVVideoControls);
 
   parent->setLayout(layout);
 }
 
 void QmitkVideoPlayer::SetFocus()
 {
   m_OpenCVVideoControls->setFocus();
 }
 
 void QmitkVideoPlayer::RenderWindowPartActivated(mitk::IRenderWindowPart *renderWindowPart)
 {
   m_OpenCVVideoControls->SetRenderWindow(renderWindowPart->GetActiveQmitkRenderWindow());
 }
 
 void QmitkVideoPlayer::RenderWindowPartDeactivated(mitk::IRenderWindowPart * /*renderWindowPart*/)
 {
   m_OpenCVVideoControls->SetRenderWindow(nullptr);
 }
diff --git a/Modules/BasicImageProcessing/MiniApps/ImageTypeConverter.cpp b/Modules/BasicImageProcessing/MiniApps/ImageTypeConverter.cpp
index 19742fcc71..40126f6ea5 100644
--- a/Modules/BasicImageProcessing/MiniApps/ImageTypeConverter.cpp
+++ b/Modules/BasicImageProcessing/MiniApps/ImageTypeConverter.cpp
@@ -1,127 +1,127 @@
 /*===================================================================
 
 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 "mitkCommandLineParser.h"
 #include "mitkIOUtil.h"
 #include <mitkImageCast.h>
 #include <typeinfo>
 
 #define CONVERT_IMAGE(TYPE, DIM)                                                                      \
   {                                                                                                   \
     MITK_INFO << "Data Type for Conversion: " << typeid(TYPE).name();                                 \
     itk::Image<TYPE, DIM>::Pointer itkImage = itk::Image<TYPE, DIM>::New();                           \
     mitk::CastToItkImage(image, itkImage);                                                            \
     mitk::CastToMitkImage(itkImage, outputImage);                                                     \
   }
 
 #define CONVERT_IMAGE_TYPE(TYPE)                                                                      \
   {                                                                                                   \
     unsigned int dimension = image->GetDimension();                                                   \
     MITK_INFO << "Image Dimension is: " << dimension;                                                 \
     switch (dimension) {                                                                              \
       case 2 : CONVERT_IMAGE( TYPE , 2);                                                              \
                break;                                                                                 \
       case 3 : CONVERT_IMAGE( TYPE , 3);                                                              \
                break;                                                                                 \
       default: MITK_INFO << "This tool doesn't support a dimension of "<<dimension<<".";              \
                outputImage = NULL;                                                                    \
                break;                                                                                 \
     };                                                                                                \
   }
 
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Image Type Converter");
   parser.setCategory("Basic Image Processing");
   parser.setDescription("");
   parser.setContributor("MBI");
 
   parser.setArgumentPrefix("--","-");
   // Add command line argument names
   parser.addArgument("help", "h",mitkCommandLineParser::Bool, "Help:", "Show this help text");
   parser.addArgument("input", "i", mitkCommandLineParser::File, "Input file:", "Input file",us::Any(),false, false, false, mitkCommandLineParser::Input);
   parser.addArgument("output", "o", mitkCommandLineParser::File, "Output file:", "Output file", us::Any(), false, false, false, mitkCommandLineParser::Output);
   parser.addArgument("type", "t", mitkCommandLineParser::String, "Type definition:", "Define Scalar data type: int, uint, short, ushort, char, uchar, float, double", us::Any(), false);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   // Show a help message
   if ( parsedArgs.count("help") || parsedArgs.count("h"))
   {
     std::cout << parser.helpText();
     return EXIT_SUCCESS;
   }
 
   std::string inputName = us::any_cast<std::string>(parsedArgs["input"]);
   std::string outputName = us::any_cast<std::string>(parsedArgs["output"]);
   std::string type = us::any_cast<std::string>(parsedArgs["type"]);
 
   mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(inputName);
   mitk::Image::Pointer outputImage = mitk::Image::New();
 
   if (type.compare("int") == 0) {
     CONVERT_IMAGE_TYPE(int);
   }
   else if (type.compare("uint") == 0)
   {
     CONVERT_IMAGE_TYPE(unsigned int);
   }
   else if (type.compare("char") == 0)
   {
     CONVERT_IMAGE_TYPE(char);
   }
   else if (type.compare("uchar") == 0)
   {
     CONVERT_IMAGE_TYPE(unsigned char);
   }
   else if (type.compare("short") == 0)
   {
     CONVERT_IMAGE_TYPE(short);
   }
   else if (type.compare("ushort") == 0)
   {
     CONVERT_IMAGE_TYPE(unsigned short);
   }
   else if (type.compare("float") == 0)
   {
     CONVERT_IMAGE_TYPE(float);
   }
   else if (type.compare("double") == 0)
   {
     CONVERT_IMAGE_TYPE(double);
   }
   else if (type.compare("none") == 0)
   {
     MITK_INFO << " No conversion performed";
-    outputImage = NULL;
+    outputImage = nullptr;
   }
   else
   {
     CONVERT_IMAGE_TYPE(double);
   }
 
   if (outputImage.IsNotNull())
   {
     mitk::IOUtil::Save(outputImage, outputName);
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/Chart/src/QmitkChartWidget.cpp b/Modules/Chart/src/QmitkChartWidget.cpp
index d4de5e15af..d5accfaacc 100644
--- a/Modules/Chart/src/QmitkChartWidget.cpp
+++ b/Modules/Chart/src/QmitkChartWidget.cpp
@@ -1,753 +1,753 @@
 /*===================================================================
 
 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 <regex>
 
 #include <QGridLayout>
 #include <QWebChannel>
 #include <QWebEngineSettings>
 #include <QWebEngineView>
 #include <QmitkChartWidget.h>
 
 #include "mitkExceptionMacro.h"
 #include <QmitkChartData.h>
 #include <QmitkChartxyData.h>
 
 class CustomPage : public QWebEnginePage
 {
 public:
-  CustomPage(QObject *parent = 0) : QWebEnginePage(parent) {}
+  CustomPage(QObject *parent = nullptr) : QWebEnginePage(parent) {}
   void javaScriptConsoleMessage(JavaScriptConsoleMessageLevel /*level*/,
                                         const QString &message,
                                         int lineNumber,
                                         const QString & /*sourceID*/) override
   {
     MITK_INFO << "JS > " << lineNumber << ": " << message.toStdString();
   }
 };
 
 class QmitkChartWidget::Impl final
 {
 public:
   explicit Impl(QWidget *parent);
   ~Impl();
 
   Impl(const Impl &) = delete;
   Impl &operator=(const Impl &) = delete;
 
   void AddData1D(const std::vector<double> &data1D, const std::string &label, QmitkChartWidget::ChartType chartType);
   void AddData2D(const std::map<double, double> &data2D,
                  const std::string &label,
                  QmitkChartWidget::ChartType chartType);
   void UpdateData1D(const std::vector<double> &data1D, const std::string &label);
   void UpdateData2D(const std::map<double, double> &data2D, const std::string &label);
 
   void RemoveData(const std::string &label);
 
   void UpdateLabel(const std::string &existingLabel, const std::string &newLabel);
 
   void ClearData();
 
   void SetColor(const std::string &label, const std::string &colorName);
   void SetLineStyle(const std::string &label, LineStyle style);
 
   void SetYAxisScale(AxisScale scale);
 
   void SetXAxisLabel(const std::string &label);
 
   void SetYAxisLabel(const std::string &label);
 
   void SetPieLabels(const std::vector<std::string> &pieLabels, const std::string &label);
 
   void SetTitle(const std::string &title);
 
   void SetXErrorBars(const std::string &label,
                      const std::vector<double> &errorPlus,
                      const std::vector<double> &errorMinus = std::vector<double>());
   void SetYErrorBars(const std::string &label,
                      const std::vector<double> &errorPlus,
                      const std::vector<double> &errorMinus = std::vector<double>());
   std::string GetThemeName() const;
   void SetThemeName(ColorTheme style);
 
   void SetLegendPosition(LegendPosition position);
 
   void Show(bool showSubChart);
 
   void SetShowLegend(bool show);
   void SetShowErrorBars(bool show);
 
   void SetStackedData(bool stacked);
 
   void SetShowDataPoints(bool showDataPoints = false);
 
   void SetShowSubchart(bool showSubChart);
 
   void SetChartType(const std::string &label, QmitkChartWidget::ChartType chartType);
 
   void SetMinMaxValueXView(double minValueX, double maxValueX);
   void SetMinMaxValueYView(double minValueY, double maxValueY);
 
   QList<QVariant> ConvertErrorVectorToQList(const std::vector<double> &error);
   QList<QVariant> ConvertVectorToQList(const std::vector<std::string> &vec);
 
   std::string ConvertChartTypeToString(QmitkChartWidget::ChartType chartType) const;
 
   void ClearJavaScriptChart();
   void InitializeJavaScriptChart();
   void CallJavaScriptFuntion(const QString &command);
 
   QSize sizeHint() const;
 
 private:
   using ChartxyDataVector = std::vector<std::unique_ptr<QmitkChartxyData>>;
   std::string GetUniqueLabelName(const QList<QVariant> &labelList, const std::string &label) const;
   QmitkChartxyData *GetDataElementByLabel(const std::string &label) const;
   QList<QVariant> GetDataLabels(const ChartxyDataVector &c3xyData) const;
 
   QWebChannel *m_WebChannel;
   QWebEngineView *m_WebEngineView;
 
   QmitkChartData m_C3Data;
   ChartxyDataVector m_C3xyData;
   std::map<QmitkChartWidget::ChartType, std::string> m_ChartTypeToName;
   std::map<QmitkChartWidget::ColorTheme, std::string> m_ColorThemeToName;
   std::map<QmitkChartWidget::LegendPosition, std::string> m_LegendPositionToName;
   std::map<QmitkChartWidget::LineStyle, std::string> m_LineStyleToName;
   std::map<QmitkChartWidget::AxisScale, std::string> m_AxisScaleToName;
 };
 
 std::string QmitkChartWidget::Impl::GetThemeName() const
 {
   return m_C3Data.GetThemeName().toString().toStdString();
 }
 
 QmitkChartWidget::Impl::Impl(QWidget *parent)
   : m_WebChannel(new QWebChannel(parent)), m_WebEngineView(new QWebEngineView(parent))
 {
   // disable context menu for QWebEngineView
   m_WebEngineView->setContextMenuPolicy(Qt::NoContextMenu);
 
   m_WebEngineView->setPage(new CustomPage());
 
   // Set the webengineview to an initial empty page. The actual chart will be loaded once the data is calculated.
 
   m_WebEngineView->load(QUrl(QStringLiteral("qrc:///Chart/empty.html")));
   m_WebEngineView->page()->setWebChannel(m_WebChannel);
 
   m_WebEngineView->settings()->setAttribute(QWebEngineSettings::FocusOnNavigationEnabled, false);
 
   connect(m_WebEngineView, SIGNAL(loadFinished(bool)), parent, SLOT(OnLoadFinished(bool)));
   auto layout = new QGridLayout(parent);
   layout->setMargin(0);
   layout->addWidget(m_WebEngineView);
   m_ChartTypeToName.emplace(ChartType::bar, "bar");
   m_ChartTypeToName.emplace(ChartType::line, "line");
   m_ChartTypeToName.emplace(ChartType::spline, "spline");
   m_ChartTypeToName.emplace(ChartType::pie, "pie");
   m_ChartTypeToName.emplace(ChartType::area, "area");
   m_ChartTypeToName.emplace(ChartType::area_spline, "area-spline");
   m_ChartTypeToName.emplace(ChartType::scatter, "scatter");
 
   m_LegendPositionToName.emplace(LegendPosition::bottomMiddle, "bottomMiddle");
   m_LegendPositionToName.emplace(LegendPosition::bottomRight, "bottomRight");
   m_LegendPositionToName.emplace(LegendPosition::topRight, "topRight");
   m_LegendPositionToName.emplace(LegendPosition::topLeft, "topLeft");
   m_LegendPositionToName.emplace(LegendPosition::middleRight, "middleRight");
 
   m_LineStyleToName.emplace(LineStyle::solid, "solid");
   m_LineStyleToName.emplace(LineStyle::dashed, "dashed");
 
   m_AxisScaleToName.emplace(AxisScale::linear, "");
   m_AxisScaleToName.emplace(AxisScale::log, "log");
 
   m_ColorThemeToName.emplace(ColorTheme::lightstyle, "light");
   m_ColorThemeToName.emplace(ColorTheme::darkstyle, "dark");
 }
 
 QmitkChartWidget::Impl::~Impl() {}
 
 std::string CheckForCorrectHex(const std::string &colorName)
 {
   std::regex rgx("([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})");
   std::smatch match;
 
   if (!colorName.empty() && colorName.at(0) != '#' && std::regex_search(colorName.begin(), colorName.end(), match, rgx))
   {
     return "#" + colorName;
   }
   else
   {
     return colorName;
   }
 }
 
 void QmitkChartWidget::Impl::AddData1D(const std::vector<double> &data1D,
                                        const std::string &label,
                                        QmitkChartWidget::ChartType type)
 {
   std::map<double, double> transformedData2D;
   unsigned int count = 0;
   // transform the 1D data to 2D data
   for (const auto &ele : data1D)
   {
     transformedData2D[count] = ele;
     count++;
   }
 
   AddData2D(transformedData2D, label, type);
 }
 
 void QmitkChartWidget::Impl::AddData2D(const std::map<double, double> &data2D,
                                        const std::string &label,
                                        QmitkChartWidget::ChartType type)
 {
   QMap<QVariant, QVariant> data2DConverted;
   for (const auto &aValue : data2D)
   {
     data2DConverted.insert(aValue.first, aValue.second);
   }
   const std::string chartTypeName(m_ChartTypeToName.at(type));
 
   auto definedLabels = GetDataLabels(m_C3xyData);
   auto uniqueLabel = GetUniqueLabelName(definedLabels, label);
   if (type == ChartType::scatter)
   {
     SetShowDataPoints(true);
     MITK_INFO << "Enabling data points for all because of scatter plot";
   }
   unsigned int sizeOfC3xyData = static_cast<unsigned int>(m_C3xyData.size());
   m_C3xyData.push_back(std::make_unique<QmitkChartxyData>(data2DConverted,
                                                           QVariant(QString::fromStdString(uniqueLabel)),
                                                           QVariant(QString::fromStdString(chartTypeName)),
                                                           QVariant(sizeOfC3xyData)));
 }
 
 void QmitkChartWidget::Impl::UpdateData1D(const std::vector<double> &data1D, const std::string &label)
 {
   std::map<double, double> transformedData2D;
   unsigned int count = 0;
   // transform the 1D data to 2D data
   for (const auto &ele : data1D)
   {
     transformedData2D[count] = ele;
     count++;
   }
 
   UpdateData2D(transformedData2D, label);
 }
 
 void QmitkChartWidget::Impl::UpdateData2D(const std::map<double, double> &data2D, const std::string &label)
 {
   auto element = GetDataElementByLabel(label);
   if (element)
   {
     QMap<QVariant, QVariant> data2DConverted;
     for (const auto &aValue : data2D)
     {
       data2DConverted.insert(aValue.first, aValue.second);
     }
     element->SetData(data2DConverted);
   }
 }
 
 void QmitkChartWidget::Impl::RemoveData(const std::string &label)
 {
   for (ChartxyDataVector::iterator iter = m_C3xyData.begin(); iter != m_C3xyData.end(); ++iter)
   {
     if ((*iter)->GetLabel().toString().toStdString() == label)
     {
       m_C3xyData.erase(iter);
       return;
     }
   }
 
   throw std::invalid_argument("Cannot Remove Data because the label does not exist.");
 }
 
 void QmitkChartWidget::Impl::ClearData()
 {
   for (auto &xyData : m_C3xyData)
   {
     m_WebChannel->deregisterObject(xyData.get());
   }
   m_C3xyData.clear();
 }
 
 void QmitkChartWidget::Impl::UpdateLabel(const std::string &existingLabel, const std::string &newLabel) {
   auto element = GetDataElementByLabel(existingLabel);
   if (element)
   {
     auto definedLabels = GetDataLabels(m_C3xyData);
     auto uniqueLabel = GetUniqueLabelName(definedLabels, newLabel);
     element->SetLabel(QString::fromStdString(uniqueLabel));
   }
 }
 
 void QmitkChartWidget::Impl::SetColor(const std::string &label, const std::string &colorName)
 {
   auto element = GetDataElementByLabel(label);
   if (element)
   {
     auto colorChecked = CheckForCorrectHex(colorName);
     element->SetColor(QVariant(QString::fromStdString(colorChecked)));
   }
 }
 
 void QmitkChartWidget::Impl::SetLineStyle(const std::string &label, LineStyle style)
 {
   auto element = GetDataElementByLabel(label);
   const std::string lineStyleName(m_LineStyleToName.at(style));
   element->SetLineStyle(QVariant(QString::fromStdString(lineStyleName)));
 }
 
 void QmitkChartWidget::Impl::SetYAxisScale(AxisScale scale)
 {
   const std::string axisScaleName(m_AxisScaleToName.at(scale));
   m_C3Data.SetYAxisScale(QString::fromStdString(axisScaleName));
 }
 
 QmitkChartxyData *QmitkChartWidget::Impl::GetDataElementByLabel(const std::string &label) const
 {
   for (const auto &qmitkChartxyData : m_C3xyData)
   {
     if (qmitkChartxyData->GetLabel().toString() == label.c_str())
     {
       return qmitkChartxyData.get();
     }
   }
   MITK_WARN << "label " << label << " not found in QmitkChartWidget";
   return nullptr;
 }
 
 QList<QVariant> QmitkChartWidget::Impl::GetDataLabels(const ChartxyDataVector &c3xyData) const
 {
   QList<QVariant> dataLabels;
   for (auto element = c3xyData.begin(); element != c3xyData.end(); ++element)
   {
     dataLabels.push_back((*element)->GetLabel());
   }
   return dataLabels;
 }
 
 void QmitkChartWidget::Impl::SetXAxisLabel(const std::string &label)
 {
   m_C3Data.SetXAxisLabel(QString::fromStdString(label));
 }
 
 void QmitkChartWidget::Impl::SetYAxisLabel(const std::string &label)
 {
   m_C3Data.SetYAxisLabel(QString::fromStdString(label));
 }
 
 void QmitkChartWidget::Impl::SetPieLabels(const std::vector<std::string> &pieLabels, const std::string &label)
 {
   auto element = GetDataElementByLabel(label);
   if (element)
   {
     if (element->GetChartType() == QVariant("pie"))
     {
       auto dataY = element->GetYData();
       element->SetPieLabels(ConvertVectorToQList(pieLabels));
       if (static_cast<unsigned>(dataY.size()) != pieLabels.size())
       {
         MITK_INFO << "data has " << dataY.size() << " entries whereas pie labels have " << pieLabels.size()
                   << " entries. Unnamed pie labels automatically get a numerical label.";
       }
     }
     else
     {
       MITK_INFO << "label" << label << "has chart type " << element->GetChartType().toString().toStdString() << ", but pie is required";
     }
   }
 }
 
 void QmitkChartWidget::Impl::SetTitle(const std::string &title)
 {
   m_C3Data.SetTitle(QString::fromStdString(title));
 }
 
 void QmitkChartWidget::Impl::SetThemeName(QmitkChartWidget::ColorTheme style)
 {
   const std::string themeName(m_ColorThemeToName.at(style));
   m_C3Data.SetThemeName(QString::fromStdString(themeName));
 }
 
 void QmitkChartWidget::Impl::SetLegendPosition(QmitkChartWidget::LegendPosition legendPosition)
 {
   const std::string legendPositionName(m_LegendPositionToName.at(legendPosition));
   m_C3Data.SetLegendPosition(QString::fromStdString(legendPositionName));
 }
 
 void QmitkChartWidget::Impl::Show(bool showSubChart)
 {
   if (m_C3xyData.empty())
   {
     MITK_WARN << "no data available for display in chart";
   }
   else
   {
     m_C3Data.SetAppearance(showSubChart, m_C3xyData.front()->GetChartType() == QVariant("pie"));
   }
 
   InitializeJavaScriptChart();
 }
 
 void QmitkChartWidget::Impl::SetShowLegend(bool show)
 {
   m_C3Data.SetShowLegend(show);
 }
 
 void QmitkChartWidget::Impl::SetStackedData(bool stacked)
 {
   m_C3Data.SetStackedData(stacked);
 }
 
 void QmitkChartWidget::Impl::SetShowErrorBars(bool show)
 {
   m_C3Data.SetShowErrorBars(show);
 }
 
 void QmitkChartWidget::Impl::SetShowDataPoints(bool showDataPoints)
 {
   if (showDataPoints == true)
   {
     m_C3Data.SetDataPointSize(6.5);
   }
   else
   {
     m_C3Data.SetDataPointSize(0);
   }
 }
 
 void QmitkChartWidget::Impl::SetShowSubchart(bool showSubChart) {
   m_C3Data.SetShowSubchart(showSubChart);
 }
 
 void QmitkChartWidget::Impl::SetChartType(const std::string &label, QmitkChartWidget::ChartType chartType)
 {
   auto element = GetDataElementByLabel(label);
   if (element)
   {
     if (chartType == ChartType::scatter)
     {
       SetShowDataPoints(true);
       MITK_INFO << "Enabling data points for all because of scatter plot";
     }
     const std::string chartTypeName(m_ChartTypeToName.at(chartType));
     element->SetChartType(QVariant(QString::fromStdString(chartTypeName)));
   }
 }
 
 void QmitkChartWidget::Impl::SetMinMaxValueXView(double minValueX, double maxValueX) {
   m_C3Data.SetMinValueXView(minValueX);
   m_C3Data.SetMaxValueXView(maxValueX);
 }
 
 void QmitkChartWidget::Impl::SetMinMaxValueYView(double minValueY, double maxValueY) {
   m_C3Data.SetMinValueYView(minValueY);
   m_C3Data.SetMaxValueYView(maxValueY);
 }
 
 QList<QVariant> QmitkChartWidget::Impl::ConvertErrorVectorToQList(const std::vector<double> &error)
 {
   QList<QVariant> errorConverted;
   for (const auto &aValue : error)
   {
     errorConverted.append(aValue);
   }
 
   return errorConverted;
 }
 
 QList<QVariant> QmitkChartWidget::Impl::ConvertVectorToQList(const std::vector<std::string> &vec)
 {
   QList<QVariant> vecConverted;
   for (const auto &aValue : vec)
   {
     vecConverted.append(QString::fromStdString(aValue));
   }
 
   return vecConverted;
 }
 
 void QmitkChartWidget::Impl::SetXErrorBars(const std::string &label,
                                            const std::vector<double> &errorPlus,
                                            const std::vector<double> &errorMinus)
 {
   auto element = GetDataElementByLabel(label);
   if (element)
   {
     auto errorConvertedPlus = ConvertErrorVectorToQList(errorPlus);
     auto errorConvertedMinus = ConvertErrorVectorToQList(errorMinus);
 
     element->SetXErrorDataPlus(errorConvertedPlus);
     element->SetXErrorDataMinus(errorConvertedMinus);
   }
 }
 
 void QmitkChartWidget::Impl::SetYErrorBars(const std::string &label,
                                            const std::vector<double> &errorPlus,
                                            const std::vector<double> &errorMinus)
 {
   auto element = GetDataElementByLabel(label);
   if (element)
   {
     auto errorConvertedPlus = ConvertErrorVectorToQList(errorPlus);
     auto errorConvertedMinus = ConvertErrorVectorToQList(errorMinus);
 
     element->SetYErrorDataPlus(errorConvertedPlus);
     element->SetYErrorDataMinus(errorConvertedMinus);
   }
 }
 
 std::string QmitkChartWidget::Impl::ConvertChartTypeToString(QmitkChartWidget::ChartType chartType) const
 {
   return m_ChartTypeToName.at(chartType);
 }
 
 QSize QmitkChartWidget::Impl::sizeHint() const
 {
   return QSize(400, 300);
 }
 
 void QmitkChartWidget::Impl::CallJavaScriptFuntion(const QString &command)
 {
   m_WebEngineView->page()->runJavaScript(command);
 }
 
 void QmitkChartWidget::Impl::ClearJavaScriptChart()
 {
   m_WebEngineView->load(QUrl(QStringLiteral("qrc:///Chart/empty.html")));
 }
 
 void QmitkChartWidget::Impl::InitializeJavaScriptChart()
 {
   auto alreadyRegisteredObjects = m_WebChannel->registeredObjects();
   auto alreadyRegisteredObjectsValues = alreadyRegisteredObjects.values();
   // only register objects that have not been registered yet
   if (alreadyRegisteredObjectsValues.indexOf(&m_C3Data) == -1)
   {
     m_WebChannel->registerObject(QStringLiteral("chartData"), &m_C3Data);
   }
 
   unsigned count = 0;
   for (auto &xyData : m_C3xyData)
   {
     // only register objects that have not been registered yet
     if (alreadyRegisteredObjectsValues.indexOf(xyData.get()) == -1)
     {
       QString variableName = "xyData" + QString::number(count);
       m_WebChannel->registerObject(variableName, xyData.get());
     }
     count++;
   }
 
   m_WebEngineView->load(QUrl(QStringLiteral("qrc:///Chart/QmitkChartWidget.html")));
 }
 
 std::string QmitkChartWidget::Impl::GetUniqueLabelName(const QList<QVariant> &labelList, const std::string &label) const
 {
   QString currentLabel = QString::fromStdString(label);
   int counter = 0;
   while (labelList.contains(currentLabel))
   {
     currentLabel = QString::fromStdString(label + std::to_string(counter));
     counter++;
   }
   return currentLabel.toStdString();
 }
 
 QmitkChartWidget::QmitkChartWidget(QWidget *parent) : QWidget(parent), m_Impl(new Impl(this))
 {
   connect(this, &QmitkChartWidget::PageSuccessfullyLoaded, this, &QmitkChartWidget::OnPageSuccessfullyLoaded);
 }
 
 QmitkChartWidget::~QmitkChartWidget() {}
 
 void QmitkChartWidget::AddData2D(const std::map<double, double> &data2D, const std::string &label, ChartType type)
 {
   m_Impl->AddData2D(data2D, label, type);
 }
 
 void QmitkChartWidget::SetColor(const std::string &label, const std::string &colorName)
 {
   m_Impl->SetColor(label, colorName);
 }
 
 void QmitkChartWidget::SetLineStyle(const std::string &label, LineStyle style)
 {
   m_Impl->SetLineStyle(label, style);
 }
 
 void QmitkChartWidget::SetYAxisScale(AxisScale scale)
 {
   m_Impl->SetYAxisScale(scale);
 }
 
 void QmitkChartWidget::AddData1D(const std::vector<double> &data1D, const std::string &label, ChartType type)
 {
   m_Impl->AddData1D(data1D, label, type);
 }
 
 void QmitkChartWidget::UpdateData1D(const std::vector<double> &data1D, const std::string &label)
 {
   m_Impl->UpdateData1D(data1D, label);
 }
 
 void QmitkChartWidget::UpdateData2D(const std::map<double, double> &data2D, const std::string &label)
 {
   m_Impl->UpdateData2D(data2D, label);
 }
 
 void QmitkChartWidget::RemoveData(const std::string &label)
 {
   m_Impl->RemoveData(label);
 }
 
 void QmitkChartWidget::UpdateLabel(const std::string &existingLabel, const std::string &newLabel) {
   m_Impl->UpdateLabel(existingLabel, newLabel);
 }
 
 void QmitkChartWidget::SetXAxisLabel(const std::string &label)
 {
   m_Impl->SetXAxisLabel(label);
 }
 
 void QmitkChartWidget::SetYAxisLabel(const std::string &label)
 {
   m_Impl->SetYAxisLabel(label);
 }
 
 void QmitkChartWidget::SetPieLabels(const std::vector<std::string> &pieLabels, const std::string &label)
 {
   m_Impl->SetPieLabels(pieLabels, label);
 }
 
 void QmitkChartWidget::SetTitle(const std::string &title)
 {
   m_Impl->SetTitle(title);
 }
 
 void QmitkChartWidget::SetShowDataPoints(bool showDataPoints)
 {
   m_Impl->SetShowDataPoints(showDataPoints);
 }
 
 void QmitkChartWidget::SetChartType(const std::string &label, ChartType type)
 {
   m_Impl->SetChartType(label, type);
 }
 
 void QmitkChartWidget::SetXErrorBars(const std::string &label,
                                      const std::vector<double> &errorPlus,
                                      const std::vector<double> &errorMinus)
 {
   m_Impl->SetXErrorBars(label, errorPlus, errorMinus);
 }
 
 void QmitkChartWidget::SetYErrorBars(const std::string &label,
                                      const std::vector<double> &errorPlus,
                                      const std::vector<double> &errorMinus)
 {
   m_Impl->SetYErrorBars(label, errorPlus, errorMinus);
 }
 
 void QmitkChartWidget::SetLegendPosition(LegendPosition position)
 {
   m_Impl->SetLegendPosition(position);
 }
 
 void QmitkChartWidget::SetShowLegend(bool show)
 {
   m_Impl->SetShowLegend(show);
 }
 
 void QmitkChartWidget::SetStackedData(bool stacked)
 {
   m_Impl->SetStackedData(stacked);
 }
 
 void QmitkChartWidget::Show(bool showSubChart)
 {
   m_Impl->Show(showSubChart);
 }
 
 void QmitkChartWidget::Clear()
 {
   m_Impl->ClearData();
   m_Impl->ClearJavaScriptChart();
 }
 
 void QmitkChartWidget::OnLoadFinished(bool isLoadSuccessful)
 {
   if (isLoadSuccessful)
   {
     emit PageSuccessfullyLoaded();
   }
 }
 
 void QmitkChartWidget::OnPageSuccessfullyLoaded()
 {
   auto themeName = m_Impl->GetThemeName();
   QString command;
   if (themeName == "dark")
   {
     command = QString("changeTheme('dark')");
   }
   else
   {
     command = QString("changeTheme('light')");
   }
 
   m_Impl->CallJavaScriptFuntion(command);
 }
 
 void QmitkChartWidget::SetTheme(ColorTheme themeEnabled)
 {
   m_Impl->SetThemeName(themeEnabled);
 }
 
 void QmitkChartWidget::SetShowSubchart(bool showSubChart)
 {
   m_Impl->SetShowSubchart(showSubChart);
 }
 
 void QmitkChartWidget::SetShowErrorBars(bool showErrorBars)
 {
   m_Impl->SetShowErrorBars(showErrorBars);
 }
 
 void QmitkChartWidget::SetMinMaxValueXView(double minValueX, double maxValueX)
 {
   m_Impl->SetMinMaxValueXView(minValueX, maxValueX);
 }
 
 void QmitkChartWidget::SetMinMaxValueYView(double minValueY, double maxValueY)
 {
   m_Impl->SetMinMaxValueYView(minValueY, maxValueY);
 }
 
 void QmitkChartWidget::Reload()
 {
   const QString command = QString("Reload()");
   m_Impl->CallJavaScriptFuntion(command);
 }
 
 QSize QmitkChartWidget::sizeHint() const
 {
   return m_Impl->sizeHint();
 }
diff --git a/Modules/Classification/CLVigraRandomForest/src/Classifier/mitkPURFClassifier.cpp b/Modules/Classification/CLVigraRandomForest/src/Classifier/mitkPURFClassifier.cpp
index 1210f113ca..64919fa6d2 100644
--- a/Modules/Classification/CLVigraRandomForest/src/Classifier/mitkPURFClassifier.cpp
+++ b/Modules/Classification/CLVigraRandomForest/src/Classifier/mitkPURFClassifier.cpp
@@ -1,478 +1,478 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // MITK includes
 #include <mitkPURFClassifier.h>
 #include <mitkThresholdSplit.h>
 #include <mitkPUImpurityLoss.h>
 #include <mitkImpurityLoss.h>
 #include <mitkLinearSplitting.h>
 #include <mitkProperties.h>
 
 // Vigra includes
 #include <vigra/random_forest.hxx>
 #include <vigra/random_forest/rf_split.hxx>
 
 // ITK include
 #include <itkFastMutexLock.h>
 #include <itkMultiThreader.h>
 #include <itkCommand.h>
 
 typedef mitk::ThresholdSplit<mitk::LinearSplitting< mitk::PUImpurityLoss<> >,int,vigra::ClassificationTag> DefaultPUSplitType;
 
 struct mitk::PURFClassifier::Parameter
 {
   vigra::RF_OptionTag Stratification;
   bool SampleWithReplacement;
   bool UseRandomSplit;
   bool UsePointBasedWeights;
   int TreeCount;
   int MinimumSplitNodeSize;
   int TreeDepth;
   double Precision;
   double WeightLambda;
   double SamplesPerTree;
 };
 
 struct mitk::PURFClassifier::TrainingData
 {
   TrainingData(unsigned int numberOfTrees,
     const vigra::RandomForest<int> & refRF,
     const DefaultPUSplitType & refSplitter,
     const vigra::MultiArrayView<2, double> refFeature,
     const vigra::MultiArrayView<2, int> refLabel,
     const Parameter parameter)
     : m_ClassCount(0),
     m_NumberOfTrees(numberOfTrees),
     m_RandomForest(refRF),
     m_Splitter(refSplitter),
     m_Feature(refFeature),
     m_Label(refLabel),
     m_Parameter(parameter)
   {
     m_mutex = itk::FastMutexLock::New();
   }
   vigra::ArrayVector<vigra::RandomForest<int>::DecisionTree_t>  trees_;
 
   int m_ClassCount;
   unsigned int m_NumberOfTrees;
   const vigra::RandomForest<int> & m_RandomForest;
   const DefaultPUSplitType & m_Splitter;
   const vigra::MultiArrayView<2, double> m_Feature;
   const vigra::MultiArrayView<2, int> m_Label;
   itk::FastMutexLock::Pointer m_mutex;
   Parameter m_Parameter;
 };
 
 struct mitk::PURFClassifier::PredictionData
 {
   PredictionData(const vigra::RandomForest<int> & refRF,
     const vigra::MultiArrayView<2, double> refFeature,
     vigra::MultiArrayView<2, int> refLabel,
     vigra::MultiArrayView<2, double> refProb,
     vigra::MultiArrayView<2, double> refTreeWeights)
     : m_RandomForest(refRF),
     m_Feature(refFeature),
     m_Label(refLabel),
     m_Probabilities(refProb),
     m_TreeWeights(refTreeWeights)
   {
   }
   const vigra::RandomForest<int> & m_RandomForest;
   const vigra::MultiArrayView<2, double> m_Feature;
   vigra::MultiArrayView<2, int> m_Label;
   vigra::MultiArrayView<2, double> m_Probabilities;
   vigra::MultiArrayView<2, double> m_TreeWeights;
 };
 
 mitk::PURFClassifier::PURFClassifier()
   :m_Parameter(nullptr)
 {
   itk::SimpleMemberCommand<mitk::PURFClassifier>::Pointer command = itk::SimpleMemberCommand<mitk::PURFClassifier>::New();
   command->SetCallbackFunction(this, &mitk::PURFClassifier::ConvertParameter);
   this->GetPropertyList()->AddObserver( itk::ModifiedEvent(), command );
 }
 
 mitk::PURFClassifier::~PURFClassifier()
 {
 }
 
 void mitk::PURFClassifier::SetClassProbabilities(Eigen::VectorXd probabilities)
 {
   m_ClassProbabilities = probabilities;
 }
 
 Eigen::VectorXd mitk::PURFClassifier::GetClassProbabilites()
 {
   return m_ClassProbabilities;
 }
 
 bool mitk::PURFClassifier::SupportsPointWiseWeight()
 {
   return true;
 }
 
 bool mitk::PURFClassifier::SupportsPointWiseProbability()
 {
   return true;
 }
 
 
 vigra::ArrayVector<double> mitk::PURFClassifier::CalculateKappa(const Eigen::MatrixXd & /* X_in */, const Eigen::MatrixXi & Y_in)
 {
   int maximumValue = Y_in.maxCoeff();
   vigra::ArrayVector<double> kappa(maximumValue + 1);
   vigra::ArrayVector<double> counts(maximumValue + 1);
   for (int i = 0; i < Y_in.rows(); ++i)
   {
     counts[Y_in(i, 0)] += 1;
   }
   for (int i = 0; i < maximumValue+1; ++i)
   {
     if (counts[i] > 0)
     {
       kappa[i] = counts[0] * m_ClassProbabilities[i] / counts[i] + 1;
     }
     else
     {
       kappa[i] = 1;
     }
   }
   return kappa;
 }
 
 
 void mitk::PURFClassifier::Train(const Eigen::MatrixXd & X_in, const Eigen::MatrixXi &Y_in)
 {
   this->ConvertParameter();
 
   PURFData* purfData = new PURFData;
   purfData->m_Kappa = this->CalculateKappa(X_in, Y_in);
 
   DefaultPUSplitType splitter;
   splitter.UsePointBasedWeights(m_Parameter->UsePointBasedWeights);
   splitter.UseRandomSplit(m_Parameter->UseRandomSplit);
   splitter.SetPrecision(m_Parameter->Precision);
   splitter.SetMaximumTreeDepth(m_Parameter->TreeDepth);
   splitter.SetAdditionalData(purfData);
 
   // Weights handled as member variable
   if (m_Parameter->UsePointBasedWeights)
   {
     // Set influence of the weight (0 no influenc to 1 max influence)
     this->m_PointWiseWeight.unaryExpr([this](double t){ return std::pow(t, this->m_Parameter->WeightLambda) ;});
 
     vigra::MultiArrayView<2, double> W(vigra::Shape2(this->m_PointWiseWeight.rows(),this->m_PointWiseWeight.cols()),this->m_PointWiseWeight.data());
     splitter.SetWeights(W);
   }
 
   vigra::MultiArrayView<2, double> X(vigra::Shape2(X_in.rows(),X_in.cols()),X_in.data());
   vigra::MultiArrayView<2, int> Y(vigra::Shape2(Y_in.rows(),Y_in.cols()),Y_in.data());
 
   m_RandomForest.set_options().tree_count(1); // Number of trees that are calculated;
 
   m_RandomForest.set_options().use_stratification(m_Parameter->Stratification);
   m_RandomForest.set_options().sample_with_replacement(m_Parameter->SampleWithReplacement);
   m_RandomForest.set_options().samples_per_tree(m_Parameter->SamplesPerTree);
   m_RandomForest.set_options().min_split_node_size(m_Parameter->MinimumSplitNodeSize);
 
   m_RandomForest.learn(X, Y,vigra::rf::visitors::VisitorBase(),splitter);
 
   std::unique_ptr<TrainingData> data(new TrainingData(m_Parameter->TreeCount,m_RandomForest,splitter,X,Y, *m_Parameter));
 
   itk::MultiThreader::Pointer threader = itk::MultiThreader::New();
   threader->SetSingleMethod(this->TrainTreesCallback,data.get());
   threader->SingleMethodExecute();
 
   // set result trees
   m_RandomForest.set_options().tree_count(m_Parameter->TreeCount);
   m_RandomForest.ext_param_.class_count_ = data->m_ClassCount;
   m_RandomForest.trees_ = data->trees_;
 
   // Set Tree Weights to default
   m_TreeWeights = Eigen::MatrixXd(m_Parameter->TreeCount,1);
   m_TreeWeights.fill(1.0);
   delete purfData;
 }
 
 Eigen::MatrixXi mitk::PURFClassifier::Predict(const Eigen::MatrixXd &X_in)
 {
   // Initialize output Eigen matrices
   m_OutProbability = Eigen::MatrixXd(X_in.rows(),m_RandomForest.class_count());
   m_OutProbability.fill(0);
   m_OutLabel = Eigen::MatrixXi(X_in.rows(),1);
   m_OutLabel.fill(0);
 
   // If no weights provided
   if(m_TreeWeights.rows() != m_RandomForest.tree_count())
   {
     m_TreeWeights = Eigen::MatrixXd(m_RandomForest.tree_count(),1);
     m_TreeWeights.fill(1);
   }
 
   vigra::MultiArrayView<2, double> P(vigra::Shape2(m_OutProbability.rows(),m_OutProbability.cols()),m_OutProbability.data());
   vigra::MultiArrayView<2, int> Y(vigra::Shape2(m_OutLabel.rows(),m_OutLabel.cols()),m_OutLabel.data());
   vigra::MultiArrayView<2, double> X(vigra::Shape2(X_in.rows(),X_in.cols()),X_in.data());
   vigra::MultiArrayView<2, double> TW(vigra::Shape2(m_RandomForest.tree_count(),1),m_TreeWeights.data());
 
   std::unique_ptr<PredictionData> data;
   data.reset(new PredictionData(m_RandomForest, X, Y, P, TW));
 
   itk::MultiThreader::Pointer threader = itk::MultiThreader::New();
   threader->SetSingleMethod(this->PredictCallback, data.get());
   threader->SingleMethodExecute();
 
   m_Probabilities = data->m_Probabilities;
   return m_OutLabel;
 }
 
 ITK_THREAD_RETURN_TYPE mitk::PURFClassifier::TrainTreesCallback(void * arg)
 {
   // Get the ThreadInfoStruct
   typedef itk::MultiThreader::ThreadInfoStruct  ThreadInfoType;
   ThreadInfoType * infoStruct = static_cast< ThreadInfoType * >( arg );
 
   TrainingData * data = (TrainingData *)(infoStruct->UserData);
   unsigned int numberOfTreesToCalculate = 0;
 
   // define the number of tress the forest have to calculate
   numberOfTreesToCalculate = data->m_NumberOfTrees / infoStruct->NumberOfThreads;
 
   // the 0th thread takes the residuals
   if(infoStruct->ThreadID == 0) numberOfTreesToCalculate += data->m_NumberOfTrees % infoStruct->NumberOfThreads;
 
   if(numberOfTreesToCalculate != 0){
     // Copy the Treestructure defined in userData
     vigra::RandomForest<int> rf = data->m_RandomForest;
 
     // Initialize a splitter for the leraning process
     DefaultPUSplitType splitter;
     splitter.UsePointBasedWeights(data->m_Splitter.IsUsingPointBasedWeights());
     splitter.UseRandomSplit(data->m_Splitter.IsUsingRandomSplit());
     splitter.SetPrecision(data->m_Splitter.GetPrecision());
     splitter.SetMaximumTreeDepth(data->m_Splitter.GetMaximumTreeDepth());
     splitter.SetWeights(data->m_Splitter.GetWeights());
     splitter.SetAdditionalData(data->m_Splitter.GetAdditionalData());
 
     rf.trees_.clear();
     rf.set_options().tree_count(numberOfTreesToCalculate);
     rf.set_options().use_stratification(data->m_Parameter.Stratification);
     rf.set_options().sample_with_replacement(data->m_Parameter.SampleWithReplacement);
     rf.set_options().samples_per_tree(data->m_Parameter.SamplesPerTree);
     rf.set_options().min_split_node_size(data->m_Parameter.MinimumSplitNodeSize);
     rf.learn(data->m_Feature, data->m_Label,vigra::rf::visitors::VisitorBase(),splitter);
 
     data->m_mutex->Lock();
 
     for(const auto & tree : rf.trees_)
       data->trees_.push_back(tree);
 
     data->m_ClassCount = rf.class_count();
     data->m_mutex->Unlock();
   }
 
-  return NULL;
+  return nullptr;
 
 }
 
 ITK_THREAD_RETURN_TYPE mitk::PURFClassifier::PredictCallback(void * arg)
 {
   // Get the ThreadInfoStruct
   typedef itk::MultiThreader::ThreadInfoStruct  ThreadInfoType;
   ThreadInfoType * infoStruct = static_cast< ThreadInfoType * >( arg );
   // assigne the thread id
   const unsigned int threadId = infoStruct->ThreadID;
 
   // Get the user defined parameters containing all
   // neccesary informations
   PredictionData * data = (PredictionData *)(infoStruct->UserData);
   unsigned int numberOfRowsToCalculate = 0;
 
   // Get number of rows to calculate
   numberOfRowsToCalculate = data->m_Feature.shape()[0] / infoStruct->NumberOfThreads;
 
   unsigned int start_index = numberOfRowsToCalculate * threadId;
   unsigned int end_index = numberOfRowsToCalculate * (threadId+1);
 
   // the last thread takes the residuals
   if(threadId == infoStruct->NumberOfThreads-1) {
     end_index += data->m_Feature.shape()[0] % infoStruct->NumberOfThreads;
   }
 
   vigra::MultiArrayView<2, double> split_features;
   vigra::MultiArrayView<2, int> split_labels;
   vigra::MultiArrayView<2, double> split_probability;
   {
     vigra::TinyVector<vigra::MultiArrayIndex, 2> lowerBound(start_index,0);
     vigra::TinyVector<vigra::MultiArrayIndex, 2> upperBound(end_index,data->m_Feature.shape(1));
     split_features = data->m_Feature.subarray(lowerBound,upperBound);
   }
 
   {
     vigra::TinyVector<vigra::MultiArrayIndex, 2> lowerBound(start_index,0);
     vigra::TinyVector<vigra::MultiArrayIndex, 2> upperBound(end_index, data->m_Label.shape(1));
     split_labels = data->m_Label.subarray(lowerBound,upperBound);
   }
 
   {
     vigra::TinyVector<vigra::MultiArrayIndex, 2> lowerBound(start_index,0);
     vigra::TinyVector<vigra::MultiArrayIndex, 2> upperBound(end_index,data->m_Probabilities.shape(1));
     split_probability = data->m_Probabilities.subarray(lowerBound,upperBound);
   }
 
   data->m_RandomForest.predictLabels(split_features,split_labels);
   data->m_RandomForest.predictProbabilities(split_features, split_probability);
 
 
-  return NULL;
+  return nullptr;
 
 }
 
 void  mitk::PURFClassifier::ConvertParameter()
 {
   if(this->m_Parameter == nullptr)
     this->m_Parameter = new Parameter();
   // Get the proerty                                                                      // Some defaults
 
   MITK_INFO("PURFClassifier") << "Convert Parameter";
   if(!this->GetPropertyList()->Get("usepointbasedweight",this->m_Parameter->UsePointBasedWeights))      this->m_Parameter->UsePointBasedWeights = false;
   if(!this->GetPropertyList()->Get("userandomsplit",this->m_Parameter->UseRandomSplit))                 this->m_Parameter->UseRandomSplit = false;
   if(!this->GetPropertyList()->Get("treedepth",this->m_Parameter->TreeDepth))                           this->m_Parameter->TreeDepth = 20;
   if(!this->GetPropertyList()->Get("treecount",this->m_Parameter->TreeCount))                           this->m_Parameter->TreeCount = 100;
   if(!this->GetPropertyList()->Get("minimalsplitnodesize",this->m_Parameter->MinimumSplitNodeSize))     this->m_Parameter->MinimumSplitNodeSize = 5;
   if(!this->GetPropertyList()->Get("precision",this->m_Parameter->Precision))                           this->m_Parameter->Precision = mitk::eps;
   if(!this->GetPropertyList()->Get("samplespertree",this->m_Parameter->SamplesPerTree))                 this->m_Parameter->SamplesPerTree = 0.6;
   if(!this->GetPropertyList()->Get("samplewithreplacement",this->m_Parameter->SampleWithReplacement))   this->m_Parameter->SampleWithReplacement = true;
   if(!this->GetPropertyList()->Get("lambda",this->m_Parameter->WeightLambda))                           this->m_Parameter->WeightLambda = 1.0; // Not used yet
   //  if(!this->GetPropertyList()->Get("samplewithreplacement",this->m_Parameter->Stratification))
   this->m_Parameter->Stratification = vigra::RF_NONE; // no Property given
 }
 
 void mitk::PURFClassifier::PrintParameter(std::ostream & str)
 {
   if(this->m_Parameter == nullptr)
   {
     MITK_WARN("PURFClassifier") << "Parameters are not initialized. Please call ConvertParameter() first!";
     return;
   }
 
   this->ConvertParameter();
 
   // Get the proerty                                                                      // Some defaults
   if(!this->GetPropertyList()->Get("usepointbasedweight",this->m_Parameter->UsePointBasedWeights))
     str << "usepointbasedweight\tNOT SET (default " << this->m_Parameter->UsePointBasedWeights << ")" << "\n";
   else
     str << "usepointbasedweight\t" << this->m_Parameter->UsePointBasedWeights << "\n";
 
   if(!this->GetPropertyList()->Get("userandomsplit",this->m_Parameter->UseRandomSplit))
     str << "userandomsplit\tNOT SET (default " << this->m_Parameter->UseRandomSplit << ")" << "\n";
   else
     str << "userandomsplit\t" << this->m_Parameter->UseRandomSplit << "\n";
 
   if(!this->GetPropertyList()->Get("treedepth",this->m_Parameter->TreeDepth))
     str << "treedepth\t\tNOT SET (default " << this->m_Parameter->TreeDepth << ")" << "\n";
   else
     str << "treedepth\t\t" << this->m_Parameter->TreeDepth << "\n";
 
   if(!this->GetPropertyList()->Get("minimalsplitnodesize",this->m_Parameter->MinimumSplitNodeSize))
     str << "minimalsplitnodesize\tNOT SET (default " << this->m_Parameter->MinimumSplitNodeSize << ")" << "\n";
   else
     str << "minimalsplitnodesize\t" << this->m_Parameter->MinimumSplitNodeSize << "\n";
 
   if(!this->GetPropertyList()->Get("precision",this->m_Parameter->Precision))
     str << "precision\t\tNOT SET (default " << this->m_Parameter->Precision << ")" << "\n";
   else
     str << "precision\t\t" << this->m_Parameter->Precision << "\n";
 
   if(!this->GetPropertyList()->Get("samplespertree",this->m_Parameter->SamplesPerTree))
     str << "samplespertree\tNOT SET (default " << this->m_Parameter->SamplesPerTree << ")" << "\n";
   else
     str << "samplespertree\t" << this->m_Parameter->SamplesPerTree << "\n";
 
   if(!this->GetPropertyList()->Get("samplewithreplacement",this->m_Parameter->SampleWithReplacement))
     str << "samplewithreplacement\tNOT SET (default " << this->m_Parameter->SampleWithReplacement << ")" << "\n";
   else
     str << "samplewithreplacement\t" << this->m_Parameter->SampleWithReplacement << "\n";
 
   if(!this->GetPropertyList()->Get("treecount",this->m_Parameter->TreeCount))
     str << "treecount\t\tNOT SET (default " << this->m_Parameter->TreeCount << ")" << "\n";
   else
     str << "treecount\t\t" << this->m_Parameter->TreeCount << "\n";
 
   if(!this->GetPropertyList()->Get("lambda",this->m_Parameter->WeightLambda))
     str << "lambda\t\tNOT SET (default " << this->m_Parameter->WeightLambda << ")" << "\n";
   else
     str << "lambda\t\t" << this->m_Parameter->WeightLambda << "\n";
 
   //  if(!this->GetPropertyList()->Get("samplewithreplacement",this->m_Parameter->Stratification))
   //  this->m_Parameter->Stratification = vigra:RF_NONE; // no Property given
 }
 
 void mitk::PURFClassifier::UsePointWiseWeight(bool val)
 {
   mitk::AbstractClassifier::UsePointWiseWeight(val);
   this->GetPropertyList()->SetBoolProperty("usepointbasedweight",val);
 }
 
 void mitk::PURFClassifier::SetMaximumTreeDepth(int val)
 {
   this->GetPropertyList()->SetIntProperty("treedepth",val);
 }
 
 void mitk::PURFClassifier::SetMinimumSplitNodeSize(int val)
 {
   this->GetPropertyList()->SetIntProperty("minimalsplitnodesize",val);
 }
 
 void mitk::PURFClassifier::SetPrecision(double val)
 {
   this->GetPropertyList()->SetDoubleProperty("precision",val);
 }
 
 void mitk::PURFClassifier::SetSamplesPerTree(double val)
 {
   this->GetPropertyList()->SetDoubleProperty("samplespertree",val);
 }
 
 void mitk::PURFClassifier::UseSampleWithReplacement(bool val)
 {
   this->GetPropertyList()->SetBoolProperty("samplewithreplacement",val);
 }
 
 void mitk::PURFClassifier::SetTreeCount(int val)
 {
   this->GetPropertyList()->SetIntProperty("treecount",val);
 }
 
 void mitk::PURFClassifier::SetWeightLambda(double val)
 {
   this->GetPropertyList()->SetDoubleProperty("lambda",val);
 }
 
 void mitk::PURFClassifier::SetRandomForest(const vigra::RandomForest<int> & rf)
 {
   this->SetMaximumTreeDepth(rf.ext_param().max_tree_depth);
   this->SetMinimumSplitNodeSize(rf.options().min_split_node_size_);
   this->SetTreeCount(rf.options().tree_count_);
   this->SetSamplesPerTree(rf.options().training_set_proportion_);
   this->UseSampleWithReplacement(rf.options().sample_with_replacement_);
   this->m_RandomForest = rf;
 }
 
 const vigra::RandomForest<int> & mitk::PURFClassifier::GetRandomForest() const
 {
   return this->m_RandomForest;
 }
diff --git a/Modules/CppMicroServices/third_party/jsoncpp.h b/Modules/CppMicroServices/third_party/jsoncpp.h
index f3285a70c6..f8a746efc5 100644
--- a/Modules/CppMicroServices/third_party/jsoncpp.h
+++ b/Modules/CppMicroServices/third_party/jsoncpp.h
@@ -1,1855 +1,1855 @@
 /// Json-cpp amalgated header (http://jsoncpp.sourceforge.net/).
 /// It is intented to be used with #include <json/json.h>
 
 // //////////////////////////////////////////////////////////////////////
 // Beginning of content of file: LICENSE
 // //////////////////////////////////////////////////////////////////////
 
 /*
 The JsonCpp library's source code, including accompanying documentation,
 tests and demonstration applications, are licensed under the following
 conditions...
 
 The author (Baptiste Lepilleur) explicitly disclaims copyright in all
 jurisdictions which recognize such a disclaimer. In such jurisdictions,
 this software is released into the Public Domain.
 
 In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
 2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is
 released under the terms of the MIT License (see below).
 
 In jurisdictions which recognize Public Domain property, the user of this
 software may choose to accept it either as 1) Public Domain, 2) under the
 conditions of the MIT License (see below), or 3) under the terms of dual
 Public Domain/MIT License conditions described here, as they choose.
 
 The MIT License is about as close to Public Domain as a license can get, and is
 described in clear, concise terms at:
 
    http://en.wikipedia.org/wiki/MIT_License
 
 The full text of the MIT License follows:
 
 ========================================================================
 Copyright (c) 2007-2010 Baptiste Lepilleur
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
 files (the "Software"), to deal in the Software without
 restriction, including without limitation the rights to use, copy,
 modify, merge, publish, distribute, sublicense, and/or sell copies
 of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ========================================================================
 (END LICENSE TEXT)
 
 The MIT license is compatible with both the GPL and commercial
 software, affording one all of the rights of Public Domain with the
 minor nuisance of being required to keep the above copyright notice
 and license text in the source code. Note also that by accepting the
 Public Domain "license" you can re-license your copy using whatever
 license you like.
 
 */
 
 // //////////////////////////////////////////////////////////////////////
 // End of content of file: LICENSE
 // //////////////////////////////////////////////////////////////////////
 
 
 
 
 
 #ifndef JSON_AMALGATED_H_INCLUDED
 # define JSON_AMALGATED_H_INCLUDED
 /// If defined, indicates that the source file is amalgated
 /// to prevent private header inclusion.
 #define JSON_IS_AMALGATED
 
 // //////////////////////////////////////////////////////////////////////
 // Beginning of content of file: include/json/config.h
 // //////////////////////////////////////////////////////////////////////
 
 // Copyright 2007-2010 Baptiste Lepilleur
 // Distributed under MIT license, or public domain if desired and
 // recognized in your jurisdiction.
 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
 #ifndef JSON_CONFIG_H_INCLUDED
 # define JSON_CONFIG_H_INCLUDED
 
 /// If defined, indicates that json library is embedded in CppTL library.
 //# define JSON_IN_CPPTL 1
 
 /// If defined, indicates that json may leverage CppTL library
 //#  define JSON_USE_CPPTL 1
 /// If defined, indicates that cpptl vector based map should be used instead of std::map
 /// as Value container.
 //#  define JSON_USE_CPPTL_SMALLMAP 1
 /// If defined, indicates that Json specific container should be used
 /// (hash table & simple deque container with customizable allocator).
 /// THIS FEATURE IS STILL EXPERIMENTAL! There is know bugs: See #3177332
 //#  define JSON_VALUE_USE_INTERNAL_MAP 1
 /// Force usage of standard new/malloc based allocator instead of memory pool based allocator.
 /// The memory pools allocator used optimization (initializing Value and ValueInternalLink
 /// as if it was a POD) that may cause some validation tool to report errors.
 /// Only has effects if JSON_VALUE_USE_INTERNAL_MAP is defined.
 //#  define JSON_USE_SIMPLE_INTERNAL_ALLOCATOR 1
 
 /// If defined, indicates that Json use exception to report invalid type manipulation
 /// instead of C assert macro.
 # define JSON_USE_EXCEPTION 1
 
 /// If defined, indicates that the source file is amalgated
 /// to prevent private header inclusion.
 /// Remarks: it is automatically defined in the generated amalgated header.
 #define JSON_IS_AMALGAMATION
 
 
 # ifdef JSON_IN_CPPTL
 #  include <cpptl/config.h>
 #  ifndef JSON_USE_CPPTL
 #   define JSON_USE_CPPTL 1
 #  endif
 # endif
 
 # ifdef JSON_IN_CPPTL
 #  define JSON_API CPPTL_API
 # elif defined(JSON_DLL_BUILD)
 #  define JSON_API __declspec(dllexport)
 # elif defined(JSON_DLL)
 #  define JSON_API __declspec(dllimport)
 # else
 #  define JSON_API
 # endif
 
 // If JSON_NO_INT64 is defined, then Json only support C++ "int" type for integer
 // Storages, and 64 bits integer support is disabled.
 // #define JSON_NO_INT64 1
 
 #if defined(_MSC_VER)  &&  _MSC_VER <= 1200 // MSVC 6
 // Microsoft Visual Studio 6 only support conversion from __int64 to double
 // (no conversion from unsigned __int64).
 #define JSON_USE_INT64_DOUBLE_CONVERSION 1
 #endif // if defined(_MSC_VER)  &&  _MSC_VER < 1200 // MSVC 6
 
 #if defined(_MSC_VER)  &&  _MSC_VER >= 1500 // MSVC 2008
 /// Indicates that the following function is deprecated.
 # define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
 #endif
 
 #if !defined(JSONCPP_DEPRECATED)
 # define JSONCPP_DEPRECATED(message)
 #endif // if !defined(JSONCPP_DEPRECATED)
 
 namespace Json {
    typedef int Int;
    typedef unsigned int UInt;
 # if defined(JSON_NO_INT64)
    typedef int LargestInt;
    typedef unsigned int LargestUInt;
 #  undef JSON_HAS_INT64
 # else // if defined(JSON_NO_INT64)
    // For Microsoft Visual use specific types as long long is not supported
 #  if defined(_MSC_VER) // Microsoft Visual Studio
    typedef __int64 Int64;
    typedef unsigned __int64 UInt64;
 #  else // if defined(_MSC_VER) // Other platforms, use long long
    typedef long long int Int64;
    typedef unsigned long long int UInt64;
 #  endif // if defined(_MSC_VER)
    typedef Int64 LargestInt;
    typedef UInt64 LargestUInt;
 #  define JSON_HAS_INT64
 # endif // if defined(JSON_NO_INT64)
 } // end namespace Json
 
 
 #endif // JSON_CONFIG_H_INCLUDED
 
 // //////////////////////////////////////////////////////////////////////
 // End of content of file: include/json/config.h
 // //////////////////////////////////////////////////////////////////////
 
 
 
 
 
 
 // //////////////////////////////////////////////////////////////////////
 // Beginning of content of file: include/json/forwards.h
 // //////////////////////////////////////////////////////////////////////
 
 // Copyright 2007-2010 Baptiste Lepilleur
 // Distributed under MIT license, or public domain if desired and
 // recognized in your jurisdiction.
 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
 #ifndef JSON_FORWARDS_H_INCLUDED
 # define JSON_FORWARDS_H_INCLUDED
 
 #if !defined(JSON_IS_AMALGAMATION)
 # include "config.h"
 #endif // if !defined(JSON_IS_AMALGAMATION)
 
 namespace Json {
 
    // writer.h
    class FastWriter;
    class StyledWriter;
 
    // reader.h
    class Reader;
 
    // features.h
    class Features;
 
    // value.h
    typedef unsigned int ArrayIndex;
    class StaticString;
    class Path;
    class PathArgument;
    class Value;
    class ValueIteratorBase;
    class ValueIterator;
    class ValueConstIterator;
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
    class ValueMapAllocator;
    class ValueInternalLink;
    class ValueInternalArray;
    class ValueInternalMap;
 #endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP
 
 } // namespace Json
 
 
 #endif // JSON_FORWARDS_H_INCLUDED
 
 // //////////////////////////////////////////////////////////////////////
 // End of content of file: include/json/forwards.h
 // //////////////////////////////////////////////////////////////////////
 
 
 
 
 
 
 // //////////////////////////////////////////////////////////////////////
 // Beginning of content of file: include/json/features.h
 // //////////////////////////////////////////////////////////////////////
 
 // Copyright 2007-2010 Baptiste Lepilleur
 // Distributed under MIT license, or public domain if desired and
 // recognized in your jurisdiction.
 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
 #ifndef CPPTL_JSON_FEATURES_H_INCLUDED
 # define CPPTL_JSON_FEATURES_H_INCLUDED
 
 #if !defined(JSON_IS_AMALGAMATION)
 # include "forwards.h"
 #endif // if !defined(JSON_IS_AMALGAMATION)
 
 namespace Json {
 
    /** \brief Configuration passed to reader and writer.
     * This configuration object can be used to force the Reader or Writer
     * to behave in a standard conforming way.
     */
    class JSON_API Features
    {
    public:
       /** \brief A configuration that allows all features and assumes all strings are UTF-8.
        * - C & C++ comments are allowed
        * - Root object can be any JSON value
        * - Assumes Value strings are encoded in UTF-8
        */
       static Features all();
 
       /** \brief A configuration that is strictly compatible with the JSON specification.
        * - Comments are forbidden.
        * - Root object must be either an array or an object value.
        * - Assumes Value strings are encoded in UTF-8
        */
       static Features strictMode();
 
       /** \brief Initialize the configuration like JsonConfig::allFeatures;
        */
       Features();
 
       /// \c true if comments are allowed. Default: \c true.
       bool allowComments_;
 
       /// \c true if root must be either an array or an object value. Default: \c false.
       bool strictRoot_;
    };
 
 } // namespace Json
 
 #endif // CPPTL_JSON_FEATURES_H_INCLUDED
 
 // //////////////////////////////////////////////////////////////////////
 // End of content of file: include/json/features.h
 // //////////////////////////////////////////////////////////////////////
 
 
 
 
 
 
 // //////////////////////////////////////////////////////////////////////
 // Beginning of content of file: include/json/value.h
 // //////////////////////////////////////////////////////////////////////
 
 // Copyright 2007-2010 Baptiste Lepilleur
 // Distributed under MIT license, or public domain if desired and
 // recognized in your jurisdiction.
 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
 #ifndef CPPTL_JSON_H_INCLUDED
 # define CPPTL_JSON_H_INCLUDED
 
 #if !defined(JSON_IS_AMALGAMATION)
 # include "forwards.h"
 #endif // if !defined(JSON_IS_AMALGAMATION)
 # include <string>
 # include <vector>
 
 # ifndef JSON_USE_CPPTL_SMALLMAP
 #  include <map>
 # else
 #  include <cpptl/smallmap.h>
 # endif
 # ifdef JSON_USE_CPPTL
 #  include <cpptl/forwards.h>
 # endif
 
 /** \brief JSON (JavaScript Object Notation).
  */
 namespace Json {
 
    /** \brief Type of the value held by a Value object.
     */
    enum ValueType
    {
       nullValue = 0, ///< 'null' value
       intValue,      ///< signed integer value
       uintValue,     ///< unsigned integer value
       realValue,     ///< double value
       stringValue,   ///< UTF-8 string value
       booleanValue,  ///< bool value
       arrayValue,    ///< array value (ordered list)
       objectValue    ///< object value (collection of name/value pairs).
    };
 
    enum CommentPlacement
    {
       commentBefore = 0,        ///< a comment placed on the line before a value
       commentAfterOnSameLine,   ///< a comment just after a value on the same line
       commentAfter,             ///< a comment on the line after a value (only make sense for root value)
       numberOfCommentPlacement
    };
 
 //# ifdef JSON_USE_CPPTL
 //   typedef CppTL::AnyEnumerator<const char *> EnumMemberNames;
 //   typedef CppTL::AnyEnumerator<const Value &> EnumValues;
 //# endif
 
    /** \brief Lightweight wrapper to tag static string.
     *
     * Value constructor and objectValue member assignement takes advantage of the
     * StaticString and avoid the cost of string duplication when storing the
     * string or the member name.
     *
     * Example of usage:
     * \code
     * Json::Value aValue( StaticString("some text") );
     * Json::Value object;
     * static const StaticString code("code");
     * object[code] = 1234;
     * \endcode
     */
    class JSON_API StaticString
    {
    public:
       explicit StaticString( const char *czstring )
          : str_( czstring )
       {
       }
 
       operator const char *() const
       {
          return str_;
       }
 
       const char *c_str() const
       {
          return str_;
       }
 
    private:
       const char *str_;
    };
 
    /** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
     *
     * This class is a discriminated union wrapper that can represents a:
     * - signed integer [range: Value::minInt - Value::maxInt]
     * - unsigned integer (range: 0 - Value::maxUInt)
     * - double
     * - UTF-8 string
     * - boolean
     * - 'null'
     * - an ordered list of Value
     * - collection of name/value pairs (javascript object)
     *
     * The type of the held value is represented by a #ValueType and
     * can be obtained using type().
     *
     * values of an #objectValue or #arrayValue can be accessed using operator[]() methods.
     * Non const methods will automatically create the a #nullValue element
     * if it does not exist.
     * The sequence of an #arrayValue will be automatically resize and initialized
     * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
     *
     * The get() methods can be used to obtanis default value in the case the required element
     * does not exist.
     *
     * It is possible to iterate over the list of a #objectValue values using
     * the getMemberNames() method.
     */
    class JSON_API Value
    {
       friend class ValueIteratorBase;
 # ifdef JSON_VALUE_USE_INTERNAL_MAP
       friend class ValueInternalLink;
       friend class ValueInternalMap;
 # endif
    public:
       typedef std::vector<std::string> Members;
       typedef ValueIterator iterator;
       typedef ValueConstIterator const_iterator;
       typedef Json::UInt UInt;
       typedef Json::Int Int;
 # if defined(JSON_HAS_INT64)
       typedef Json::UInt64 UInt64;
       typedef Json::Int64 Int64;
 #endif // defined(JSON_HAS_INT64)
       typedef Json::LargestInt LargestInt;
       typedef Json::LargestUInt LargestUInt;
       typedef Json::ArrayIndex ArrayIndex;
 
       static const Value null;
       /// Minimum signed integer value that can be stored in a Json::Value.
       static const LargestInt minLargestInt;
       /// Maximum signed integer value that can be stored in a Json::Value.
       static const LargestInt maxLargestInt;
       /// Maximum unsigned integer value that can be stored in a Json::Value.
       static const LargestUInt maxLargestUInt;
 
       /// Minimum signed int value that can be stored in a Json::Value.
       static const Int minInt;
       /// Maximum signed int value that can be stored in a Json::Value.
       static const Int maxInt;
       /// Maximum unsigned int value that can be stored in a Json::Value.
       static const UInt maxUInt;
 
       /// Minimum signed 64 bits int value that can be stored in a Json::Value.
       static const Int64 minInt64;
       /// Maximum signed 64 bits int value that can be stored in a Json::Value.
       static const Int64 maxInt64;
       /// Maximum unsigned 64 bits int value that can be stored in a Json::Value.
       static const UInt64 maxUInt64;
 
    private:
 #ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
 # ifndef JSON_VALUE_USE_INTERNAL_MAP
       class CZString
       {
       public:
          enum DuplicationPolicy
          {
             noDuplication = 0,
             duplicate,
             duplicateOnCopy
          };
          CZString( ArrayIndex index );
          CZString( const char *cstr, DuplicationPolicy allocate );
          CZString( const CZString &other );
          ~CZString();
          CZString &operator =( const CZString &other );
          bool operator<( const CZString &other ) const;
          bool operator==( const CZString &other ) const;
          ArrayIndex index() const;
          const char *c_str() const;
          bool isStaticString() const;
       private:
          void swap( CZString &other );
          const char *cstr_;
          ArrayIndex index_;
       };
 
    public:
 #  ifndef JSON_USE_CPPTL_SMALLMAP
       typedef std::map<CZString, Value> ObjectValues;
 #  else
       typedef CppTL::SmallMap<CZString, Value> ObjectValues;
 #  endif // ifndef JSON_USE_CPPTL_SMALLMAP
 # endif // ifndef JSON_VALUE_USE_INTERNAL_MAP
 #endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
 
    public:
       /** \brief Create a default Value of the given type.
 
         This is a very useful constructor.
         To create an empty array, pass arrayValue.
         To create an empty object, pass objectValue.
         Another Value can then be set to this one by assignment.
     This is useful since clear() and resize() will not alter types.
 
         Examples:
     \code
     Json::Value null_value; // null
     Json::Value arr_value(Json::arrayValue); // []
     Json::Value obj_value(Json::objectValue); // {}
     \endcode
       */
       Value( ValueType type = nullValue );
       Value( Int value );
       Value( UInt value );
 #if defined(JSON_HAS_INT64)
       Value( Int64 value );
       Value( UInt64 value );
 #endif // if defined(JSON_HAS_INT64)
       Value( double value );
       Value( const char *value );
       Value( const char *beginValue, const char *endValue );
       /** \brief Constructs a value from a static string.
 
        * Like other value string constructor but do not duplicate the string for
        * internal storage. The given string must remain alive after the call to this
        * constructor.
        * Example of usage:
        * \code
        * Json::Value aValue( StaticString("some text") );
        * \endcode
        */
       Value( const StaticString &value );
       Value( const std::string &value );
 # ifdef JSON_USE_CPPTL
       Value( const CppTL::ConstString &value );
 # endif
       Value( bool value );
       Value( const Value &other );
       ~Value();
 
       Value &operator=( const Value &other );
       /// Swap values.
       /// \note Currently, comments are intentionally not swapped, for
       /// both logic and efficiency.
       void swap( Value &other );
 
       ValueType type() const;
 
       bool operator <( const Value &other ) const;
       bool operator <=( const Value &other ) const;
       bool operator >=( const Value &other ) const;
       bool operator >( const Value &other ) const;
 
       bool operator ==( const Value &other ) const;
       bool operator !=( const Value &other ) const;
 
       int compare( const Value &other ) const;
 
       const char *asCString() const;
       std::string asString() const;
 # ifdef JSON_USE_CPPTL
       CppTL::ConstString asConstString() const;
 # endif
       Int asInt() const;
       UInt asUInt() const;
       Int64 asInt64() const;
       UInt64 asUInt64() const;
       LargestInt asLargestInt() const;
       LargestUInt asLargestUInt() const;
       float asFloat() const;
       double asDouble() const;
       bool asBool() const;
 
       bool isNull() const;
       bool isBool() const;
       bool isInt() const;
       bool isUInt() const;
       bool isIntegral() const;
       bool isDouble() const;
       bool isNumeric() const;
       bool isString() const;
       bool isArray() const;
       bool isObject() const;
 
       bool isConvertibleTo( ValueType other ) const;
 
       /// Number of values in array or object
       ArrayIndex size() const;
 
       /// \brief Return true if empty array, empty object, or null;
       /// otherwise, false.
       bool empty() const;
 
       /// Return isNull()
       bool operator!() const;
 
       /// Remove all object members and array elements.
       /// \pre type() is arrayValue, objectValue, or nullValue
       /// \post type() is unchanged
       void clear();
 
       /// Resize the array to size elements.
       /// New elements are initialized to null.
       /// May only be called on nullValue or arrayValue.
       /// \pre type() is arrayValue or nullValue
       /// \post type() is arrayValue
       void resize( ArrayIndex size );
 
       /// Access an array element (zero based index ).
       /// If the array contains less than index element, then null value are inserted
       /// in the array so that its size is index+1.
       /// (You may need to say 'value[0u]' to get your compiler to distinguish
       ///  this from the operator[] which takes a string.)
       Value &operator[]( ArrayIndex index );
 
       /// Access an array element (zero based index ).
       /// If the array contains less than index element, then null value are inserted
       /// in the array so that its size is index+1.
       /// (You may need to say 'value[0u]' to get your compiler to distinguish
       ///  this from the operator[] which takes a string.)
       Value &operator[]( int index );
 
       /// Access an array element (zero based index )
       /// (You may need to say 'value[0u]' to get your compiler to distinguish
       ///  this from the operator[] which takes a string.)
       const Value &operator[]( ArrayIndex index ) const;
 
       /// Access an array element (zero based index )
       /// (You may need to say 'value[0u]' to get your compiler to distinguish
       ///  this from the operator[] which takes a string.)
       const Value &operator[]( int index ) const;
 
       /// If the array contains at least index+1 elements, returns the element value,
       /// otherwise returns defaultValue.
       Value get( ArrayIndex index,
                  const Value &defaultValue ) const;
       /// Return true if index < size().
       bool isValidIndex( ArrayIndex index ) const;
       /// \brief Append value to array at the end.
       ///
       /// Equivalent to jsonvalue[jsonvalue.size()] = value;
       Value &append( const Value &value );
 
       /// Access an object value by name, create a null member if it does not exist.
       Value &operator[]( const char *key );
       /// Access an object value by name, returns null if there is no member with that name.
       const Value &operator[]( const char *key ) const;
       /// Access an object value by name, create a null member if it does not exist.
       Value &operator[]( const std::string &key );
       /// Access an object value by name, returns null if there is no member with that name.
       const Value &operator[]( const std::string &key ) const;
       /** \brief Access an object value by name, create a null member if it does not exist.
 
        * If the object as no entry for that name, then the member name used to store
        * the new entry is not duplicated.
        * Example of use:
        * \code
        * Json::Value object;
        * static const StaticString code("code");
        * object[code] = 1234;
        * \endcode
        */
       Value &operator[]( const StaticString &key );
 # ifdef JSON_USE_CPPTL
       /// Access an object value by name, create a null member if it does not exist.
       Value &operator[]( const CppTL::ConstString &key );
       /// Access an object value by name, returns null if there is no member with that name.
       const Value &operator[]( const CppTL::ConstString &key ) const;
 # endif
       /// Return the member named key if it exist, defaultValue otherwise.
       Value get( const char *key,
                  const Value &defaultValue ) const;
       /// Return the member named key if it exist, defaultValue otherwise.
       Value get( const std::string &key,
                  const Value &defaultValue ) const;
 # ifdef JSON_USE_CPPTL
       /// Return the member named key if it exist, defaultValue otherwise.
       Value get( const CppTL::ConstString &key,
                  const Value &defaultValue ) const;
 # endif
       /// \brief Remove and return the named member.
       ///
       /// Do nothing if it did not exist.
       /// \return the removed Value, or null.
       /// \pre type() is objectValue or nullValue
       /// \post type() is unchanged
       Value removeMember( const char* key );
       /// Same as removeMember(const char*)
       Value removeMember( const std::string &key );
 
       /// Return true if the object has a member named key.
       bool isMember( const char *key ) const;
       /// Return true if the object has a member named key.
       bool isMember( const std::string &key ) const;
 # ifdef JSON_USE_CPPTL
       /// Return true if the object has a member named key.
       bool isMember( const CppTL::ConstString &key ) const;
 # endif
 
       /// \brief Return a list of the member names.
       ///
       /// If null, return an empty list.
       /// \pre type() is objectValue or nullValue
       /// \post if type() was nullValue, it remains nullValue
       Members getMemberNames() const;
 
 //# ifdef JSON_USE_CPPTL
 //      EnumMemberNames enumMemberNames() const;
 //      EnumValues enumValues() const;
 //# endif
 
       /// Comments must be //... or /* ... */
       void setComment( const char *comment,
                        CommentPlacement placement );
       /// Comments must be //... or /* ... */
       void setComment( const std::string &comment,
                        CommentPlacement placement );
       bool hasComment( CommentPlacement placement ) const;
       /// Include delimiters and embedded newlines.
       std::string getComment( CommentPlacement placement ) const;
 
       std::string toStyledString() const;
 
       const_iterator begin() const;
       const_iterator end() const;
 
       iterator begin();
       iterator end();
 
    private:
       Value &resolveReference( const char *key,
                                bool isStatic );
 
 # ifdef JSON_VALUE_USE_INTERNAL_MAP
       inline bool isItemAvailable() const
       {
          return itemIsUsed_ == 0;
       }
 
       inline void setItemUsed( bool isUsed = true )
       {
          itemIsUsed_ = isUsed ? 1 : 0;
       }
 
       inline bool isMemberNameStatic() const
       {
          return memberNameIsStatic_ == 0;
       }
 
       inline void setMemberNameIsStatic( bool isStatic )
       {
          memberNameIsStatic_ = isStatic ? 1 : 0;
       }
 # endif // # ifdef JSON_VALUE_USE_INTERNAL_MAP
 
    private:
       struct CommentInfo
       {
          CommentInfo();
          ~CommentInfo();
 
          void setComment( const char *text );
 
          char *comment_;
       };
 
       //struct MemberNamesTransform
       //{
       //   typedef const char *result_type;
       //   const char *operator()( const CZString &name ) const
       //   {
       //      return name.c_str();
       //   }
       //};
 
       union ValueHolder
       {
          LargestInt int_;
          LargestUInt uint_;
          double real_;
          bool bool_;
          char *string_;
 # ifdef JSON_VALUE_USE_INTERNAL_MAP
          ValueInternalArray *array_;
          ValueInternalMap *map_;
 #else
          ObjectValues *map_;
 # endif
       } value_;
       ValueType type_ : 8;
       int allocated_ : 1;     // Notes: if declared as bool, bitfield is useless.
 # ifdef JSON_VALUE_USE_INTERNAL_MAP
       unsigned int itemIsUsed_ : 1;      // used by the ValueInternalMap container.
       int memberNameIsStatic_ : 1;       // used by the ValueInternalMap container.
 # endif
       CommentInfo *comments_;
    };
 
 
    /** \brief Experimental and untested: represents an element of the "path" to access a node.
     */
    class PathArgument
    {
    public:
       friend class Path;
 
       PathArgument();
       PathArgument( ArrayIndex index );
       PathArgument( const char *key );
       PathArgument( const std::string &key );
 
    private:
       enum Kind
       {
          kindNone = 0,
          kindIndex,
          kindKey
       };
       std::string key_;
       ArrayIndex index_;
       Kind kind_;
    };
 
    /** \brief Experimental and untested: represents a "path" to access a node.
     *
     * Syntax:
     * - "." => root node
     * - ".[n]" => elements at index 'n' of root node (an array value)
     * - ".name" => member named 'name' of root node (an object value)
     * - ".name1.name2.name3"
     * - ".[0][1][2].name1[3]"
     * - ".%" => member name is provided as parameter
     * - ".[%]" => index is provied as parameter
     */
    class Path
    {
    public:
       Path( const std::string &path,
             const PathArgument &a1 = PathArgument(),
             const PathArgument &a2 = PathArgument(),
             const PathArgument &a3 = PathArgument(),
             const PathArgument &a4 = PathArgument(),
             const PathArgument &a5 = PathArgument() );
 
       const Value &resolve( const Value &root ) const;
       Value resolve( const Value &root,
                      const Value &defaultValue ) const;
       /// Creates the "path" to access the specified node and returns a reference on the node.
       Value &make( Value &root ) const;
 
    private:
       typedef std::vector<const PathArgument *> InArgs;
       typedef std::vector<PathArgument> Args;
 
       void makePath( const std::string &path,
                      const InArgs &in );
       void addPathInArg( const std::string &path,
                          const InArgs &in,
                          InArgs::const_iterator &itInArg,
                          PathArgument::Kind kind );
       void invalidPath( const std::string &path,
                         int location );
 
       Args args_;
    };
 
 
 
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
    /** \brief Allocator to customize Value internal map.
     * Below is an example of a simple implementation (default implementation actually
     * use memory pool for speed).
     * \code
       class DefaultValueMapAllocator : public ValueMapAllocator
       {
       public: // overridden from ValueMapAllocator
          virtual ValueInternalMap *newMap()
          {
             return new ValueInternalMap();
          }
 
          virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other )
          {
             return new ValueInternalMap( other );
          }
 
          virtual void destructMap( ValueInternalMap *map )
          {
             delete map;
          }
 
          virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
          {
             return new ValueInternalLink[size];
          }
 
          virtual void releaseMapBuckets( ValueInternalLink *links )
          {
             delete [] links;
          }
 
          virtual ValueInternalLink *allocateMapLink()
          {
             return new ValueInternalLink();
          }
 
          virtual void releaseMapLink( ValueInternalLink *link )
          {
             delete link;
          }
       };
     * \endcode
     */
    class JSON_API ValueMapAllocator
    {
    public:
       virtual ~ValueMapAllocator();
       virtual ValueInternalMap *newMap() = 0;
       virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other ) = 0;
       virtual void destructMap( ValueInternalMap *map ) = 0;
       virtual ValueInternalLink *allocateMapBuckets( unsigned int size ) = 0;
       virtual void releaseMapBuckets( ValueInternalLink *links ) = 0;
       virtual ValueInternalLink *allocateMapLink() = 0;
       virtual void releaseMapLink( ValueInternalLink *link ) = 0;
    };
 
    /** \brief ValueInternalMap hash-map bucket chain link (for internal use only).
     * \internal previous_ & next_ allows for bidirectional traversal.
     */
    class JSON_API ValueInternalLink
    {
    public:
       enum { itemPerLink = 6 };  // sizeof(ValueInternalLink) = 128 on 32 bits architecture.
       enum InternalFlags {
          flagAvailable = 0,
          flagUsed = 1
       };
 
       ValueInternalLink();
 
       ~ValueInternalLink();
 
       Value items_[itemPerLink];
       char *keys_[itemPerLink];
       ValueInternalLink *previous_;
       ValueInternalLink *next_;
    };
 
 
    /** \brief A linked page based hash-table implementation used internally by Value.
     * \internal ValueInternalMap is a tradional bucket based hash-table, with a linked
     * list in each bucket to handle collision. There is an addional twist in that
     * each node of the collision linked list is a page containing a fixed amount of
     * value. This provides a better compromise between memory usage and speed.
     *
     * Each bucket is made up of a chained list of ValueInternalLink. The last
     * link of a given bucket can be found in the 'previous_' field of the following bucket.
     * The last link of the last bucket is stored in tailLink_ as it has no following bucket.
     * Only the last link of a bucket may contains 'available' item. The last link always
     * contains at least one element unless is it the bucket one very first link.
     */
    class JSON_API ValueInternalMap
    {
       friend class ValueIteratorBase;
       friend class Value;
    public:
       typedef unsigned int HashKey;
       typedef unsigned int BucketIndex;
 
 # ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
       struct IteratorState
       {
          IteratorState()
             : map_(0)
             , link_(0)
             , itemIndex_(0)
             , bucketIndex_(0)
          {
          }
          ValueInternalMap *map_;
          ValueInternalLink *link_;
          BucketIndex itemIndex_;
          BucketIndex bucketIndex_;
       };
 # endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
 
       ValueInternalMap();
       ValueInternalMap( const ValueInternalMap &other );
       ValueInternalMap &operator =( const ValueInternalMap &other );
       ~ValueInternalMap();
 
       void swap( ValueInternalMap &other );
 
       BucketIndex size() const;
 
       void clear();
 
       bool reserveDelta( BucketIndex growth );
 
       bool reserve( BucketIndex newItemCount );
 
       const Value *find( const char *key ) const;
 
       Value *find( const char *key );
 
       Value &resolveReference( const char *key,
                                bool isStatic );
 
       void remove( const char *key );
 
       void doActualRemove( ValueInternalLink *link,
                            BucketIndex index,
                            BucketIndex bucketIndex );
 
       ValueInternalLink *&getLastLinkInBucket( BucketIndex bucketIndex );
 
       Value &setNewItem( const char *key,
                          bool isStatic,
                          ValueInternalLink *link,
                          BucketIndex index );
 
       Value &unsafeAdd( const char *key,
                         bool isStatic,
                         HashKey hashedKey );
 
       HashKey hash( const char *key ) const;
 
       int compare( const ValueInternalMap &other ) const;
 
    private:
       void makeBeginIterator( IteratorState &it ) const;
       void makeEndIterator( IteratorState &it ) const;
       static bool equals( const IteratorState &x, const IteratorState &other );
       static void increment( IteratorState &iterator );
       static void incrementBucket( IteratorState &iterator );
       static void decrement( IteratorState &iterator );
       static const char *key( const IteratorState &iterator );
       static const char *key( const IteratorState &iterator, bool &isStatic );
       static Value &value( const IteratorState &iterator );
       static int distance( const IteratorState &x, const IteratorState &y );
 
    private:
       ValueInternalLink *buckets_;
       ValueInternalLink *tailLink_;
       BucketIndex bucketsSize_;
       BucketIndex itemCount_;
    };
 
    /** \brief A simplified deque implementation used internally by Value.
    * \internal
    * It is based on a list of fixed "page", each page contains a fixed number of items.
    * Instead of using a linked-list, a array of pointer is used for fast item look-up.
    * Look-up for an element is as follow:
    * - compute page index: pageIndex = itemIndex / itemsPerPage
    * - look-up item in page: pages_[pageIndex][itemIndex % itemsPerPage]
    *
    * Insertion is amortized constant time (only the array containing the index of pointers
    * need to be reallocated when items are appended).
    */
    class JSON_API ValueInternalArray
    {
       friend class Value;
       friend class ValueIteratorBase;
    public:
       enum { itemsPerPage = 8 };    // should be a power of 2 for fast divide and modulo.
       typedef Value::ArrayIndex ArrayIndex;
       typedef unsigned int PageIndex;
 
 # ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
       struct IteratorState // Must be a POD
       {
          IteratorState()
             : array_(0)
             , currentPageIndex_(0)
             , currentItemIndex_(0)
          {
          }
          ValueInternalArray *array_;
          Value **currentPageIndex_;
          unsigned int currentItemIndex_;
       };
 # endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
 
       ValueInternalArray();
       ValueInternalArray( const ValueInternalArray &other );
       ValueInternalArray &operator =( const ValueInternalArray &other );
       ~ValueInternalArray();
       void swap( ValueInternalArray &other );
 
       void clear();
       void resize( ArrayIndex newSize );
 
       Value &resolveReference( ArrayIndex index );
 
       Value *find( ArrayIndex index ) const;
 
       ArrayIndex size() const;
 
       int compare( const ValueInternalArray &other ) const;
 
    private:
       static bool equals( const IteratorState &x, const IteratorState &other );
       static void increment( IteratorState &iterator );
       static void decrement( IteratorState &iterator );
       static Value &dereference( const IteratorState &iterator );
       static Value &unsafeDereference( const IteratorState &iterator );
       static int distance( const IteratorState &x, const IteratorState &y );
       static ArrayIndex indexOf( const IteratorState &iterator );
       void makeBeginIterator( IteratorState &it ) const;
       void makeEndIterator( IteratorState &it ) const;
       void makeIterator( IteratorState &it, ArrayIndex index ) const;
 
       void makeIndexValid( ArrayIndex index );
 
       Value **pages_;
       ArrayIndex size_;
       PageIndex pageCount_;
    };
 
    /** \brief Experimental: do not use. Allocator to customize Value internal array.
     * Below is an example of a simple implementation (actual implementation use
     * memory pool).
       \code
 class DefaultValueArrayAllocator : public ValueArrayAllocator
 {
 public: // overridden from ValueArrayAllocator
    virtual ~DefaultValueArrayAllocator()
    {
    }
 
    virtual ValueInternalArray *newArray()
    {
       return new ValueInternalArray();
    }
 
    virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other )
    {
       return new ValueInternalArray( other );
    }
 
    virtual void destruct( ValueInternalArray *array )
    {
       delete array;
    }
 
    virtual void reallocateArrayPageIndex( Value **&indexes,
                                           ValueInternalArray::PageIndex &indexCount,
                                           ValueInternalArray::PageIndex minNewIndexCount )
    {
       ValueInternalArray::PageIndex newIndexCount = (indexCount*3)/2 + 1;
       if ( minNewIndexCount > newIndexCount )
          newIndexCount = minNewIndexCount;
       void *newIndexes = realloc( indexes, sizeof(Value*) * newIndexCount );
       if ( !newIndexes )
          throw std::bad_alloc();
       indexCount = newIndexCount;
       indexes = static_cast<Value **>( newIndexes );
    }
    virtual void releaseArrayPageIndex( Value **indexes,
                                        ValueInternalArray::PageIndex indexCount )
    {
       if ( indexes )
          free( indexes );
    }
 
    virtual Value *allocateArrayPage()
    {
       return static_cast<Value *>( malloc( sizeof(Value) * ValueInternalArray::itemsPerPage ) );
    }
 
    virtual void releaseArrayPage( Value *value )
    {
       if ( value )
          free( value );
    }
 };
       \endcode
     */
    class JSON_API ValueArrayAllocator
    {
    public:
       virtual ~ValueArrayAllocator();
       virtual ValueInternalArray *newArray() = 0;
       virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other ) = 0;
       virtual void destructArray( ValueInternalArray *array ) = 0;
       /** \brief Reallocate array page index.
        * Reallocates an array of pointer on each page.
        * \param indexes [input] pointer on the current index. May be \c nullptr.
        *                [output] pointer on the new index of at least
        *                         \a minNewIndexCount pages.
        * \param indexCount [input] current number of pages in the index.
        *                   [output] number of page the reallocated index can handle.
        *                            \b MUST be >= \a minNewIndexCount.
        * \param minNewIndexCount Minimum number of page the new index must be able to
        *                         handle.
        */
       virtual void reallocateArrayPageIndex( Value **&indexes,
                                              ValueInternalArray::PageIndex &indexCount,
                                              ValueInternalArray::PageIndex minNewIndexCount ) = 0;
       virtual void releaseArrayPageIndex( Value **indexes,
                                           ValueInternalArray::PageIndex indexCount ) = 0;
       virtual Value *allocateArrayPage() = 0;
       virtual void releaseArrayPage( Value *value ) = 0;
    };
 #endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP
 
 
    /** \brief base class for Value iterators.
     *
     */
    class ValueIteratorBase
    {
    public:
       typedef unsigned int size_t;
       typedef int difference_type;
       typedef ValueIteratorBase SelfType;
 
       ValueIteratorBase();
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
       explicit ValueIteratorBase( const Value::ObjectValues::iterator &current );
 #else
       ValueIteratorBase( const ValueInternalArray::IteratorState &state );
       ValueIteratorBase( const ValueInternalMap::IteratorState &state );
 #endif
 
       bool operator ==( const SelfType &other ) const
       {
          return isEqual( other );
       }
 
       bool operator !=( const SelfType &other ) const
       {
          return !isEqual( other );
       }
 
       difference_type operator -( const SelfType &other ) const
       {
          return computeDistance( other );
       }
 
       /// Return either the index or the member name of the referenced value as a Value.
       Value key() const;
 
       /// Return the index of the referenced Value. -1 if it is not an arrayValue.
       UInt index() const;
 
       /// Return the member name of the referenced Value. "" if it is not an objectValue.
       const char *memberName() const;
 
    protected:
       Value &deref() const;
 
       void increment();
 
       void decrement();
 
       difference_type computeDistance( const SelfType &other ) const;
 
       bool isEqual( const SelfType &other ) const;
 
       void copy( const SelfType &other );
 
    private:
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
       Value::ObjectValues::iterator current_;
       // Indicates that iterator is for a null value.
       bool isNull_;
 #else
       union
       {
          ValueInternalArray::IteratorState array_;
          ValueInternalMap::IteratorState map_;
       } iterator_;
       bool isArray_;
 #endif
    };
 
    /** \brief const iterator for object and array value.
     *
     */
    class ValueConstIterator : public ValueIteratorBase
    {
       friend class Value;
    public:
       typedef unsigned int size_t;
       typedef int difference_type;
       typedef const Value &reference;
       typedef const Value *pointer;
       typedef ValueConstIterator SelfType;
 
       ValueConstIterator();
    private:
       /*! \internal Use by Value to create an iterator.
        */
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
       explicit ValueConstIterator( const Value::ObjectValues::iterator &current );
 #else
       ValueConstIterator( const ValueInternalArray::IteratorState &state );
       ValueConstIterator( const ValueInternalMap::IteratorState &state );
 #endif
    public:
       SelfType &operator =( const ValueIteratorBase &other );
 
       SelfType operator++( int )
       {
          SelfType temp( *this );
          ++*this;
          return temp;
       }
 
       SelfType operator--( int )
       {
          SelfType temp( *this );
          --*this;
          return temp;
       }
 
       SelfType &operator--()
       {
          decrement();
          return *this;
       }
 
       SelfType &operator++()
       {
          increment();
          return *this;
       }
 
       reference operator *() const
       {
          return deref();
       }
    };
 
 
    /** \brief Iterator for object and array value.
     */
    class ValueIterator : public ValueIteratorBase
    {
       friend class Value;
    public:
       typedef unsigned int size_t;
       typedef int difference_type;
       typedef Value &reference;
       typedef Value *pointer;
       typedef ValueIterator SelfType;
 
       ValueIterator();
       ValueIterator( const ValueConstIterator &other );
       ValueIterator( const ValueIterator &other );
    private:
       /*! \internal Use by Value to create an iterator.
        */
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
       explicit ValueIterator( const Value::ObjectValues::iterator &current );
 #else
       ValueIterator( const ValueInternalArray::IteratorState &state );
       ValueIterator( const ValueInternalMap::IteratorState &state );
 #endif
    public:
 
       SelfType &operator =( const SelfType &other );
 
       SelfType operator++( int )
       {
          SelfType temp( *this );
          ++*this;
          return temp;
       }
 
       SelfType operator--( int )
       {
          SelfType temp( *this );
          --*this;
          return temp;
       }
 
       SelfType &operator--()
       {
          decrement();
          return *this;
       }
 
       SelfType &operator++()
       {
          increment();
          return *this;
       }
 
       reference operator *() const
       {
          return deref();
       }
    };
 
 
 } // namespace Json
 
 
 #endif // CPPTL_JSON_H_INCLUDED
 
 // //////////////////////////////////////////////////////////////////////
 // End of content of file: include/json/value.h
 // //////////////////////////////////////////////////////////////////////
 
 
 
 
 
 
 // //////////////////////////////////////////////////////////////////////
 // Beginning of content of file: include/json/reader.h
 // //////////////////////////////////////////////////////////////////////
 
 // Copyright 2007-2010 Baptiste Lepilleur
 // Distributed under MIT license, or public domain if desired and
 // recognized in your jurisdiction.
 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
 #ifndef CPPTL_JSON_READER_H_INCLUDED
 # define CPPTL_JSON_READER_H_INCLUDED
 
 #if !defined(JSON_IS_AMALGAMATION)
 # include "features.h"
 # include "value.h"
 #endif // if !defined(JSON_IS_AMALGAMATION)
 # include <deque>
 # include <stack>
 # include <string>
 # include <iostream>
 
 namespace Json {
 
    /** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a Value.
     *
     */
    class JSON_API Reader
    {
    public:
       typedef char Char;
       typedef const Char *Location;
 
       /** \brief Constructs a Reader allowing all features
        * for parsing.
        */
       Reader();
 
       /** \brief Constructs a Reader allowing the specified feature set
        * for parsing.
        */
       Reader( const Features &features );
 
       /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a> document.
        * \param document UTF-8 encoded string containing the document to read.
        * \param root [out] Contains the root value of the document if it was
        *             successfully parsed.
        * \param collectComments \c true to collect comment and allow writing them back during
        *                        serialization, \c false to discard comments.
        *                        This parameter is ignored if Features::allowComments_
        *                        is \c false.
        * \return \c true if the document was successfully parsed, \c false if an error occurred.
        */
       bool parse( const std::string &document,
                   Value &root,
                   bool collectComments = true );
 
       /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a> document.
        * \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the document to read.
        * \param endDoc Pointer on the end of the UTF-8 encoded string of the document to read.
        \               Must be >= beginDoc.
        * \param root [out] Contains the root value of the document if it was
        *             successfully parsed.
        * \param collectComments \c true to collect comment and allow writing them back during
        *                        serialization, \c false to discard comments.
        *                        This parameter is ignored if Features::allowComments_
        *                        is \c false.
        * \return \c true if the document was successfully parsed, \c false if an error occurred.
        */
       bool parse( const char *beginDoc, const char *endDoc,
                   Value &root,
                   bool collectComments = true );
 
       /// \brief Parse from input stream.
       /// \see Json::operator>>(std::istream&, Json::Value&).
       bool parse( std::istream &is,
                   Value &root,
                   bool collectComments = true );
 
       /** \brief Returns a user friendly string that list errors in the parsed document.
        * \return Formatted error message with the list of errors with their location in
        *         the parsed document. An empty string is returned if no error occurred
        *         during parsing.
        * \deprecated Use getFormattedErrorMessages() instead (typo fix).
        */
       JSONCPP_DEPRECATED("Use getFormattedErrorMessages instead")
       std::string getFormatedErrorMessages() const;
 
       /** \brief Returns a user friendly string that list errors in the parsed document.
        * \return Formatted error message with the list of errors with their location in
        *         the parsed document. An empty string is returned if no error occurred
        *         during parsing.
        */
       std::string getFormattedErrorMessages() const;
 
    private:
       enum TokenType
       {
          tokenEndOfStream = 0,
          tokenObjectBegin,
          tokenObjectEnd,
          tokenArrayBegin,
          tokenArrayEnd,
          tokenString,
          tokenNumber,
          tokenTrue,
          tokenFalse,
          tokenNull,
          tokenArraySeparator,
          tokenMemberSeparator,
          tokenComment,
          tokenError
       };
 
       class Token
       {
       public:
          TokenType type_;
          Location start_;
          Location end_;
       };
 
       class ErrorInfo
       {
       public:
          Token token_;
          std::string message_;
          Location extra_;
       };
 
       typedef std::deque<ErrorInfo> Errors;
 
       bool expectToken( TokenType type, Token &token, const char *message );
       bool readToken( Token &token );
       void skipSpaces();
       bool match( Location pattern,
                   int patternLength );
       bool readComment();
       bool readCStyleComment();
       bool readCppStyleComment();
       bool readString();
       void readNumber();
       bool readValue();
       bool readObject( Token &token );
       bool readArray( Token &token );
       bool decodeNumber( Token &token );
       bool decodeString( Token &token );
       bool decodeString( Token &token, std::string &decoded );
       bool decodeDouble( Token &token );
       bool decodeUnicodeCodePoint( Token &token,
                                    Location &current,
                                    Location end,
                                    unsigned int &unicode );
       bool decodeUnicodeEscapeSequence( Token &token,
                                         Location &current,
                                         Location end,
                                         unsigned int &unicode );
       bool addError( const std::string &message,
                      Token &token,
-                     Location extra = 0 );
+                     Location extra = nullptr );
       bool recoverFromError( TokenType skipUntilToken );
       bool addErrorAndRecover( const std::string &message,
                                Token &token,
                                TokenType skipUntilToken );
       void skipUntilSpace();
       Value &currentValue();
       Char getNextChar();
       void getLocationLineAndColumn( Location location,
                                      int &line,
                                      int &column ) const;
       std::string getLocationLineAndColumn( Location location ) const;
       void addComment( Location begin,
                        Location end,
                        CommentPlacement placement );
       void skipCommentTokens( Token &token );
 
       typedef std::stack<Value *> Nodes;
       Nodes nodes_;
       Errors errors_;
       std::string document_;
       Location begin_;
       Location end_;
       Location current_;
       Location lastValueEnd_;
       Value *lastValue_;
       std::string commentsBefore_;
       Features features_;
       bool collectComments_;
    };
 
    /** \brief Read from 'sin' into 'root'.
 
     Always keep comments from the input JSON.
 
     This can be used to read a file into a particular sub-object.
     For example:
     \code
     Json::Value root;
     cin >> root["dir"]["file"];
     cout << root;
     \endcode
     Result:
     \verbatim
     {
     "dir": {
         "file": {
         // The input stream JSON would be nested here.
         }
     }
     }
     \endverbatim
     \throw std::exception on parse error.
     \see Json::operator<<()
    */
    std::istream& operator>>( std::istream&, Value& );
 
 } // namespace Json
 
 #endif // CPPTL_JSON_READER_H_INCLUDED
 
 // //////////////////////////////////////////////////////////////////////
 // End of content of file: include/json/reader.h
 // //////////////////////////////////////////////////////////////////////
 
 
 
 
 
 
 // //////////////////////////////////////////////////////////////////////
 // Beginning of content of file: include/json/writer.h
 // //////////////////////////////////////////////////////////////////////
 
 // Copyright 2007-2010 Baptiste Lepilleur
 // Distributed under MIT license, or public domain if desired and
 // recognized in your jurisdiction.
 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
 #ifndef JSON_WRITER_H_INCLUDED
 # define JSON_WRITER_H_INCLUDED
 
 #if !defined(JSON_IS_AMALGAMATION)
 # include "value.h"
 #endif // if !defined(JSON_IS_AMALGAMATION)
 # include <vector>
 # include <string>
 # include <iostream>
 
 namespace Json {
 
    class Value;
 
    /** \brief Abstract class for writers.
     */
    class JSON_API Writer
    {
    public:
       virtual ~Writer();
 
       virtual std::string write( const Value &root ) = 0;
    };
 
    /** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format without formatting (not human friendly).
     *
     * The JSON document is written in a single line. It is not intended for 'human' consumption,
     * but may be usefull to support feature such as RPC where bandwith is limited.
     * \sa Reader, Value
     */
    class JSON_API FastWriter : public Writer
    {
    public:
       FastWriter();
       ~FastWriter() override{}
 
       void enableYAMLCompatibility();
 
    public: // overridden from Writer
       std::string write( const Value &root ) override;
 
    private:
       void writeValue( const Value &value );
 
       std::string document_;
       bool yamlCompatiblityEnabled_;
    };
 
    /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a human friendly way.
     *
     * The rules for line break and indent are as follow:
     * - Object value:
     *     - if empty then print {} without indent and line break
     *     - if not empty the print '{', line break & indent, print one value per line
     *       and then unindent and line break and print '}'.
     * - Array value:
     *     - if empty then print [] without indent and line break
     *     - if the array contains no object value, empty array or some other value types,
     *       and all the values fit on one lines, then print the array on a single line.
     *     - otherwise, it the values do not fit on one line, or the array contains
     *       object or non empty array, then print one value per line.
     *
     * If the Value have comments then they are outputed according to their #CommentPlacement.
     *
     * \sa Reader, Value, Value::setComment()
     */
    class JSON_API StyledWriter: public Writer
    {
    public:
       StyledWriter();
       ~StyledWriter() override{}
 
    public: // overridden from Writer
       /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
        * \param root Value to serialize.
        * \return String containing the JSON document that represents the root value.
        */
       std::string write( const Value &root ) override;
 
    private:
       void writeValue( const Value &value );
       void writeArrayValue( const Value &value );
       bool isMultineArray( const Value &value );
       void pushValue( const std::string &value );
       void writeIndent();
       void writeWithIndent( const std::string &value );
       void indent();
       void unindent();
       void writeCommentBeforeValue( const Value &root );
       void writeCommentAfterValueOnSameLine( const Value &root );
       bool hasCommentForValue( const Value &value );
       static std::string normalizeEOL( const std::string &text );
 
       typedef std::vector<std::string> ChildValues;
 
       ChildValues childValues_;
       std::string document_;
       std::string indentString_;
       int rightMargin_;
       int indentSize_;
       bool addChildValues_;
    };
 
    /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a human friendly way,
         to a stream rather than to a string.
     *
     * The rules for line break and indent are as follow:
     * - Object value:
     *     - if empty then print {} without indent and line break
     *     - if not empty the print '{', line break & indent, print one value per line
     *       and then unindent and line break and print '}'.
     * - Array value:
     *     - if empty then print [] without indent and line break
     *     - if the array contains no object value, empty array or some other value types,
     *       and all the values fit on one lines, then print the array on a single line.
     *     - otherwise, it the values do not fit on one line, or the array contains
     *       object or non empty array, then print one value per line.
     *
     * If the Value have comments then they are outputed according to their #CommentPlacement.
     *
     * \param indentation Each level will be indented by this amount extra.
     * \sa Reader, Value, Value::setComment()
     */
    class JSON_API StyledStreamWriter
    {
    public:
       StyledStreamWriter( std::string indentation="\t" );
       ~StyledStreamWriter(){}
 
    public:
       /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
        * \param out Stream to write to. (Can be ostringstream, e.g.)
        * \param root Value to serialize.
        * \note There is no point in deriving from Writer, since write() should not return a value.
        */
       void write( std::ostream &out, const Value &root );
 
    private:
       void writeValue( const Value &value );
       void writeArrayValue( const Value &value );
       bool isMultineArray( const Value &value );
       void pushValue( const std::string &value );
       void writeIndent();
       void writeWithIndent( const std::string &value );
       void indent();
       void unindent();
       void writeCommentBeforeValue( const Value &root );
       void writeCommentAfterValueOnSameLine( const Value &root );
       bool hasCommentForValue( const Value &value );
       static std::string normalizeEOL( const std::string &text );
 
       typedef std::vector<std::string> ChildValues;
 
       ChildValues childValues_;
       std::ostream* document_;
       std::string indentString_;
       int rightMargin_;
       std::string indentation_;
       bool addChildValues_;
    };
 
 # if defined(JSON_HAS_INT64)
    std::string JSON_API valueToString( Int value );
    std::string JSON_API valueToString( UInt value );
 # endif // if defined(JSON_HAS_INT64)
    std::string JSON_API valueToString( LargestInt value );
    std::string JSON_API valueToString( LargestUInt value );
    std::string JSON_API valueToString( double value );
    std::string JSON_API valueToString( bool value );
    std::string JSON_API valueToQuotedString( const char *value );
 
    /// \brief Output using the StyledStreamWriter.
    /// \see Json::operator>>()
    std::ostream& operator<<( std::ostream&, const Value &root );
 
 } // namespace Json
 
 
 
 #endif // JSON_WRITER_H_INCLUDED
 
 // //////////////////////////////////////////////////////////////////////
 // End of content of file: include/json/writer.h
 // //////////////////////////////////////////////////////////////////////
 
 
 
 
 
 #endif //ifndef JSON_AMALGATED_H_INCLUDED
diff --git a/Modules/IGT/IO/mitkNavigationToolWriter.cpp b/Modules/IGT/IO/mitkNavigationToolWriter.cpp
index 9e8b1ad615..c7d8d58574 100644
--- a/Modules/IGT/IO/mitkNavigationToolWriter.cpp
+++ b/Modules/IGT/IO/mitkNavigationToolWriter.cpp
@@ -1,169 +1,169 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //Poco headers
 #include <Poco/Zip/Compress.h>
 #include <Poco/Path.h>
 
 //mitk headers
 #include "mitkNavigationToolWriter.h"
 #include <mitkStandaloneDataStorage.h>
 #include <mitkProperties.h>
 #include <mitkSceneIO.h>
 #include <mitkPointSet.h>
 #include <mitkIOUtil.h>
 
 //std headers
 #include <cstdio>
 
 mitk::NavigationToolWriter::NavigationToolWriter()
   {
 
   }
 
 mitk::NavigationToolWriter::~NavigationToolWriter()
   {
 
   }
 
 bool mitk::NavigationToolWriter::DoWrite(std::string FileName,mitk::NavigationTool::Pointer Tool)
   {
   //some initial validation checks...
   if ( Tool.IsNull())
     {
     m_ErrorMessage = "Cannot write a navigation tool containing invalid tool data, aborting!";
     MITK_ERROR << m_ErrorMessage;
     return false;
     }
 
 
   // Workaround for a problem: the geometry might be modified if the tool is tracked. If this
   // modified geometry is saved the surface representation is moved by this offset. To avoid
   // this bug, the geometry is set to identity for the saving progress and restored later.
   mitk::BaseGeometry::Pointer geometryBackup;
   if (  Tool->GetDataNode().IsNotNull()
         && (Tool->GetDataNode()->GetData()!=nullptr)
         && (Tool->GetDataNode()->GetData()->GetGeometry()!=nullptr)
         )
       {
       geometryBackup = Tool->GetDataNode()->GetData()->GetGeometry()->Clone();
       Tool->GetDataNode()->GetData()->GetGeometry()->SetIdentity();
       }
   else {MITK_WARN << "Saving a tool with invalid data node, proceeding but errors might occure!";}
 
   //convert whole data to a mitk::DataStorage
   mitk::StandaloneDataStorage::Pointer saveStorage = mitk::StandaloneDataStorage::New();
   mitk::DataNode::Pointer thisTool = ConvertToDataNode(Tool);
   saveStorage->Add(thisTool);
 
   //use SceneSerialization to save the DataStorage
   std::string DataStorageFileName = mitk::IOUtil::CreateTemporaryDirectory() + Poco::Path::separator() + GetFileWithoutPath(FileName) + ".storage";
   mitk::SceneIO::Pointer mySceneIO = mitk::SceneIO::New();
   mySceneIO->SaveScene(saveStorage->GetAll(),saveStorage,DataStorageFileName);
 
   //now put the DataStorage and the Toolfile in a ZIP-file
   std::ofstream file( FileName.c_str(), std::ios::binary | std::ios::out);
   if (!file.good())
     {
     m_ErrorMessage = "Could not open a zip file for writing: '" + FileName + "'";
     MITK_ERROR << m_ErrorMessage;
     return false;
     }
   else
     {
     Poco::Zip::Compress zipper( file, true );
     zipper.addFile(DataStorageFileName,GetFileWithoutPath(DataStorageFileName));
     if (Tool->GetCalibrationFile()!="none") zipper.addFile(Tool->GetCalibrationFile(),GetFileWithoutPath(Tool->GetCalibrationFile()));
     zipper.close();
     }
 
   //delete the data storage
   std::remove(DataStorageFileName.c_str());
 
   //restore original geometry
   if (geometryBackup.IsNotNull()) {Tool->GetDataNode()->GetData()->SetGeometry(geometryBackup);}
 
   return true;
   }
 
 mitk::DataNode::Pointer mitk::NavigationToolWriter::ConvertToDataNode(mitk::NavigationTool::Pointer Tool)
   {
     mitk::DataNode::Pointer thisTool = Tool->GetDataNode();
   //Name
     if (Tool->GetDataNode().IsNull())
     {
       thisTool = mitk::DataNode::New();
       thisTool->SetName("none");
     }
     
   //Identifier
-    thisTool->AddProperty("identifier",mitk::StringProperty::New(Tool->GetIdentifier().c_str()), NULL, true);
+    thisTool->AddProperty("identifier",mitk::StringProperty::New(Tool->GetIdentifier().c_str()), nullptr, true);
   //Serial Number
-    thisTool->AddProperty("serial number",mitk::StringProperty::New(Tool->GetSerialNumber().c_str()), NULL, true);
+    thisTool->AddProperty("serial number",mitk::StringProperty::New(Tool->GetSerialNumber().c_str()), nullptr, true);
   //Tracking Device
-    thisTool->AddProperty("tracking device type",mitk::StringProperty::New(Tool->GetTrackingDeviceType()), NULL, true);
+    thisTool->AddProperty("tracking device type",mitk::StringProperty::New(Tool->GetTrackingDeviceType()), nullptr, true);
   //Tool Type
-    thisTool->AddProperty("tracking tool type",mitk::IntProperty::New(Tool->GetType()), NULL, true);
+    thisTool->AddProperty("tracking tool type",mitk::IntProperty::New(Tool->GetType()), nullptr, true);
   //Calibration File Name
-    thisTool->AddProperty("toolfileName",mitk::StringProperty::New(GetFileWithoutPath(Tool->GetCalibrationFile())), NULL, true);
+    thisTool->AddProperty("toolfileName",mitk::StringProperty::New(GetFileWithoutPath(Tool->GetCalibrationFile())), nullptr, true);
   //Tool Landmarks
-    thisTool->AddProperty("ToolRegistrationLandmarks",mitk::StringProperty::New(ConvertPointSetToString(Tool->GetToolLandmarks())), NULL, true);
-    thisTool->AddProperty("ToolCalibrationLandmarks",mitk::StringProperty::New(ConvertPointSetToString(Tool->GetToolControlPoints())), NULL, true);
+    thisTool->AddProperty("ToolRegistrationLandmarks",mitk::StringProperty::New(ConvertPointSetToString(Tool->GetToolLandmarks())), nullptr, true);
+    thisTool->AddProperty("ToolCalibrationLandmarks",mitk::StringProperty::New(ConvertPointSetToString(Tool->GetToolControlPoints())), nullptr, true);
 
   //Tool Tip
     if (Tool->IsToolTipSet())
     {
-      thisTool->AddProperty("ToolTipPosition",mitk::StringProperty::New(ConvertPointToString(Tool->GetToolTipPosition())), NULL, true);
-      thisTool->AddProperty("ToolAxisOrientation",mitk::StringProperty::New(ConvertQuaternionToString(Tool->GetToolAxisOrientation())), NULL, true);
+      thisTool->AddProperty("ToolTipPosition",mitk::StringProperty::New(ConvertPointToString(Tool->GetToolTipPosition())), nullptr, true);
+      thisTool->AddProperty("ToolAxisOrientation",mitk::StringProperty::New(ConvertQuaternionToString(Tool->GetToolAxisOrientation())), nullptr, true);
     }
 
   //Material is not needed, to avoid errors in scene serialization we have to do this:
     thisTool->RemoveProperty("material");
 
   return thisTool;
   }
 
 std::string mitk::NavigationToolWriter::GetFileWithoutPath(std::string FileWithPath)
   {
   Poco::Path myFile(FileWithPath.c_str());
   return myFile.getFileName();
   }
 
 std::string mitk::NavigationToolWriter::ConvertPointSetToString(mitk::PointSet::Pointer pointSet)
   {
   std::stringstream returnValue;
   mitk::PointSet::PointDataIterator it;
   for ( it = pointSet->GetPointSet()->GetPointData()->Begin();it != pointSet->GetPointSet()->GetPointData()->End();it++ )
     {
     mitk::Point3D thisPoint = pointSet->GetPoint(it->Index());
     returnValue << it->Index() << ";" << ConvertPointToString(thisPoint) << "|";
     }
   return returnValue.str();
   }
 
 std::string mitk::NavigationToolWriter::ConvertPointToString(mitk::Point3D point)
 {
 std::stringstream returnValue;
 returnValue << point[0] << ";" << point[1] << ";" << point[2];
 return returnValue.str();
 }
 
 std::string mitk::NavigationToolWriter::ConvertQuaternionToString(mitk::Quaternion quat)
 {
 std::stringstream returnValue;
 returnValue << quat.x() << ";" << quat.y() << ";" << quat.z() << ";" << quat.r();
 return returnValue.str();
 }
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp
index c49e192fb4..a47cc5d838 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp
@@ -1,385 +1,385 @@
 /*===================================================================
 
 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 "QmitkImageStatisticsTreeModel.h"
 
 #include "QmitkImageStatisticsTreeItem.h"
 #include "itkMutexLockHolder.h"
 #include "mitkImageStatisticsContainerManager.h"
 #include "mitkProportionalTimeGeometry.h"
 #include "mitkStatisticsToImageRelationRule.h"
 #include "mitkStatisticsToMaskRelationRule.h"
 
 QmitkImageStatisticsTreeModel::QmitkImageStatisticsTreeModel(QObject *parent) : QmitkAbstractDataStorageModel(parent)
 {
   m_RootItem = new QmitkImageStatisticsTreeItem();
 }
 
 QmitkImageStatisticsTreeModel ::~QmitkImageStatisticsTreeModel()
 {
   // set data storage to nullptr so that the event listener gets removed
   this->SetDataStorage(nullptr);
   delete m_RootItem;
 };
 
 void QmitkImageStatisticsTreeModel::DataStorageChanged()
 {
   emit beginResetModel();
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::NodePredicateChanged()
 {
   emit beginResetModel();
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 int QmitkImageStatisticsTreeModel::columnCount(const QModelIndex& /*parent*/) const
 {
   int columns = m_StatisticNames.size() + 1;
   return columns;
 }
 
 int QmitkImageStatisticsTreeModel::rowCount(const QModelIndex &parent) const
 {
   QmitkImageStatisticsTreeItem *parentItem;
   if (parent.column() > 0)
     return 0;
 
   if (!parent.isValid())
     parentItem = m_RootItem;
   else
     parentItem = static_cast<QmitkImageStatisticsTreeItem *>(parent.internalPointer());
 
   return parentItem->childCount();
 }
 
 QVariant QmitkImageStatisticsTreeModel::data(const QModelIndex &index, int role) const
 {
   if (!index.isValid())
     return QVariant();
 
   if (role != Qt::DisplayRole)
     return QVariant();
 
   QmitkImageStatisticsTreeItem *item = static_cast<QmitkImageStatisticsTreeItem *>(index.internalPointer());
 
   return item->data(index.column());
 }
 
 QModelIndex QmitkImageStatisticsTreeModel::index(int row, int column, const QModelIndex &parent) const
 {
   if (!hasIndex(row, column, parent))
     return QModelIndex();
 
   QmitkImageStatisticsTreeItem *parentItem;
 
   if (!parent.isValid())
     parentItem = m_RootItem;
   else
     parentItem = static_cast<QmitkImageStatisticsTreeItem *>(parent.internalPointer());
 
   QmitkImageStatisticsTreeItem *childItem = parentItem->child(row);
   if (childItem)
     return createIndex(row, column, childItem);
   else
     return QModelIndex();
 }
 
 QModelIndex QmitkImageStatisticsTreeModel::parent(const QModelIndex &child) const
 {
   if (!child.isValid())
     return QModelIndex();
 
   QmitkImageStatisticsTreeItem *childItem = static_cast<QmitkImageStatisticsTreeItem *>(child.internalPointer());
   QmitkImageStatisticsTreeItem *parentItem = childItem->parentItem();
 
   if (parentItem == m_RootItem)
     return QModelIndex();
 
   return createIndex(parentItem->row(), 0, parentItem);
 }
 
 Qt::ItemFlags QmitkImageStatisticsTreeModel::flags(const QModelIndex &index) const
 {
   if (!index.isValid())
-    return 0;
+    return nullptr;
 
   return QAbstractItemModel::flags(index);
 }
 
 QVariant QmitkImageStatisticsTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if ((Qt::DisplayRole == role) && (Qt::Horizontal == orientation))
   {
     if (section == 0)
     {
       return m_HeaderFirstColumn;
     }
     else
     {
       return QVariant(m_StatisticNames.at(section - 1).c_str());
     }
   }
   return QVariant();
 }
 
 void QmitkImageStatisticsTreeModel::SetImageNodes(const std::vector<mitk::DataNode::ConstPointer> &nodes)
 {
   std::vector<std::pair<mitk::DataNode::ConstPointer, unsigned int>> tempNodes;
   for (const auto &node : nodes)
   {
     auto data = node->GetData();
     if (data)
     {
       auto timeSteps = data->GetTimeSteps();
       for (unsigned int i = 0; i < timeSteps; i++)
       {
         tempNodes.push_back(std::make_pair(node, i));
       }
     }
   }
 
   emit beginResetModel();
   m_TimeStepResolvedImageNodes = std::move(tempNodes);
   m_ImageNodes = nodes;
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::SetMaskNodes(const std::vector<mitk::DataNode::ConstPointer> &nodes)
 {
   std::vector<std::pair<mitk::DataNode::ConstPointer, unsigned int>> tempNodes;
   for (const auto &node : nodes)
   {
     auto data = node->GetData();
     if (data)
     {
       auto timeSteps = data->GetTimeSteps();
       // special case: apply one mask to each timestep of an 4D image
       if (timeSteps == 1 && m_TimeStepResolvedImageNodes.size() > 1)
       {
         timeSteps = m_TimeStepResolvedImageNodes.size();
       }
       for (unsigned int i = 0; i < timeSteps; i++)
       {
         tempNodes.push_back(std::make_pair(node, i));
       }
     }
   }
 
   emit beginResetModel();
   m_TimeStepResolvedMaskNodes = std::move(tempNodes);
   m_MaskNodes = nodes;
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::Clear()
 {
   emit beginResetModel();
   m_Statistics.clear();
   m_ImageNodes.clear();
   m_TimeStepResolvedImageNodes.clear();
   m_MaskNodes.clear();
   m_StatisticNames.clear();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::UpdateByDataStorage()
 {
   StatisticsContainerVector newStatistics;
 
   auto datamanager = m_DataStorage.Lock();
 
   if (datamanager.IsNotNull())
   {
     for (const auto &image : m_ImageNodes)
     {
       if (m_MaskNodes.empty())
       {
         auto stats = mitk::ImageStatisticsContainerManager::GetImageStatistics(datamanager, image->GetData());
 
         if (stats.IsNotNull())
         {
           newStatistics.emplace_back(stats);
         }
       }
       else
       {
         for (const auto &mask : m_MaskNodes)
         {
           auto stats =
             mitk::ImageStatisticsContainerManager::GetImageStatistics(datamanager, image->GetData(), mask->GetData());
           if (stats.IsNotNull())
           {
             newStatistics.emplace_back(stats);
           }
         }
       }
     }
     if (!newStatistics.empty())
     {
       emit dataAvailable();
     }
   }
 
   {
     itk::MutexLockHolder<itk::SimpleFastMutexLock> locked(m_Mutex);
     m_Statistics = newStatistics;
   }
 
   m_StatisticNames = mitk::GetAllStatisticNames(m_Statistics);
   BuildHierarchicalModel();
 }
 
 void QmitkImageStatisticsTreeModel::BuildHierarchicalModel()
 {
   // reset old model
   delete m_RootItem;
   m_RootItem = new QmitkImageStatisticsTreeItem();
 
   bool hasMask = false;
   bool hasMultipleTimesteps = false;
 
   std::map<mitk::DataNode::Pointer, QmitkImageStatisticsTreeItem *> dataNodeToTreeItem;
 
   for (auto statistic : m_Statistics)
   {
     // get the connected image data node/mask data node
     auto imageRule = mitk::StatisticsToImageRelationRule::New();
     auto imageOfStatisticsPredicate = imageRule->GetDestinationsDetector(statistic);
     auto imageCandidates = this->GetDataStorage()->GetSubset(imageOfStatisticsPredicate);
 
     auto maskRule = mitk::StatisticsToMaskRelationRule::New();
     auto maskOfStatisticsPredicate = maskRule->GetDestinationsDetector(statistic);
     auto maskCandidates = this->GetDataStorage()->GetSubset(maskOfStatisticsPredicate);
 
     if (imageCandidates->empty())
     {
       mitkThrow() << "no image found connected to statistic" << statistic << " Aborting.";
     }
     auto image = imageCandidates->front();
     // image: 1. hierarchy level
     QmitkImageStatisticsTreeItem *imageItem;
     auto search = dataNodeToTreeItem.find(image);
     // the tree item was created previously
     if (search != dataNodeToTreeItem.end())
     {
       imageItem = search->second;
     }
     // create the tree item
     else
     {
       QString imageLabel = QString::fromStdString(image->GetName());
       if (statistic->GetTimeSteps() == 1 && maskCandidates->empty())
       {
         auto statisticsObject = statistic->GetStatisticsForTimeStep(0);
         imageItem = new QmitkImageStatisticsTreeItem(statisticsObject, m_StatisticNames, imageLabel, m_RootItem);
       }
       else
       {
         imageItem = new QmitkImageStatisticsTreeItem(m_StatisticNames, imageLabel, m_RootItem);
       }
       m_RootItem->appendChild(imageItem);
       dataNodeToTreeItem.emplace(image, imageItem);
     }
 
     // mask: 2. hierarchy level (optional, only if mask exists)
     QmitkImageStatisticsTreeItem *lastParent;
     if (!maskCandidates->empty())
     {
       auto mask = maskCandidates->front();
       QString maskLabel = QString::fromStdString(mask->GetName());
       QmitkImageStatisticsTreeItem *maskItem;
       // add statistical values directly in this hierarchy level
       if (statistic->GetTimeSteps() == 1)
       {
         auto statisticsObject = statistic->GetStatisticsForTimeStep(0);
         maskItem = new QmitkImageStatisticsTreeItem(statisticsObject, m_StatisticNames, maskLabel, imageItem);
       }
       else
       {
         maskItem = new QmitkImageStatisticsTreeItem(m_StatisticNames, maskLabel, imageItem);
       }
 
       imageItem->appendChild(maskItem);
       lastParent = maskItem;
       hasMask = true;
     }
     else
     {
       lastParent = imageItem;
     }
     // 3. hierarchy level (optional, only if >1 timestep)
     if (statistic->GetTimeSteps() > 1)
     {
       for (unsigned int i = 0; i < statistic->GetTimeSteps(); i++)
       {
         QString timeStepLabel = "[" + QString::number(i) + "] " +
                                 QString::number(statistic->GetTimeGeometry()->TimeStepToTimePoint(i)) + " ms";
         if (statistic->TimeStepExists(i))
         {
           auto statisticsItem = new QmitkImageStatisticsTreeItem(
                 statistic->GetStatisticsForTimeStep(i), m_StatisticNames, timeStepLabel, lastParent);
           lastParent->appendChild(statisticsItem);
         }
       }
       hasMultipleTimesteps = true;
     }
   }
   QString headerString = "Images";
   if (hasMask)
   {
     headerString += "/Masks";
   }
   if (hasMultipleTimesteps)
   {
     headerString += "/Timesteps";
   }
   m_HeaderFirstColumn = headerString;
 }
 
 void QmitkImageStatisticsTreeModel::NodeRemoved(const mitk::DataNode *)
 {
   emit beginResetModel();
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::NodeAdded(const mitk::DataNode *)
 {
   emit beginResetModel();
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::NodeChanged(const mitk::DataNode *)
 {
   emit beginResetModel();
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
diff --git a/Modules/ModelFit/cmdapps/GenericFittingMiniApp.cpp b/Modules/ModelFit/cmdapps/GenericFittingMiniApp.cpp
index a9047570de..af1b963027 100644
--- a/Modules/ModelFit/cmdapps/GenericFittingMiniApp.cpp
+++ b/Modules/ModelFit/cmdapps/GenericFittingMiniApp.cpp
@@ -1,364 +1,364 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // std includes
 #include <string>
 
 // itk includes
 #include "itksys/SystemTools.hxx"
 
 // CTK includes
 #include "mitkCommandLineParser.h"
 
 // MITK includes
 #include <mitkIOUtil.h>
 #include <mitkPixelBasedParameterFitImageGenerator.h>
 #include <mitkROIBasedParameterFitImageGenerator.h>
 #include <mitkLinearModelParameterizer.h>
 #include <mitkGenericParamModelParameterizer.h>
 #include <mitkModelFitInfo.h>
 #include <mitkMaskedDynamicImageStatisticsGenerator.h>
 #include <mitkLevenbergMarquardtModelFitFunctor.h>
 #include <mitkNormalizedSumOfSquaredDifferencesFitCostFunction.h>
 #include <mitkExtractTimeGrid.h>
 #include <mitkModelFitCmdAppsHelper.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 
 std::string inFilename;
 std::string outFileName;
 std::string maskFileName;
 bool verbose(false);
 bool roibased(false);
 std::string functionName;
 std::string formular;
 mitk::Image::Pointer image;
 mitk::Image::Pointer mask;
 
 
 void onFitEvent(::itk::Object* caller, const itk::EventObject & event, void* /*data*/)
 {
     itk::ProgressEvent progressEvent;
 
     if (progressEvent.CheckEvent(&event))
     {
         mitk::ParameterFitImageGeneratorBase* castedReporter = dynamic_cast<mitk::ParameterFitImageGeneratorBase*>(caller);
         std::cout <<castedReporter->GetProgress()*100 << "% ";
     }
 }
 
 
 void setupParser(mitkCommandLineParser& parser)
 {
     // set general information about your MiniApp
     parser.setCategory("Dynamic Data Analysis Tools");
     parser.setTitle("Generic Fitting");
     parser.setDescription("MiniApp that allows to make a pixel based fitting on the intensity signal over time for a given model function.");
     parser.setContributor("DKFZ MIC");
     //! [create parser]
 
     //! [add arguments]
     // how should arguments be prefixed
     parser.setArgumentPrefix("--", "-");
     // add each argument, unless specified otherwise each argument is optional
     // see mitkCommandLineParser::addArgument for more information
     parser.beginGroup("Model parameters");
     parser.addArgument(
         "function", "f", mitkCommandLineParser::String, "Model function", "Function that should be used to fit the intensity signals. Options are: \"Linear\" or \"<Parameter Number>\" (for generic formulas).", us::Any(std::string("Linear")));
     parser.addArgument(
         "formular", "y", mitkCommandLineParser::String, "Generic model function formular", "Formular of a generic model (if selected) that will be parsed and fitted.", us::Any());
     parser.endGroup();
     parser.beginGroup("Required I/O parameters");
     parser.addArgument(
         "input", "i", mitkCommandLineParser::File, "Input file", "input 3D+t image file", us::Any(), false, false, false, mitkCommandLineParser::Input);
     parser.addArgument("output",
         "o",
         mitkCommandLineParser::File,
         "Output file template",
         "where to save the output parameter images. The specified path will be used as template to determine the format (via extension) and the name \"root\". For each parameter a suffix will be added to the name.",
         us::Any(),
         false, false, false, mitkCommandLineParser::Output);
     parser.endGroup();
 
     parser.beginGroup("Optional parameters");
     parser.addArgument(
         "mask", "m", mitkCommandLineParser::File, "Mask file", "Mask that defines the spatial image region that should be fitted. Must have the same geometry as the input image!", us::Any(), true, false, false, mitkCommandLineParser::Input);
     parser.addArgument(
         "verbose", "v", mitkCommandLineParser::Bool, "Verbose Output", "Whether to produce verbose output");
     parser.addArgument(
         "roibased", "r", mitkCommandLineParser::Bool, "Roi based fitting", "Will compute a mean intesity signal over the ROI before fitting it. If this mode is used a mask must be specified.");
     parser.addArgument("help", "h", mitkCommandLineParser::Bool, "Help:", "Show this help text");
     parser.endGroup();
     //! [add arguments]
 }
 
 bool configureApplicationSettings(std::map<std::string, us::Any> parsedArgs)
 {
     if (parsedArgs.size() == 0)
         return false;
 
     // parse, cast and set required arguments
     functionName = "Linear";
     if (parsedArgs.count("function"))
     {
         functionName = us::any_cast<std::string>(parsedArgs["function"]);
     }
     if (parsedArgs.count("formular"))
     {
         formular = us::any_cast<std::string>(parsedArgs["formular"]);
     }
     inFilename = us::any_cast<std::string>(parsedArgs["input"]);
     outFileName = us::any_cast<std::string>(parsedArgs["output"]);
 
 
     verbose = false;
     if (parsedArgs.count("verbose"))
     {
         verbose = us::any_cast<bool>(parsedArgs["verbose"]);
     }
 
     roibased = false;
     if (parsedArgs.count("roibased"))
     {
         roibased = us::any_cast<bool>(parsedArgs["roibased"]);
     }
 
     if (parsedArgs.count("mask"))
     {
         maskFileName = us::any_cast<std::string>(parsedArgs["mask"]);
     }
 
     return true;
 }
 
 void configureInitialParametersOfParameterizer(mitk::ModelParameterizerBase*
     parameterizer)
 {
     mitk::GenericParamModelParameterizer* genericParameterizer =
         dynamic_cast<mitk::GenericParamModelParameterizer*>(parameterizer);
 
     if (genericParameterizer)
     {
         genericParameterizer->SetFunctionString(formular);
     }
 }
 
 mitk::ModelFitFunctorBase::Pointer createDefaultFitFunctor(
     const mitk::ModelParameterizerBase* parameterizer)
 {
     mitk::LevenbergMarquardtModelFitFunctor::Pointer fitFunctor =
         mitk::LevenbergMarquardtModelFitFunctor::New();
 
     mitk::NormalizedSumOfSquaredDifferencesFitCostFunction::Pointer chi2 =
         mitk::NormalizedSumOfSquaredDifferencesFitCostFunction::New();
     fitFunctor->RegisterEvaluationParameter("Chi^2", chi2);
 
     mitk::ModelBase::Pointer refModel = parameterizer->GenerateParameterizedModel();
 
     ::itk::LevenbergMarquardtOptimizer::ScalesType scales;
     scales.SetSize(refModel->GetNumberOfParameters());
     scales.Fill(1.0);
     fitFunctor->SetScales(scales);
 
     fitFunctor->SetDebugParameterMaps(true);
 
     return fitFunctor.GetPointer();
 }
 
 template <typename TParameterizer>
 void generateModelFit_PixelBased(mitk::modelFit::ModelFitInfo::Pointer&
     /*modelFitInfo*/, mitk::ParameterFitImageGeneratorBase::Pointer& generator)
 {
     mitk::PixelBasedParameterFitImageGenerator::Pointer fitGenerator =
         mitk::PixelBasedParameterFitImageGenerator::New();
 
     typename TParameterizer::Pointer modelParameterizer =
         TParameterizer::New();
 
     configureInitialParametersOfParameterizer(modelParameterizer);
 
     //Specify fitting strategy and criterion parameters
     mitk::ModelFitFunctorBase::Pointer fitFunctor = createDefaultFitFunctor(modelParameterizer);
 
     //Parametrize fit generator
     fitGenerator->SetModelParameterizer(modelParameterizer);
 
     fitGenerator->SetMask(mask);
 
     fitGenerator->SetDynamicImage(image);
     fitGenerator->SetFitFunctor(fitFunctor);
 
     generator = fitGenerator.GetPointer();
 }
 
 template <typename TParameterizer>
 void generateModelFit_ROIBased(
     mitk::modelFit::ModelFitInfo::Pointer& /*modelFitInfo*/,
     mitk::ParameterFitImageGeneratorBase::Pointer& generator)
 {
     mitk::ROIBasedParameterFitImageGenerator::Pointer fitGenerator =
         mitk::ROIBasedParameterFitImageGenerator::New();
 
     typename TParameterizer::Pointer modelParameterizer =
         TParameterizer::New();
 
     configureInitialParametersOfParameterizer(modelParameterizer);
 
     //Compute ROI signal
     mitk::MaskedDynamicImageStatisticsGenerator::Pointer signalGenerator =
         mitk::MaskedDynamicImageStatisticsGenerator::New();
     signalGenerator->SetMask(mask);
     signalGenerator->SetDynamicImage(image);
     signalGenerator->Generate();
 
     mitk::MaskedDynamicImageStatisticsGenerator::ResultType roiSignal = signalGenerator->GetMean();
 
     //Specify fitting strategy and criterion parameters
     mitk::ModelFitFunctorBase::Pointer fitFunctor = createDefaultFitFunctor(modelParameterizer);
 
     //Parametrize fit generator
     fitGenerator->SetModelParameterizer(modelParameterizer);
     fitGenerator->SetMask(mask);
     fitGenerator->SetFitFunctor(fitFunctor);
     fitGenerator->SetSignal(roiSignal);
     fitGenerator->SetTimeGrid(mitk::ExtractTimeGrid(image));
 
     generator = fitGenerator.GetPointer();
 }
 
 void doFitting()
 {
-        mitk::ParameterFitImageGeneratorBase::Pointer generator = NULL;
-        mitk::modelFit::ModelFitInfo::Pointer fitSession = NULL;
+        mitk::ParameterFitImageGeneratorBase::Pointer generator = nullptr;
+        mitk::modelFit::ModelFitInfo::Pointer fitSession = nullptr;
 
         ::itk::CStyleCommand::Pointer command = ::itk::CStyleCommand::New();
         command->SetCallback(onFitEvent);
 
         bool isLinearFactory = functionName == "Linear";
 
         if (isLinearFactory)
         {
             std::cout << "Model:  linear" << std::endl;
             if (!roibased)
             {
                 generateModelFit_PixelBased<mitk::LinearModelParameterizer>(fitSession, generator);
             }
             else
             {
                 generateModelFit_ROIBased<mitk::LinearModelParameterizer>(fitSession, generator);
             }
         }
         else
         {
             std::cout << "Model:  generic (2 parameter)" << std::endl;
             if (!roibased)
             {
                 generateModelFit_PixelBased<mitk::GenericParamModelParameterizer>(fitSession, generator);
             }
             else
             {
                 generateModelFit_ROIBased<mitk::GenericParamModelParameterizer>(fitSession, generator);
             }
         }
 
         if (generator.IsNotNull() )
         {
             std::cout << "Started fitting process..." << std::endl;
             generator->AddObserver(::itk::AnyEvent(), command);
             generator->Generate();
             std::cout << std::endl << "Finished fitting process" << std::endl;
 
             mitk::storeModelFitGeneratorResults(outFileName, generator, fitSession);
         }
         else
         {
             mitkThrow() << "Fitting error! Could not initalize fitting job.";
         }
 }
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
     setupParser(parser);
 
     mitk::PreferenceListReaderOptionsFunctor readerFilterFunctor = mitk::PreferenceListReaderOptionsFunctor({ "MITK DICOM Reader v2 (classic config)" }, { "MITK DICOM Reader" });
 
     const std::map<std::string, us::Any>& parsedArgs = parser.parseArguments(argc, argv);
     if (!configureApplicationSettings(parsedArgs))
     {
         return EXIT_FAILURE;
     };
 
     // Show a help message
     if (parsedArgs.count("help") || parsedArgs.count("h"))
     {
         std::cout << parser.helpText();
         return EXIT_SUCCESS;
     }
 
     //! [do processing]
     try
     {
         image = mitk::IOUtil::Load<mitk::Image>(inFilename, &readerFilterFunctor);
         std::cout << "Input: " << inFilename << std::endl;
 
         if (!maskFileName.empty())
         {
             mask = mitk::IOUtil::Load<mitk::Image>(maskFileName, &readerFilterFunctor);
             std::cout << "Mask:  " << maskFileName << std::endl;
         }
         else
         {
             std::cout << "Mask:  none" << std::endl;
         }
 
         if (roibased && mask.IsNull())
         {
             mitkThrow() << "Error. Cannot fit. Please specify mask if you select roi based fitting.";
         }
 
         std::cout << "Style: ";
         if (roibased)
         {
             std::cout << "ROI based";
         }
         else
         {
             std::cout << "pixel based";
         }
         std::cout << std::endl;
 
         doFitting();
 
         std::cout << "Processing finished." << std::endl;
 
         return EXIT_SUCCESS;
     }
     catch (const itk::ExceptionObject& e)
     {
         MITK_ERROR << e.what();
         return EXIT_FAILURE;
     }
     catch (const std::exception& e)
     {
         MITK_ERROR << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_ERROR << "Unexpected error encountered.";
         return EXIT_FAILURE;
     }
 }
diff --git a/Modules/ModelFit/include/itkMultiOutputNaryFunctorImageFilter.tpp b/Modules/ModelFit/include/itkMultiOutputNaryFunctorImageFilter.tpp
index deb5513da0..998494d954 100644
--- a/Modules/ModelFit/include/itkMultiOutputNaryFunctorImageFilter.tpp
+++ b/Modules/ModelFit/include/itkMultiOutputNaryFunctorImageFilter.tpp
@@ -1,235 +1,235 @@
 /*===================================================================
 
 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 __itkMultiOutputNaryFunctorImageFilter_hxx
 #define __itkMultiOutputNaryFunctorImageFilter_hxx
 
 #include "itkMultiOutputNaryFunctorImageFilter.h"
 #include "itkImageRegionIterator.h"
 #include "itkProgressReporter.h"
 
 namespace itk
 {
   /**
   * Constructor
   */
   template< class TInputImage, class TOutputImage, class TFunction, class TMaskImage >
   MultiOutputNaryFunctorImageFilter< TInputImage, TOutputImage, TFunction, TMaskImage >
     ::MultiOutputNaryFunctorImageFilter()
   {
     // This number will be incremented each time an image
     // is added over the two minimum required
     this->SetNumberOfRequiredInputs(1);
 
     this->ActualizeOutputs();
   }
 
   template< class TInputImage, class TOutputImage, class TFunction, class TMaskImage >
   void
     MultiOutputNaryFunctorImageFilter< TInputImage, TOutputImage, TFunction, TMaskImage >
     ::ActualizeOutputs()
   {
     this->SetNumberOfRequiredOutputs(m_Functor.GetNumberOfOutputs());
 
     for (typename Superclass::DataObjectPointerArraySizeType i = this->GetNumberOfIndexedOutputs(); i< m_Functor.GetNumberOfOutputs(); ++i)
     {
       this->SetNthOutput( i, this->MakeOutput(i) );
     }
 
     while(this->GetNumberOfIndexedOutputs() > m_Functor.GetNumberOfOutputs())
     {
       this->RemoveOutput(this->GetNumberOfIndexedOutputs()-1);
     }
   };
 
   /**
   * ThreadedGenerateData Performs the pixel-wise addition
   */
   template< class TInputImage, class TOutputImage, class TFunction, class TMaskImage >
   void
     MultiOutputNaryFunctorImageFilter< TInputImage, TOutputImage, TFunction, TMaskImage >
     ::ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread,
     ThreadIdType threadId)
   {
     ProgressReporter progress( this, threadId,
       outputRegionForThread.GetNumberOfPixels() );
 
     const unsigned int numberOfInputImages =
       static_cast< unsigned int >( this->GetNumberOfIndexedInputs() );
 
     const unsigned int numberOfOutputImages =
       static_cast< unsigned int >( this->GetNumberOfIndexedOutputs() );
 
     typedef ImageRegionConstIterator< TInputImage > ImageRegionConstIteratorType;
     std::vector< ImageRegionConstIteratorType * > inputItrVector;
     inputItrVector.reserve(numberOfInputImages);
 
     typedef ImageRegionIterator< TOutputImage > OutputImageRegionIteratorType;
     std::vector< OutputImageRegionIteratorType * > outputItrVector;
     outputItrVector.reserve(numberOfOutputImages);
 
     //check if mask image is set and generate iterator if mask is valid
     typedef ImageRegionConstIterator< TMaskImage > MaskImageRegionIteratorType;
-    MaskImageRegionIteratorType* pMaskIterator = NULL;
+    MaskImageRegionIteratorType* pMaskIterator = nullptr;
 
     if (m_Mask.IsNotNull())
     {
       if (!m_Mask->GetLargestPossibleRegion().IsInside(outputRegionForThread))
       {
         itkExceptionMacro("Mask of filter is set but does not cover region of thread. Mask region: "<< m_Mask->GetLargestPossibleRegion() <<"Thread region: "<<outputRegionForThread)
       }
       pMaskIterator = new MaskImageRegionIteratorType(m_Mask,outputRegionForThread);
     }
 
     // go through the inputs and add iterators for non-null inputs
     for ( unsigned int i = 0; i < numberOfInputImages; ++i )
     {
       InputImagePointer inputPtr =
         dynamic_cast< TInputImage * >( ProcessObject::GetInput(i) );
 
       if ( inputPtr )
       {
         inputItrVector.push_back( new ImageRegionConstIteratorType(inputPtr, outputRegionForThread) );
       }
 
     }
 
     // go through the outputs and add iterators for non-null outputs
     for ( unsigned int i = 0; i < numberOfOutputImages; ++i )
     {
       OutputImagePointer outputPtr =
         dynamic_cast< TOutputImage * >( ProcessObject::GetOutput(i) );
 
       if ( outputPtr )
       {
         outputItrVector.push_back( new OutputImageRegionIteratorType(outputPtr, outputRegionForThread) );
       }
     }
 
     typename std::vector< ImageRegionConstIteratorType * >::iterator regionInputIterators;
     const typename std::vector< ImageRegionConstIteratorType * >::const_iterator regionInputItEnd =
       inputItrVector.end();
 
     typename std::vector< OutputImageRegionIteratorType * >::iterator regionOutputIterators;
     const typename std::vector< OutputImageRegionIteratorType * >::const_iterator regionOutputItEnd =
       outputItrVector.end();
 
     const unsigned int numberOfValidInputImages = inputItrVector.size();
     const unsigned int numberOfValidOutputImages = outputItrVector.size();
 
     if ( (numberOfValidInputImages != 0) && ( numberOfValidOutputImages != 0))
     {
       try
       {
 
         while ( !(outputItrVector.front()->IsAtEnd()) )
         {
           typename NaryInputArrayType::iterator arrayInIt;
           typename NaryOutputArrayType::iterator arrayOutIt;
           NaryInputArrayType naryInputArray(numberOfValidInputImages);
           NaryOutputArrayType naryOutputArray(numberOfValidOutputImages);
 
           bool isValid = true;
 
           if (pMaskIterator)
           {
             isValid = pMaskIterator->Get() > 0;
             ++(*pMaskIterator);
           }
 
           arrayInIt = naryInputArray.begin();
           regionInputIterators = inputItrVector.begin();
 
           typename ImageRegionConstIteratorType::IndexType currentIndex;
           if(regionInputIterators != regionInputItEnd)
           {
             currentIndex = ( *regionInputIterators )->GetIndex();
           }
 
           while ( regionInputIterators != regionInputItEnd )
           {
             *arrayInIt++ = ( *regionInputIterators )->Get();
             ++( *( *regionInputIterators ) );
             ++regionInputIterators;
           }
 
           if (isValid)
           {
             naryOutputArray = m_Functor(naryInputArray, currentIndex);
 
             if (numberOfValidOutputImages != naryOutputArray.size())
             {
               itkExceptionMacro("Error. Number of valid output images do not equal number of outputs required by functor. Number of valid outputs: "<< numberOfValidOutputImages << "; needed output number:" << this->m_Functor.GetNumberOfOutputs());
             }
           }
           else
           {
             for (typename NaryOutputArrayType::iterator pos = naryOutputArray.begin(); pos!= naryOutputArray.end(); ++pos)
             {
                 *pos = 0.0;
             }
           }
 
           arrayOutIt = naryOutputArray.begin();
           regionOutputIterators = outputItrVector.begin();
           while ( regionOutputIterators != regionOutputItEnd )
           {
             ( *regionOutputIterators )->Set(*arrayOutIt++);
             ++( *( *regionOutputIterators ) );
             ++regionOutputIterators;
           }
 
           progress.CompletedPixel();
         }
       }
       catch(...)
       {
         // Free memory in case of exceptions
         regionInputIterators = inputItrVector.begin();
         while ( regionInputIterators != regionInputItEnd )
         {
           delete ( *regionInputIterators++ );
         }
 
         regionOutputIterators = outputItrVector.begin();
         while ( regionOutputIterators != regionOutputItEnd )
         {
           delete ( *regionOutputIterators++ );
         }
 
         delete pMaskIterator;
         throw;
       }
     }
 
     // Free memory regulary
     regionInputIterators = inputItrVector.begin();
     while ( regionInputIterators != regionInputItEnd )
     {
       delete ( *regionInputIterators++ );
     }
 
     regionOutputIterators = outputItrVector.begin();
     while ( regionOutputIterators != regionOutputItEnd )
     {
       delete ( *regionOutputIterators++ );
     }
 
     delete pMaskIterator;
   }
 } // end namespace itk
 
 #endif
diff --git a/Modules/ModelFit/include/mitkModelFitResultHelper.h b/Modules/ModelFit/include/mitkModelFitResultHelper.h
index 8e8625fc02..fe58e629bf 100644
--- a/Modules/ModelFit/include/mitkModelFitResultHelper.h
+++ b/Modules/ModelFit/include/mitkModelFitResultHelper.h
@@ -1,65 +1,65 @@
 /*===================================================================
 
 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 __MITK_MODEL_FIT_RESULT_HELPER_H_
 #define __MITK_MODEL_FIT_RESULT_HELPER_H_
 
 #include <mitkImage.h>
 #include <mitkDataNode.h>
 
 #include "mitkScalarListLookupTableProperty.h"
 #include "mitkModelBase.h"
 #include "mitkModelFitParameter.h"
 #include "mitkModelFitStaticParameterMap.h"
 
 #include "MitkModelFitExports.h"
 
 namespace mitk
 {
   class DataStorage;
   class ModelTraitsInterface;
   class ModelBase;
 
   namespace modelFit
   {
     class ModelFitInfo;
 
     typedef std::map<ModelBase::ParameterNameType,Image::Pointer> ModelFitResultImageMapType;
     typedef std::vector<DataNode::Pointer> ModelFitResultNodeVectorType;
 
     /**Helper function that sets the properties of the passed base data according to the given model fit info instance and parameter specification.
      @param data Instance that properties should be configured.
      @param name Name of the parameter this data instance represents.
      @param dataType Type of the parameter this data instance represents.
      @param fitInfo Instance to the fit info that containes the information of the fit that derived the parameter.
      @pre Data must point to a valid instance.
      @pre fitInfo must point to an valid instance.
     */
     MITKMODELFIT_EXPORT void SetModelFitDataProperties(mitk::BaseData* data, const ModelBase::ParameterNameType& name, modelFit::Parameter::Type dataType, const modelFit::ModelFitInfo* fitInfo);
 
     MITKMODELFIT_EXPORT mitk::ScalarListLookupTableProperty::Pointer ConvertStaticParametersToProperty(const mitk::modelFit::StaticParameterMap& params);
 
     MITKMODELFIT_EXPORT DataNode::Pointer CreateResultNode(const ModelBase::ParameterNameType& name, modelFit::Parameter::Type nodeType, Image* parameterImage, const ModelFitInfo* modelFitInfo);
 
     MITKMODELFIT_EXPORT ModelFitResultNodeVectorType CreateResultNodeMap(const ModelFitResultImageMapType& results, const ModelFitResultImageMapType& derivedResults, const ModelFitResultImageMapType& criterionResults, const ModelFitResultImageMapType& evaluationResults, const ModelFitInfo* fitInfo);
 
-    MITKMODELFIT_EXPORT void StoreResultsInDataStorage(DataStorage* storage, const ModelFitResultNodeVectorType& resultNodes, DataNode* parentNode = NULL);
+    MITKMODELFIT_EXPORT void StoreResultsInDataStorage(DataStorage* storage, const ModelFitResultNodeVectorType& resultNodes, DataNode* parentNode = nullptr);
 
   }
 
 }
 
 #endif
diff --git a/Modules/ModelFit/src/Common/mitkFormulaParser.cpp b/Modules/ModelFit/src/Common/mitkFormulaParser.cpp
index fe8d95bbbb..b5427bcf65 100644
--- a/Modules/ModelFit/src/Common/mitkFormulaParser.cpp
+++ b/Modules/ModelFit/src/Common/mitkFormulaParser.cpp
@@ -1,294 +1,294 @@
 /*===================================================================
 
 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 <boost/math/constants/constants.hpp>
 #include <boost/spirit/include/qi.hpp>
 #include <boost/spirit/include/phoenix.hpp>
 #include <boost/version.hpp>
 
 #include "mitkFormulaParser.h"
 #include "mitkFresnel.h"
 
 namespace qi = boost::spirit::qi;
 namespace ascii = boost::spirit::ascii;
 namespace phx = boost::phoenix;
 
 typedef std::string::const_iterator Iter;
 typedef ascii::space_type Skipper;
 
 namespace qi = boost::spirit::qi;
 
 namespace mitk
 {
   /*!
    *	@brief			Transforms the given number from degrees to radians and returns it.
    *	@tparam T		The scalar type that represents a value (e.g. double).
    *	@param[in] deg	A scalar value in degrees.
    *	@return			The given value in radians.
    */
   template<typename T>
   inline T deg2rad(const T deg)
   {
     return deg * boost::math::constants::pi<T>() / static_cast<T>(180);
   }
 
   /*!
    *	@brief			Returns the cosine of the given degree scalar.
    *	@tparam T		The scalar type that represents a value (e.g. double).
    *	@param[in] t	A scalar value in degrees whose cosine should be returned.
    *	@return			The cosine of the given degree scalar.
    */
   template<typename T>
   inline T cosd(const T t)
   {
     return std::cos(deg2rad(t));
   }
 
   /*!
    *	@brief			Returns the sine of the given degree scalar.
    *	@tparam T		The scalar type that represents a value (e.g. double).
    *	@param[in] t	A scalar value in degrees whose sine should be returned.
    *	@return			The sine of the given degree scalar.
    */
   template<typename T>
   inline T sind(const T t)
   {
     return std::sin(deg2rad(t));
   }
 
   /*!
    *	@brief			Returns the tangent of the given degree scalar.
    *	@tparam T		The scalar type that represents a value (e.g. double).
    *	@param[in] t	A scalar value in degrees whose tangent should be returned.
    *	@return			The tangent of the given degree scalar.
    */
   template<typename T>
   inline T tand(const T t)
   {
     return std::tan(deg2rad(t));
   }
 
   /*!
    *	@brief			Returns the fresnel integral sine at the given x-coordinate.
    *	@details		Code for "fresnel_s()" (fresnel.cpp and fresnel.h) taken as-is from the GNU
    *					Scientific Library (http://www.gnu.org/software/gsl/), specifically from
    *					http://www.network-theory.co.uk/download/gslextras/Fresnel/.
    *	@tparam T		The scalar type that represents a value (e.g. double).
    *	@param[in] t	The x-coordinate at which the fresnel integral sine should be returned.
    *	@return			The fresnel integral sine at the given x-coordinate.
    */
   template<typename T>
   T fresnelS(const T t)
   {
     T x = t / boost::math::constants::root_half_pi<T>();
     return static_cast<T>(fresnel_s(x) / boost::math::constants::root_two_div_pi<T>());
   }
 
   /*!
    *	@brief			Returns the fresnel integral cosine at the given x-coordinate.
    *	@details		Code for "fresnel_c()" (fresnel.cpp and fresnel.h) taken as-is from the GNU
    *					Scientific Library (http://www.gnu.org/software/gsl/), specifically from
    *					http://www.network-theory.co.uk/download/gslextras/Fresnel/.
    *	@tparam T		The scalar type that represents a value (e.g. double).
    *	@param[in] t	The x-coordinate at which the fresnel integral cosine should be returned.
    *	@return			The fresnel integral cosine at the given x-coordinate.
    */
   template<typename T>
   T fresnelC(const T t)
   {
     T x = t / boost::math::constants::root_half_pi<T>();
     return static_cast<T>(fresnel_c(x) / boost::math::constants::root_two_div_pi<T>());
   }
 
   /*!
    *	@brief		The grammar that defines the language (i.e. what is allowed) for the parser.
    */
   class Grammar : public qi::grammar<Iter, FormulaParser::ValueType(), Skipper>
   {
     /*!
      *	@brief	Helper structure that makes it easier to dynamically call any
      *			one-parameter-function by overloading the @c () operator.
      */
     struct func1_
     {
       // Required for Phoenix 3+
       template<typename Sig>
       struct result;
 
       /*!
        *	@brief				Helper structure that is needed for compatibility with
        *						@c boost::phoenix.
        *	@tparam Functor		Type of the functor (this struct).
        *	@tparam Function	Type of the function that should be called.
        *	@tparam Arg1		Type of the argument the function should be called with.
        *
        */
       template<typename Functor, typename Function, typename Arg1>
       struct result<Functor(Function, Arg1&)>
       {
         /*! @brief The result structure always needs this typedef */
         typedef Arg1 type;
       };
 
       /*!
        *	@brief				Calls the function @b f with the argument @b a1 and returns the
        *						result.
        *						The result always has the same type as the argument.
        *	@tparam Function	Type of the function that should be called.
        *	@tparam Arg1			Type of the argument the function should be called with.
        *	@param[in] f		The function that should be called.
        *	@param[in] a1		The argument the function should be called with.
        *	@return				The result of the called function.
        */
       template<typename Function, typename Arg1>
       Arg1 operator()(const Function f, const Arg1 a1) const
       {
         return f(a1);
       }
     };
 
     /*!
      *	@brief	Helper structure that maps strings to function calls so that parsing e.g.
      *			@c "cos(0)" actually calls the @c std::cos function with parameter @c 1 so it
      *			returns @c 0.
      */
     class unaryFunction_ :
       public qi::symbols<typename std::iterator_traits<Iter>::value_type, FormulaParser::ValueType(*)(FormulaParser::ValueType)>
     {
     public:
       /*!
        *	@brief Constructs the structure, this is where the mapping takes place.
        */
       unaryFunction_()
       {
         this->add
         ("abs", static_cast<FormulaParser::ValueType(*)(FormulaParser::ValueType)>(&std::abs))
           ("exp", static_cast<FormulaParser::ValueType(*)(FormulaParser::ValueType)>(&std::exp)) // @TODO: exp ignores division by zero
           ("sin", static_cast<FormulaParser::ValueType(*)(FormulaParser::ValueType)>(&std::sin))
           ("cos", static_cast<FormulaParser::ValueType(*)(FormulaParser::ValueType)>(&std::cos))
           ("tan", static_cast<FormulaParser::ValueType(*)(FormulaParser::ValueType)>(&std::tan))
           ("sind", &sind)
           ("cosd", &cosd)
           ("tand", &tand)
           ("fresnelS", &fresnelS)
           ("fresnelC", &fresnelC);
       }
     } unaryFunction;
 
   public:
     /*!
      *	@brief							Constructs the grammar with the given formula parser.
      *	@param[in, out] formulaParser	The formula parser this grammar is for - so it can
      *									access its variable map.
      */
     Grammar(FormulaParser& formulaParser) : Grammar::base_type(start)
     {
       using qi::_val;
       using qi::_1;
       using qi::_2;
       using qi::char_;
       using qi::alpha;
       using qi::alnum;
       using qi::double_;
       using qi::as_string;
 
       phx::function<func1_> func1;
 
       start = expression > qi::eoi;
 
       expression = term[_val = _1]
         >> *(('+' >> term[_val += _1])
           | ('-' >> term[_val -= _1]));
 
       term = factor[_val = _1]
         >> *(('*' >> factor[_val *= _1])
           | ('/' >> factor[_val /= _1]));
 
       factor = primary[_val = _1];
       /*!	@TODO:	Repair exponentiation */
       //>> *('^' >> factor[phx::bind<FormulaParser::ValueType, FormulaParser::ValueType, FormulaParser::ValueType>(std::pow, _val, _1)]);
 
       variable = as_string[alpha >> *(alnum | char_('_'))]
         [_val = phx::bind(&FormulaParser::lookupVariable, &formulaParser, _1)];
 
       primary = double_[_val = _1]
         | '(' >> expression[_val = _1] >> ')'
         | ('-' >> primary[_val = -_1])
         | ('+' >> primary[_val = _1])
         | (unaryFunction >> '(' >> expression >> ')')[_val = func1(_1, _2)]
         | variable[_val = _1];
     }
 
     /*! the rules of the grammar. */
     qi::rule<Iter, FormulaParser::ValueType(), Skipper> start;
     qi::rule<Iter, FormulaParser::ValueType(), Skipper> expression;
     qi::rule<Iter, FormulaParser::ValueType(), Skipper> term;
     qi::rule<Iter, FormulaParser::ValueType(), Skipper> factor;
     qi::rule<Iter, FormulaParser::ValueType(), Skipper> variable;
     qi::rule<Iter, FormulaParser::ValueType(), Skipper> primary;
   };
 
 
   FormulaParser::FormulaParser(const VariableMapType* variables) : m_Variables(variables)
   {}
 
   FormulaParser::ValueType FormulaParser::parse(const std::string& input)
   {
     std::string::const_iterator iter = input.begin();
     std::string::const_iterator end = input.end();
     FormulaParser::ValueType result = static_cast<FormulaParser::ValueType>(0);
 
     try
     {
       if (!qi::phrase_parse(iter, end, Grammar(*this), ascii::space, result))
       {
         mitkThrowException(FormulaParserException) << "Could not parse '" << input <<
           "': Grammar could not be applied to the input " << "at all.";
       }
     }
     catch (qi::expectation_failure<Iter>& e)
     {
       std::string parsed = "";
 
       for (Iter i = input.begin(); i != e.first; i++)
       {
         parsed += *i;
       }
       mitkThrowException(FormulaParserException) << "Error while parsing '" << input <<
         "': Unexpected character '" << *e.first << "' after '" << parsed << "'";
     }
 
     return result;
   };
 
   FormulaParser::ValueType FormulaParser::lookupVariable(const std::string var)
   {
-    if (m_Variables == NULL)
+    if (m_Variables == nullptr)
     {
       mitkThrowException(FormulaParserException) << "Map of variables is empty";
     }
 
     try
     {
       return m_Variables->at(var);
     }
     catch (std::out_of_range&)
     {
       mitkThrowException(FormulaParserException) << "No variable '" << var << "' defined in lookup";
     }
   };
 
 }
diff --git a/Modules/ModelFit/src/Common/mitkMaskedDynamicImageStatisticsGenerator.cpp b/Modules/ModelFit/src/Common/mitkMaskedDynamicImageStatisticsGenerator.cpp
index 5fc4936c1c..005e9dce7c 100644
--- a/Modules/ModelFit/src/Common/mitkMaskedDynamicImageStatisticsGenerator.cpp
+++ b/Modules/ModelFit/src/Common/mitkMaskedDynamicImageStatisticsGenerator.cpp
@@ -1,197 +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 "mitkMaskedDynamicImageStatisticsGenerator.h"
 
 #include "mitkImageTimeSelector.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include "itkMaskedNaryStatisticsImageFilter.h"
 
 mitk::MaskedDynamicImageStatisticsGenerator::MaskedDynamicImageStatisticsGenerator()
 {
-  m_Mask = NULL;
-  m_DynamicImage = NULL;
+  m_Mask = nullptr;
+  m_DynamicImage = nullptr;
 };
 
 mitk::MaskedDynamicImageStatisticsGenerator::~MaskedDynamicImageStatisticsGenerator(){};
 
 const mitk::MaskedDynamicImageStatisticsGenerator::ResultType& mitk::MaskedDynamicImageStatisticsGenerator::GetMaximum()
 {
   if(this->HasOutdatedResults())
   {
     CheckValidInputs();
     Generate();
   }
   return m_Maximum;
 };
 
 const mitk::MaskedDynamicImageStatisticsGenerator::ResultType& mitk::MaskedDynamicImageStatisticsGenerator::GetMinimum()
 {
   if(this->HasOutdatedResults())
   {
     CheckValidInputs();
     Generate();
   }
   return m_Minimum;
 };
 
 const mitk::MaskedDynamicImageStatisticsGenerator::ResultType& mitk::MaskedDynamicImageStatisticsGenerator::GetMean()
 {
   if(this->HasOutdatedResults())
   {
     CheckValidInputs();
     Generate();
   }
   return m_Mean;
 };
 
 const mitk::MaskedDynamicImageStatisticsGenerator::ResultType& mitk::MaskedDynamicImageStatisticsGenerator::GetSigma()
 {
   if(this->HasOutdatedResults())
   {
     CheckValidInputs();
     Generate();
   }
   return m_Sigma;
 };
 
 const mitk::MaskedDynamicImageStatisticsGenerator::ResultType& mitk::MaskedDynamicImageStatisticsGenerator::GetVariance()
 {
   if(this->HasOutdatedResults())
   {
     CheckValidInputs();
     Generate();
   }
   return m_Variance;
 };
 
 const mitk::MaskedDynamicImageStatisticsGenerator::ResultType& mitk::MaskedDynamicImageStatisticsGenerator::GetSum()
 {
   if(this->HasOutdatedResults())
   {
     CheckValidInputs();
     Generate();
   }
   return m_Sum;
 };
 
 template <typename TPixel, unsigned int VDim>
 void mitk::MaskedDynamicImageStatisticsGenerator::DoCalculateStatistics(const itk::Image<TPixel, VDim>* /*image*/)
 {
   typedef itk::Image<TPixel, VDim-1> InputFrameImageType;
   typedef itk::MaskedNaryStatisticsImageFilter<InputFrameImageType, InternalMaskType> FilterType;
 
   typename FilterType::Pointer statFilter = FilterType::New();
 
   //add the time frames to the fit filter
   unsigned int timeSteps = this->m_DynamicImage->GetTimeSteps();
   std::vector<Image::Pointer> frameCache;
   mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
   imageTimeSelector->SetInput(this->m_DynamicImage);
   for (unsigned int i = 0; i < timeSteps; ++i)
   {
     typename InputFrameImageType::Pointer frameImage;
     imageTimeSelector->SetTimeNr(i);
     imageTimeSelector->UpdateLargestPossibleRegion();
 
     Image::Pointer frameMITKImage = imageTimeSelector->GetOutput();
     frameCache.push_back(frameMITKImage);
     mitk::CastToItkImage(frameMITKImage, frameImage);
     statFilter->SetInput(i,frameImage);
   }
 
   if (this->m_InternalMask.IsNotNull())
   {
     statFilter->SetMask(this->m_InternalMask);
   }
 
   statFilter->Update();
 
   m_Maximum.SetSize(timeSteps);
   m_Minimum.SetSize(timeSteps);
   m_Mean.SetSize(timeSteps);
   m_Sigma.SetSize(timeSteps);
   m_Variance.SetSize(timeSteps);
   m_Sum.SetSize(timeSteps);
 
   for (unsigned int i = 0; i < timeSteps; ++i)
   {
     m_Maximum.SetElement(i,statFilter->GetMaximum()[i]);
     m_Minimum.SetElement(i,statFilter->GetMinimum()[i]);
     m_Mean.SetElement(i,statFilter->GetMean()[i]);
     m_Sigma.SetElement(i,statFilter->GetSigma()[i]);
     m_Variance.SetElement(i,statFilter->GetVariance()[i]);
     m_Sum.SetElement(i,statFilter->GetSum()[i]);
   }
 
   this->m_GenerationTimeStamp.Modified();
 }
 
 void mitk::MaskedDynamicImageStatisticsGenerator::Generate()
 {
   if(this->m_Mask.IsNotNull())
   {
     InternalMaskType::Pointer castedMask;
     CastToItkImage<InternalMaskType>(m_Mask, castedMask);
     if (castedMask.IsNull())
     {
       mitkThrow() << "Dynamic cast of mask went wrong. Internal Mask is NULL. Image statistics cannot be generated.";
     }
 
     this->m_InternalMask = castedMask;
   }
   else
   {
-    this->m_InternalMask = NULL;
+    this->m_InternalMask = nullptr;
   }
 
   AccessFixedDimensionByItk(m_DynamicImage, mitk::MaskedDynamicImageStatisticsGenerator::DoCalculateStatistics, 4);
 }
 
 void
   mitk::MaskedDynamicImageStatisticsGenerator::CheckValidInputs() const
 {
 
   if (m_DynamicImage.IsNull())
   {
     mitkThrow() << "Cannot generate statistics. Input dynamic image is not set.";
   }
 }
 
 bool
   mitk::MaskedDynamicImageStatisticsGenerator::HasOutdatedResults() const
 {
   bool result = this->GetMTime() > this->m_GenerationTimeStamp;
 
   if (m_DynamicImage.IsNotNull())
   {
     if (m_DynamicImage->GetMTime() > this->m_GenerationTimeStamp)
     {
       result = true;
     }
   }
 
   if (m_Mask.IsNotNull())
   {
     if (m_Mask->GetMTime() > this->m_GenerationTimeStamp)
     {
       result = true;
     }
   }
   return result;
 
 };
diff --git a/Modules/ModelFit/src/Common/mitkModelFitInfo.cpp b/Modules/ModelFit/src/Common/mitkModelFitInfo.cpp
index 390f54e648..576ed9a260 100644
--- a/Modules/ModelFit/src/Common/mitkModelFitInfo.cpp
+++ b/Modules/ModelFit/src/Common/mitkModelFitInfo.cpp
@@ -1,433 +1,433 @@
 /*===================================================================
 
 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 <mitkNodePredicateDataProperty.h>
 #include <mitkUIDGenerator.h>
 #include "mitkDataNode.h"
 #include "mitkDataStorage.h"
 #include "mitkModelFitInfo.h"
 #include "mitkScalarListLookupTableProperty.h"
 #include "mitkModelFitException.h"
 
 void mitk::modelFit::ModelFitInfo::AddParameter(Parameter::Pointer p)
 {
   if (p.IsNull())
   {
     mitkThrow() << "Given parameter must not be NULL";
   }
 
   if (GetParameter(p->name, p->type).IsNull())
   {
     MITK_DEBUG << "Adding parameter '" << p->name << "with type " << p->type
                << "' to modelFit '" << uid << "'.";
 
     LockType lock(mutex);
     parameterList.push_back(p);
   }
   else
   {
     MITK_DEBUG << "Parameter '" << p->name << "' of modelFit '" << uid
                << "' already exists. Aborting.";
   }
 }
 
 mitk::modelFit::Parameter::ConstPointer
 mitk::modelFit::ModelFitInfo::GetParameter(const std::string& name,
     const Parameter::Type& type) const
 {
   for (ConstIterType iter = parameterList.begin(); iter != parameterList.end(); ++iter)
   {
     Parameter::ConstPointer p = static_cast<Parameter::ConstPointer>(*iter);
 
     if (p->name == name && p->type == type)
     {
       return p;
     }
   }
 
-  return NULL;
+  return nullptr;
 }
 
 
 const mitk::modelFit::ModelFitInfo::ParamListType& mitk::modelFit::ModelFitInfo::GetParameters()
 const
 {
   return this->parameterList;
 };
 
 void mitk::modelFit::ModelFitInfo::DeleteParameter(const std::string& name,
     const Parameter::Type& type)
 {
   for (IterType iter = parameterList.begin(); iter != parameterList.end(); ++iter)
   {
     Parameter::ConstPointer p = static_cast<Parameter::ConstPointer>(*iter);
 
     if (p->name == name && p->type == type)
     {
       MITK_DEBUG << "Deleting parameter '" << name << " with type " << type
                  << "' from modelFit '" << uid << "'.";
 
       LockType lock(mutex);
       parameterList.erase(iter);
       return;
     }
   }
 }
 
 
 const std::string mitk::modelFit::GetMandatoryProperty(const mitk::DataNode* node,
     const std::string& prop)
 {
   std::string result;
 
   if (!node || !node->GetData() ||
       !node->GetData()->GetPropertyList()->GetStringProperty(prop.c_str(), result) || result.empty())
   {
     mitkThrowException(mitk::modelFit::ModelFitException) << "Node " << node->GetName()
         << " is lacking the required "
         << "property '" << prop
         << "' or contains an empty string.";
   }
 
   return result;
 }
 
 const std::string mitk::modelFit::GetMandatoryProperty(const mitk::BaseData* data,
   const std::string& prop)
 {
   std::string result;
 
   if (!data || !data->GetPropertyList()->GetStringProperty(prop.c_str(), result) || result.empty())
   {
     mitkThrowException(mitk::modelFit::ModelFitException) << "Data is lacking the required "
       << "property '" << prop
       << "' or contains an empty string.";
   }
 
   return result;
 }
 
 mitk::modelFit::ModelFitInfo::Pointer
 mitk::modelFit::CreateFitInfoFromNode(const ModelFitInfo::UIDType& uid,
                                       const mitk::DataStorage* storage)
 {
   if (!storage)
   {
-    return NULL;
+    return nullptr;
   }
 
   mitk::DataStorage::SetOfObjects::ConstPointer nodes = GetNodesOfFit(uid, storage);
 
   if (nodes.IsNull() || nodes->empty())
   {
-    return NULL;
+    return nullptr;
   }
 
   mitk::DataNode::ConstPointer node = nodes->GetElement(
                                         0).GetPointer(); //take one of the nodes as template
 
   if (!node->GetData())
   {
-    return NULL;
+    return nullptr;
   }
 
   ModelFitInfo::Pointer fit = ModelFitInfo::New();
   fit->uid = uid;
 
   // Mandatory properties
   try
   {
     fit->fitType = GetMandatoryProperty(node, mitk::ModelFitConstants::FIT_TYPE_PROPERTY_NAME());
     fit->modelType = GetMandatoryProperty(node, mitk::ModelFitConstants::MODEL_TYPE_PROPERTY_NAME());
     fit->modelName = GetMandatoryProperty(node, mitk::ModelFitConstants::MODEL_NAME_PROPERTY_NAME());
   }
   catch (const ModelFitException& e)
   {
     MITK_ERROR << e.what();
-    return NULL;
+    return nullptr;
   }
 
   // Either a function string or a function class must exist
   if (!node->GetData()->GetPropertyList()->GetStringProperty(mitk::ModelFitConstants::MODEL_FUNCTION_PROPERTY_NAME().c_str(),
                                fit->function))
   {
     fit->function = "";
   }
 
   try
   {
     fit->functionClassID =
       GetMandatoryProperty(node, mitk::ModelFitConstants::MODEL_FUNCTION_CLASS_PROPERTY_NAME());
   }
   catch (const ModelFitException&)
   {
     if (fit->function.empty())
     {
       MITK_ERROR << "The properties '"
                  << mitk::ModelFitConstants::MODEL_FUNCTION_PROPERTY_NAME()
                  << "'and '" << mitk::ModelFitConstants::MODEL_FUNCTION_CLASS_PROPERTY_NAME()
                  << "' are both empty or missing. One of these is required.";
-      return NULL;
+      return nullptr;
     }
   }
 
   node->GetData()->GetPropertyList()->GetStringProperty(mitk::ModelFitConstants::FIT_NAME_PROPERTY_NAME().c_str(), fit->fitName);
   node->GetData()->GetPropertyList()->GetStringProperty(mitk::ModelFitConstants::MODEL_X_PROPERTY_NAME().c_str(), fit->x);
   node->GetData()->GetPropertyList()->GetStringProperty(mitk::ModelFitConstants::XAXIS_NAME_PROPERTY_NAME().c_str(), fit->xAxisName);
   node->GetData()->GetPropertyList()->GetStringProperty(mitk::ModelFitConstants::XAXIS_UNIT_PROPERTY_NAME().c_str(), fit->xAxisUnit);
   node->GetData()->GetPropertyList()->GetStringProperty(mitk::ModelFitConstants::YAXIS_NAME_PROPERTY_NAME().c_str(), fit->yAxisName);
   node->GetData()->GetPropertyList()->GetStringProperty(mitk::ModelFitConstants::YAXIS_UNIT_PROPERTY_NAME().c_str(), fit->yAxisUnit);
 
   // Parameter
   for (DataStorage::SetOfObjects::ConstIterator pos = nodes->Begin(); pos != nodes->End(); ++pos)
   {
     modelFit::Parameter::Pointer param = ExtractParameterFromData(pos->Value()->GetData());
 
     if (param.IsNotNull())
     {
       fit->AddParameter(param);
     }
   }
 
   // Static parameters
   mitk::ScalarListLookupTableProperty::ConstPointer varProp = dynamic_cast<const mitk::ScalarListLookupTableProperty*>(node->GetData()->GetProperty(mitk::ModelFitConstants::FIT_STATIC_PARAMETERS_PROPERTY_NAME().c_str()).GetPointer());
 
   if (varProp.IsNotNull())
   {
     const mitk::ScalarListLookupTable lut = varProp->GetValue();
     const mitk::ScalarListLookupTable::LookupTableType& varMap = lut.GetLookupTable();
 
     for (mitk::ScalarListLookupTable::LookupTableType::const_iterator mapIter =
            varMap.begin(); mapIter != varMap.end(); ++mapIter)
     {
       fit->staticParamMap.Add(mapIter->first, mapIter->second);
     }
   }
 
   //fit input and ROI
   try
   {
     fit->inputUID = GetMandatoryProperty(node,
                                          mitk::ModelFitConstants::FIT_INPUT_IMAGEUID_PROPERTY_NAME());
   }
   catch (const ModelFitException& e)
   {
     MITK_ERROR << e.what();
-    return NULL;
+    return nullptr;
   }
 
   if (storage)
   {
     mitk::DataNode::Pointer inputNode = GetNodeByModelFitUID(storage, fit->inputUID);
 
     if (inputNode.IsNull())
     {
       MITK_ERROR << "Cannot create valid model fit info. input node cannot be found.";
-      return NULL;
+      return nullptr;
     }
 
     mitk::Image::Pointer inputImage = dynamic_cast<mitk::Image*>(inputNode->GetData());
 
     if (inputImage.IsNull())
     {
       MITK_ERROR << "Cannot create valid model fit info. input node does not contain an image.";
-      return NULL;
+      return nullptr;
     }
 
     fit->inputImage = inputImage;
   }
 
   node->GetData()->GetPropertyList()->GetStringProperty(mitk::ModelFitConstants::FIT_INPUT_ROIUID_PROPERTY_NAME().c_str(),
                           fit->roiUID);
 
   mitk::ScalarListLookupTableProperty::ConstPointer inputDataProp = dynamic_cast<const mitk::ScalarListLookupTableProperty*>(node->GetData()->GetProperty(mitk::ModelFitConstants::FIT_INPUT_DATA_PROPERTY_NAME().c_str()).GetPointer());
   if (inputDataProp.IsNotNull())
   {
     fit->inputData = inputDataProp->GetValue();
   }
 
   return fit;
 }
 
 mitk::modelFit::ModelFitInfo::Pointer
 mitk::modelFit::CreateFitInfoFromModelParameterizer(const ModelParameterizerBase* usedParameterizer,
 mitk::BaseData* inputImage, const std::string& fitType, const std::string& fitName,
     const NodeUIDType roiUID)
 {
   if (!usedParameterizer)
   {
-    return NULL;
+    return nullptr;
   }
 
   UIDGenerator generator("FitUID_");
   std::string uid = generator.GetUID();
 
   ModelFitInfo::Pointer fit = ModelFitInfo::New();
   fit->uid = uid;
   fit->fitType = fitType;
   fit->fitName = fitName;
   fit->inputImage = dynamic_cast<Image*>(inputImage);
   fit->inputUID = EnsureModelFitUID(inputImage);
 
   if (fit->inputImage.IsNull())
   {
     mitkThrow() << "Cannot generate model fit info. Input node does not contain an image.";
   }
 
   fit->modelType = usedParameterizer->GetModelType();
   fit->modelName = usedParameterizer->GetModelDisplayName();
 
   fit->function = usedParameterizer->GetFunctionString();
   fit->x = usedParameterizer->GetXName();
   fit->functionClassID = usedParameterizer->GetClassID();
 
   fit->xAxisName = usedParameterizer->GetXAxisName();
   fit->xAxisUnit = usedParameterizer->GetXAxisUnit();
   fit->yAxisName = usedParameterizer->GetYAxisName();
   fit->yAxisUnit = usedParameterizer->GetYAxisUnit();
 
   // Parameter
   ModelTraitsInterface::ParameterNamesType paramNames = usedParameterizer->GetParameterNames();
   ModelTraitsInterface::ParamterScaleMapType paramScales = usedParameterizer->GetParameterScales();
   ModelTraitsInterface::ParamterUnitMapType paramUnits = usedParameterizer->GetParameterUnits();
 
   for (ModelTraitsInterface::ParameterNamesType::iterator pos = paramNames.begin();
        pos != paramNames.end(); ++pos)
   {
     modelFit::Parameter::Pointer param = modelFit::Parameter::New();
     param->name = *pos;
     param->type = Parameter::ParameterType;
 
     if (paramScales.find(*pos) == paramScales.end())
     {
       mitkThrow() <<
                   "Cannot generate model fit info. Model traits invalid (scales do not include parameter). Parameter name: "
                   << *pos;
     }
 
     if (paramUnits.find(*pos) == paramUnits.end())
     {
       mitkThrow() <<
                   "Cannot generate model fit info. Model traits invalid (units do not include parameter). Parameter name: "
                   << *pos;
     }
 
     param->scale = paramScales[*pos];
     param->unit = paramUnits[*pos];
     fit->AddParameter(param);
   }
 
   //derived parameter
   ModelTraitsInterface::DerivedParameterNamesType derivedNames =
     usedParameterizer->GetDerivedParameterNames();
   ModelTraitsInterface::DerivedParamterScaleMapType derivedScales =
     usedParameterizer->GetDerivedParameterScales();
   ModelTraitsInterface::DerivedParamterUnitMapType derivedUnits =
     usedParameterizer->GetDerivedParameterUnits();
 
   for (ModelTraitsInterface::ParameterNamesType::iterator pos = derivedNames.begin();
        pos != derivedNames.end(); ++pos)
   {
     modelFit::Parameter::Pointer param = modelFit::Parameter::New();
     param->name = *pos;
     param->type = Parameter::DerivedType;
 
     if (derivedScales.find(*pos) == derivedScales.end())
     {
       mitkThrow() <<
                   "Cannot generate model fit info. Model traits invalid (scales do not include parameter). Parameter name: "
                   << *pos;
     }
 
     if (derivedUnits.find(*pos) == derivedUnits.end())
     {
       mitkThrow() <<
                   "Cannot generate model fit info. Model traits invalid (units do not include parameter). Parameter name: "
                   << *pos;
     }
 
     param->scale = derivedScales[*pos];
     param->unit = derivedUnits[*pos];
     fit->AddParameter(param);
   }
 
   // Static parameters (but transfer only the global ones)
   ModelParameterizerBase::StaticParameterMapType staticParamMap =
     usedParameterizer->GetGlobalStaticParameters();
 
   for (ModelParameterizerBase::StaticParameterMapType::const_iterator pos = staticParamMap.begin();
        pos != staticParamMap.end(); ++pos)
   {
     fit->staticParamMap.Add(pos->first, pos->second);
   }
 
 
   fit->roiUID = roiUID;
 
   return fit;
 }
 
 mitk::modelFit::ModelFitInfo::Pointer
 mitk::modelFit::CreateFitInfoFromModelParameterizer(const ModelParameterizerBase* usedParameterizer,
 mitk::BaseData* inputImage, const std::string& fitType, const ScalarListLookupTable& inputData,
 const std::string& fitName, const NodeUIDType roiUID)
 {
   mitk::modelFit::ModelFitInfo::Pointer info = CreateFitInfoFromModelParameterizer(usedParameterizer,
     inputImage, fitType, fitName, roiUID);
 
   info->inputData = inputData;
 
   return info;
 }
 
 mitk::DataStorage::SetOfObjects::ConstPointer
 mitk::modelFit::GetNodesOfFit(const ModelFitInfo::UIDType& fitUID, const mitk::DataStorage* storage)
 {
   if (!storage)
   {
-    return NULL;
+    return nullptr;
   }
 
   mitk::NodePredicateDataProperty::Pointer predicate = mitk::NodePredicateDataProperty::New(
         mitk::ModelFitConstants::FIT_UID_PROPERTY_NAME().c_str(), mitk::StringProperty::New(fitUID));
   return storage->GetSubset(predicate);
 };
 
 
 mitk::modelFit::NodeUIDSetType
 mitk::modelFit::GetFitUIDsOfNode(const mitk::DataNode* node,	const mitk::DataStorage* storage)
 {
   mitk::modelFit::NodeUIDSetType result;
 
   if (node && storage)
   {
     mitk::NodePredicateDataProperty::Pointer predicate = mitk::NodePredicateDataProperty::New(
           mitk::ModelFitConstants::FIT_UID_PROPERTY_NAME().c_str());
     mitk::DataStorage::SetOfObjects::ConstPointer nodes = storage->GetDerivations(node, predicate,
         false);
 
     for (mitk::DataStorage::SetOfObjects::ConstIterator pos = nodes->Begin(); pos != nodes->End();
          ++pos)
     {
       mitk::modelFit::ModelFitInfo::UIDType uid;
       pos->Value()->GetData()->GetPropertyList()->GetStringProperty(mitk::ModelFitConstants::FIT_UID_PROPERTY_NAME().c_str(), uid);
       result.insert(uid);
     }
 
   }
 
   return result;
 };
diff --git a/Modules/ModelFit/src/Common/mitkModelFitParameter.cpp b/Modules/ModelFit/src/Common/mitkModelFitParameter.cpp
index 388fa5bafc..c9abd9258e 100644
--- a/Modules/ModelFit/src/Common/mitkModelFitParameter.cpp
+++ b/Modules/ModelFit/src/Common/mitkModelFitParameter.cpp
@@ -1,74 +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 "mitkModelFitParameter.h"
 #include "mitkModelFitConstants.h"
 
 mitk::modelFit::Parameter::Parameter() :
   name (""), type(Parameter::ParameterType), unit(""), scale(1.0f)
 {
 }
 
 mitk::modelFit::Parameter::Pointer mitk::modelFit::ExtractParameterFromData(const mitk::BaseData* data)
 {
   if (!data)
   {
-    return NULL;
+    return nullptr;
   }
 
   mitk::modelFit::Parameter::Pointer param = mitk::modelFit::Parameter::New();
 
   if (!data->GetPropertyList()->GetStringProperty(mitk::ModelFitConstants::PARAMETER_NAME_PROPERTY_NAME().c_str(), param->name))
   {
-    return NULL;
+    return nullptr;
   };
 
   param->image = dynamic_cast<const mitk::Image*>(data);
 
   if(!(param->image))
   {
-    return NULL;
+    return nullptr;
   }
 
   std::string typeString;
   data->GetPropertyList()->GetStringProperty(mitk::ModelFitConstants::PARAMETER_TYPE_PROPERTY_NAME().c_str(), typeString);
 
   if(typeString == mitk::ModelFitConstants::PARAMETER_TYPE_VALUE_DERIVED_PARAMETER())
   {
     param->type = Parameter::DerivedType;
   }
   else if(typeString == mitk::ModelFitConstants::PARAMETER_TYPE_VALUE_CRITERION())
   {
     param->type = Parameter::CriterionType;
   }
   else if(typeString == mitk::ModelFitConstants::PARAMETER_TYPE_VALUE_EVALUATION_PARAMETER())
   {
     param->type = Parameter::EvaluationType;
   }
   else
   {
     param->type = Parameter::ParameterType;
   }
 
   data->GetPropertyList()->GetStringProperty(mitk::ModelFitConstants::PARAMETER_UNIT_PROPERTY_NAME().c_str(),
     param->unit);
   data->GetPropertyList()->GetFloatProperty(mitk::ModelFitConstants::PARAMETER_SCALE_PROPERTY_NAME().c_str(),
     param->scale);
 
   return param;
 }
 
diff --git a/Modules/ModelFit/src/Common/mitkModelSignalImageGenerator.cpp b/Modules/ModelFit/src/Common/mitkModelSignalImageGenerator.cpp
index c7e0b015b6..bc5084cf05 100644
--- a/Modules/ModelFit/src/Common/mitkModelSignalImageGenerator.cpp
+++ b/Modules/ModelFit/src/Common/mitkModelSignalImageGenerator.cpp
@@ -1,188 +1,188 @@
 #include "mitkModelSignalImageGenerator.h"
 #include "itkMultiOutputNaryFunctorImageFilter.h"
 #include "mitkArbitraryTimeGeometry.h"
 #include "mitkImageCast.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkITKImageImport.h"
 #include "mitkModelDataGenerationFunctor.h"
 #include "mitkSimpleFunctorPolicy.h"
 
 
 void mitk::ModelSignalImageGenerator::SetParameterInputImage(const ParametersIndexType parameterIndex, ParameterImageType parameterImage)
 {
     m_ParameterInputMap.insert(std::make_pair(parameterIndex,parameterImage));
 
 }
 
 mitk::ModelSignalImageGenerator::ResultImageType mitk::ModelSignalImageGenerator::GetGeneratedImage()
 {
     Generate();
     return m_ResultImage;
 }
 
 template <typename TPixel, unsigned int VDim>
 void
   mitk::ModelSignalImageGenerator::DoPrepareMask(itk::Image<TPixel, VDim>* image)
 {
   m_InternalMask = dynamic_cast<InternalMaskType*>(image);
 
   if (m_InternalMask.IsNull())
   {
     MITK_INFO << "Parameter Fit Generator. Need to cast mask for parameter fit.";
     typedef itk::Image<TPixel, VDim> InputImageType;
     typedef itk::CastImageFilter< InputImageType, InternalMaskType > CastFilterType;
     typename CastFilterType::Pointer  spImageCaster =  CastFilterType::New();
 
     spImageCaster->SetInput(image);
 
     m_InternalMask = spImageCaster->GetOutput();
     spImageCaster->Update();
   }
 }
 
 void mitk::ModelSignalImageGenerator::SortParameterImages()
 {
     ParameterVectorType inputImages(this->m_ParameterInputMap.size());
 
     unsigned int i = 0;
     for (ParameterMapType::const_iterator pos = m_ParameterInputMap.begin(); pos != m_ParameterInputMap.end(); ++pos)
     {
 
       i = pos->first;
       inputImages[i] = pos->second;
     }
 
     this->m_InputParameterImages = inputImages;
 
 
 }
 
 void mitk::ModelSignalImageGenerator::Generate()
 {
      SortParameterImages();
 
     if(this->m_Mask.IsNotNull())
     {
       AccessFixedDimensionByItk(m_Mask, mitk::ModelSignalImageGenerator::DoPrepareMask, 3);
     }
     else
     {
-      this->m_InternalMask = NULL;
+      this->m_InternalMask = nullptr;
     }
 
     /** @todo #1 This did not work! The Access-Routine would be a much nicer solution, but for some reasons, the handling did not work.
      * Thats why the code for Generation the Data was pasted below
      */
 //    mitk::Image::Pointer firstParameterImage = this->m_InputParameterImages[0];
 //    AccessFixedDimensionByItk(firstParameterImage, mitk::ModelSignalImageGenerator::DoGenerateData, 3);
 
 
     typedef itk::Image<double, 3> InputFrameImageType;
     typedef itk::Image<double, 3> OutputImageType;
 
     typedef itk::MultiOutputNaryFunctorImageFilter<InputFrameImageType, OutputImageType, SimpleFunctorPolicy, InternalMaskType> FilterType;
      FilterType::Pointer filter = FilterType::New();
 
     for(unsigned int i=0; i<this->m_ParameterInputMap.size(); ++i)
     {
         InputFrameImageType::Pointer frameImage = InputFrameImageType::New();
         Image::Pointer parameterImage = m_InputParameterImages.at(i);
 
         mitk::CastToItkImage(parameterImage, frameImage);
         filter->SetInput(i,frameImage);
     }
 
     ModelDataGenerationFunctor::Pointer generationFunctor = ModelDataGenerationFunctor::New();
     generationFunctor->SetModelParameterizer(m_Parameterizer);
 
     SimpleFunctorPolicy functor;
     functor.SetFunctor(generationFunctor);
     filter->SetFunctor(functor);
     if (this->m_InternalMask.IsNotNull())
     {
      filter->SetMask(this->m_InternalMask);
     }
     filter->Update();
 
     if (filter->GetNumberOfOutputs() != generationFunctor->GetGrid().GetSize())
     {
       itkExceptionMacro("Error. Number of computed output Images does not match Grid size!");
     }
 
     /** @todo #1 Better solution than all this code!
      * This was copied from TestingHelper/TestArtifactGenerator. Just instantiating a mitk::Image and setting its Volumes
      * in the for-loop did not work somehow.
      * This was a work around
      */
 
     typedef itk::Image<double,4> DynamicITKImageType;
 
     Image::Pointer dynamicImage= Image::New();
     mitk::Image::Pointer tempImage = mitk::ImportItkImage(filter->GetOutput(0))->Clone();
 
     DynamicITKImageType::Pointer dynamicITKImage = DynamicITKImageType::New();
     DynamicITKImageType::RegionType dynamicITKRegion;
     DynamicITKImageType::PointType dynamicITKOrigin;
     DynamicITKImageType::IndexType dynamicITKIndex;
     DynamicITKImageType::SpacingType dynamicITKSpacing;
 
     dynamicITKSpacing[0] = tempImage->GetGeometry()->GetSpacing()[0];
     dynamicITKSpacing[1] = tempImage->GetGeometry()->GetSpacing()[1];
     dynamicITKSpacing[2] = tempImage->GetGeometry()->GetSpacing()[2];
     dynamicITKSpacing[3] = 3.0;
 
     dynamicITKIndex[0] = 0;  // The first pixel of the REGION
     dynamicITKIndex[1] = 0;
     dynamicITKIndex[2] = 0;
     dynamicITKIndex[3] = 0;
 
     dynamicITKRegion.SetSize( 0,tempImage->GetDimension(0));
     dynamicITKRegion.SetSize( 1,tempImage->GetDimension(1));
     dynamicITKRegion.SetSize( 2,tempImage->GetDimension(2));
     dynamicITKRegion.SetSize(3, filter->GetNumberOfOutputs());
 
     dynamicITKRegion.SetIndex( dynamicITKIndex );
 
     dynamicITKOrigin[0]=tempImage->GetGeometry()->GetOrigin()[0];
     dynamicITKOrigin[1]=tempImage->GetGeometry()->GetOrigin()[1];
     dynamicITKOrigin[2]=tempImage->GetGeometry()->GetOrigin()[2];
 
     dynamicITKImage->SetOrigin(dynamicITKOrigin);
     dynamicITKImage->SetSpacing(dynamicITKSpacing);
     dynamicITKImage->SetRegions( dynamicITKRegion);
     dynamicITKImage->Allocate();
     dynamicITKImage->FillBuffer(0); //not sure if this is necessary
 
     // Convert
     mitk::CastToMitkImage(dynamicITKImage, dynamicImage);
 
 
 
     ArbitraryTimeGeometry::Pointer timeGeometry = ArbitraryTimeGeometry::New();
     timeGeometry->ClearAllGeometries();
 
     auto nrOfOutputs = filter->GetNumberOfOutputs();
     auto grid = generationFunctor->GetGrid();
     for (unsigned int i = 0; i<nrOfOutputs; ++i)
     {
       mitk::Image::Pointer frame = mitk::ImportItkImage(filter->GetOutput(i))->Clone();
       mitk::ImageReadAccessor accessor(frame);
       dynamicImage->SetVolume(accessor.GetData(), i);
 
       double tmax = 0;
       if (i<(nrOfOutputs - 1))
       {
         tmax = grid[i + 1] * 1000;
       }
       else
       {
         tmax = grid[i] * 1000;
       }
       timeGeometry->AppendNewTimeStepClone(frame->GetGeometry(), grid[i] * 1000, tmax);
      }
 
     dynamicImage->SetTimeGeometry(timeGeometry);
 
     this->m_ResultImage = dynamicImage->Clone();
 
 }
diff --git a/Modules/ModelFit/src/Common/mitkScalarListLookupTablePropertySerializer.cpp b/Modules/ModelFit/src/Common/mitkScalarListLookupTablePropertySerializer.cpp
index f7ffa847b5..551321035b 100644
--- a/Modules/ModelFit/src/Common/mitkScalarListLookupTablePropertySerializer.cpp
+++ b/Modules/ModelFit/src/Common/mitkScalarListLookupTablePropertySerializer.cpp
@@ -1,131 +1,131 @@
 /*===================================================================
 
 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 "mitkScalarListLookupTableProperty.h"
 #include "mitkScalarListLookupTablePropertySerializer.h"
 
 
 TiXmlElement* mitk::ScalarListLookupTablePropertySerializer::Serialize()
 {
 	const ScalarListLookupTableProperty* prop =
 		dynamic_cast<const ScalarListLookupTableProperty*>(m_Property.GetPointer());
 
-	if (prop == NULL)
+	if (prop == nullptr)
 	{
 		MITK_ERROR << "Serialization: Property is NULL";
-		return NULL;
+		return nullptr;
 	}
 
 	ScalarListLookupTable lut = prop->GetValue();
 	const ScalarListLookupTable::LookupTableType& map = lut.GetLookupTable();
 
 	TiXmlElement* mapElement = new TiXmlElement("ScalarListLookupTable");
 
 	for (ScalarListLookupTable::LookupTableType::const_iterator mapIter = map.begin();
 		 mapIter != map.end(); ++mapIter)
 	{
 		const ScalarListLookupTable::ValueType& list = mapIter->second;
 		TiXmlElement* listElement = new TiXmlElement("List");
 		listElement->SetAttribute("name", mapIter->first);
 
 		for (ScalarListLookupTable::ValueType::const_iterator listIter =  list.begin();
 			 listIter != list.end(); ++listIter)
 		{
 			TiXmlElement* valueElement = new TiXmlElement("Element");
 			valueElement->SetDoubleAttribute("value", *listIter);
 			listElement->LinkEndChild(valueElement);
 		}
 
 		mapElement->LinkEndChild(listElement);
 	}
 
 	return mapElement;
 }
 
 mitk::BaseProperty::Pointer
 mitk::ScalarListLookupTablePropertySerializer::Deserialize(TiXmlElement* element)
 {
 	if (!element)
 	{
 		MITK_ERROR << "Deserialization: Element is NULL";
-		return NULL;
+		return nullptr;
 	}
 
 	ScalarListLookupTable lut;
 
 	for (TiXmlElement* listElement = element->FirstChildElement("List");
-		 listElement != NULL; listElement = listElement->NextSiblingElement("List"))
+		 listElement != nullptr; listElement = listElement->NextSiblingElement("List"))
 	{
 		std::string name;
 
-		if (listElement->Attribute("name") != NULL)
+		if (listElement->Attribute("name") != nullptr)
 		{
 			name = listElement->Attribute("name");
 		}
 		else
 		{
 			MITK_ERROR << "Deserialization: No element with attribute 'name' found";
-			return NULL;
+			return nullptr;
 		}
 
 		ScalarListLookupTable::ValueType list;
 
 		for (TiXmlElement* valueElement = listElement->FirstChildElement("Element");
-			 valueElement != NULL;
+			 valueElement != nullptr;
 			 valueElement = valueElement->NextSiblingElement("Element"))
 		{
 			double value;
 
 			if (valueElement->QueryDoubleAttribute("value", &value) == TIXML_WRONG_TYPE)
 			{
 				MITK_ERROR << "Deserialization: No element with attribute 'value' found";
-				return NULL;
+				return nullptr;
 			}
 
 			list.push_back(value);
 		}
 
 		lut.SetTableValue(name, list);
 	}
 
 	return ScalarListLookupTableProperty::New(lut).GetPointer();
 }
 
 MITK_REGISTER_SERIALIZER(ScalarListLookupTablePropertySerializer);
 
 ::std::string mitk::PropertyPersistenceSerialization::serializeScalarListLookupTablePropertyToXML(
   const mitk::BaseProperty *prop)
 {
   mitk::ScalarListLookupTablePropertySerializer::Pointer lutSerializer = mitk::ScalarListLookupTablePropertySerializer::New();
 
   lutSerializer->SetProperty(prop);
   auto xmlLut = lutSerializer->Serialize();
 
   TiXmlPrinter printer;
   xmlLut->Accept(&printer);
   printer.SetStreamPrinting();
   return printer.Str();
 }
 
 mitk::BaseProperty::Pointer mitk::PropertyPersistenceDeserialization::deserializeXMLToScalarListLookupTableProperty(
   const std::string &value)
 {
   mitk::ScalarListLookupTablePropertySerializer::Pointer lutSerializer = mitk::ScalarListLookupTablePropertySerializer::New();
 
   TiXmlDocument doc;
   doc.Parse(value.c_str());
   return lutSerializer->Deserialize(doc.RootElement());
 }
diff --git a/Modules/ModelFit/src/Functors/mitkModelFitFunctorBase.cpp b/Modules/ModelFit/src/Functors/mitkModelFitFunctorBase.cpp
index 2af5a1dccc..e171e04ae2 100644
--- a/Modules/ModelFit/src/Functors/mitkModelFitFunctorBase.cpp
+++ b/Modules/ModelFit/src/Functors/mitkModelFitFunctorBase.cpp
@@ -1,245 +1,245 @@
 /*===================================================================
 
 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 "mitkModelFitFunctorBase.h"
 
 mitk::ModelFitFunctorBase::OutputPixelArrayType
 mitk::ModelFitFunctorBase::
 Compute(const InputPixelArrayType& value, const ModelBase* model,
         const ModelBase::ParametersType& initialParameters) const
 {
   if (!model)
   {
     itkExceptionMacro("Cannot compute fit. Passed model is not defined.");
   }
 
   if (model->GetNumberOfParameters() != initialParameters.Size())
   {
     itkExceptionMacro("Cannot compute fit. Parameter count of passed model and passed initial parameters differ. Model parameter count: "
                       << model->GetNumberOfParameters() << "; Initial parameters: " << initialParameters);
   }
 
   SignalType sample(value.size());
 
   for (SignalType::SizeValueType i = 0; i < sample.Size(); ++i)
   {
     sample[i] = value [i];
   }
 
   DebugParameterMapType debugParams;
   ParameterNamesType debugNames;
   if (this->m_DebugParameterMaps)
   {
     debugNames = this->GetDebugParameterNames();
   }
 
   ParametersType fittedParameters = DoModelFit(sample, model, initialParameters, debugParams);
 
   OutputPixelArrayType derivedParameters = this->GetDerivedParameters(model, fittedParameters);
 
   OutputPixelArrayType criteria = this->GetCriteria(model, fittedParameters, sample);
 
   OutputPixelArrayType evaluationParameters = this->GetEvaluationParameters(model, fittedParameters,
       sample);
 
   if (criteria.size() != this->GetCriterionNames().size())
   {
     itkExceptionMacro("ModelFitInfo implementation seems to be inconsitent. Number of criterion values is not equal to number of criterion names.");
   }
 
   OutputPixelArrayType result(fittedParameters.Size() + derivedParameters.size() + criteria.size() +
                               evaluationParameters.size() + debugNames.size());
 
   for (ParametersType::SizeValueType i = 0; i < fittedParameters.Size(); ++i)
   {
     result[i] = fittedParameters[i];
   }
 
   OutputPixelArrayType::size_type offset = fittedParameters.Size();
 
   for (OutputPixelArrayType::size_type j = 0; j < derivedParameters.size(); ++j)
   {
     result[offset + j] = derivedParameters[j];
   }
 
   offset += derivedParameters.size();
   for (OutputPixelArrayType::size_type j = 0; j < criteria.size(); ++j)
   {
     result[offset + j] = criteria[j];
   }
 
   offset += criteria.size();
   for (OutputPixelArrayType::size_type j = 0; j < evaluationParameters.size(); ++j)
   {
     result[offset + j] = evaluationParameters[j];
   }
 
   offset += evaluationParameters.size();
   for (OutputPixelArrayType::size_type j = 0; j < debugNames.size(); ++j)
   {
     DebugParameterMapType::const_iterator pos = debugParams.find(debugNames[j]);
     if (pos == debugParams.end())
     {
       itkExceptionMacro("ModelFitInfo implementation seems to be inconsitent. Debug parameter defined by functor is not in its returned debug map. Invalid debug parameter name: "<<debugNames[j]);
     }
     else
     {
       result[offset + j] = pos->second;
     }
   }
 
   return result;
 };
 
 unsigned int
 mitk::ModelFitFunctorBase::GetNumberOfOutputs(const ModelBase* model) const
 {
   if (!model)
   {
     itkExceptionMacro("Cannot get number of outputs. Model is not defined.");
   }
 
   return model->GetNumberOfParameters() + model->GetNumberOfDerivedParameters() +
          this->GetCriterionNames().size() + m_CostFunctionMap.size()+ this->GetDebugParameterNames().size();
 };
 
 void
 mitk::ModelFitFunctorBase::ResetEvaluationParameters()
 {
   m_Mutex.Lock();
 
   m_CostFunctionMap.clear();
 
   m_Mutex.Unlock();
 };
 
 void
 mitk::ModelFitFunctorBase::RegisterEvaluationParameter(const std::string& parameterName,
     SVModelFitCostFunction* evaluationCostFunction)
 {
   m_Mutex.Lock();
 
   SVModelFitCostFunction::Pointer costFunctPtr = evaluationCostFunction;
 
   m_CostFunctionMap.insert(std::make_pair(parameterName, costFunctPtr));
 
   m_Mutex.Unlock();
 };
 
 mitk::ModelFitFunctorBase::ParameterNamesType
 mitk::ModelFitFunctorBase::GetEvaluationParameterNames() const
 {
   m_Mutex.Lock();
 
   ParameterNamesType result;
 
   for (CostFunctionMapType::const_iterator pos = m_CostFunctionMap.begin();
        pos != m_CostFunctionMap.end(); ++pos)
   {
     result.push_back(pos->first);
   }
 
   m_Mutex.Unlock();
 
   return result;
 };
 
 const mitk::SVModelFitCostFunction*
 mitk::ModelFitFunctorBase::GetEvaluationParameterCostFunction(const std::string& parameterName)
 const
 {
-  const SVModelFitCostFunction* result = NULL;
+  const SVModelFitCostFunction* result = nullptr;
 
   m_Mutex.Lock();
 
   CostFunctionMapType::const_iterator pos = m_CostFunctionMap.find(parameterName);
 
   if (pos != m_CostFunctionMap.end())
   {
     result = (pos->second).GetPointer();
   }
 
   m_Mutex.Unlock();
 
   return result;
 };
 
 mitk::ModelFitFunctorBase::ParameterNamesType
 mitk::ModelFitFunctorBase::GetDebugParameterNames() const
 {
   ParameterNamesType result;
 
   if (this->m_DebugParameterMaps)
   {
     result = this->DefineDebugParameterNames();
   }
 
   return result;
 };
 
 mitk::ModelFitFunctorBase::
 ModelFitFunctorBase() : m_DebugParameterMaps(false)
 {};
 
 mitk::ModelFitFunctorBase::
 ~ModelFitFunctorBase() {};
 
 mitk::ModelFitFunctorBase::OutputPixelArrayType
 mitk::ModelFitFunctorBase::GetDerivedParameters(const ModelBase* model,
     const ParametersType& parameters) const
 {
   ModelBase::DerivedParameterMapType derivedParameterMap = model->GetDerivedParameters(parameters);
   OutputPixelArrayType result(derivedParameterMap.size());
 
   unsigned int i = 0;
 
   for (ModelBase::DerivedParameterMapType::const_iterator pos = derivedParameterMap.begin();
        pos != derivedParameterMap.end(); ++pos, ++i)
   {
     result[i] = pos->second;
   }
 
   return result;
 };
 
 mitk::ModelFitFunctorBase::OutputPixelArrayType
 mitk::ModelFitFunctorBase::GetEvaluationParameters(const ModelBase* model,
     const ParametersType& parameters, const SignalType& sample) const
 {
   m_Mutex.Lock();
 
   OutputPixelArrayType result(m_CostFunctionMap.size());
 
   unsigned int i = 0;
 
   for (CostFunctionMapType::const_iterator pos = m_CostFunctionMap.begin();
        pos != m_CostFunctionMap.end(); ++pos, ++i)
   {
     //break constness to configure evaluation cost functions. This operatoin is guarded be the mutex
     //after costFct->GetValue() the cost function may change its state again and is irrelevant for the
     //current call of GetEvaluationParameters
     SVModelFitCostFunction* costFct = const_cast<SVModelFitCostFunction*>(pos->second.GetPointer());
 
     costFct->SetModel(model);
     costFct->SetSample(sample);
 
     result[i] = costFct->GetValue(parameters);
   }
 
   m_Mutex.Unlock();
 
   return result;
 };
diff --git a/Modules/ModelFit/test/mitkFormulaParserTest.cpp b/Modules/ModelFit/test/mitkFormulaParserTest.cpp
index 705cfc5ea2..1aedc45d95 100644
--- a/Modules/ModelFit/test/mitkFormulaParserTest.cpp
+++ b/Modules/ModelFit/test/mitkFormulaParserTest.cpp
@@ -1,229 +1,229 @@
 /*===================================================================
 
 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 "mitkTestingMacros.h"
 #include "mitkFormulaParser.h"
 
 using namespace mitk;
 
 #define TEST_NOTHROW(expression, MSG) \
     do \
     { \
         MITK_TEST_OUTPUT_NO_ENDL(<< MSG) \
         bool test_caught = false; \
         try \
         { \
             expression; \
         } \
         catch(...) \
         { \
             test_caught = true; \
             MITK_TEST_FAILED_MSG(<< "An unwanted exception was thrown"); \
         } \
         if(!test_caught) \
         { \
             MITK_TEST_OUTPUT(<< " [PASSED]") \
             mitk::TestManager::GetInstance()->TestPassed(); \
         } \
     } while(0)
 
 /*!
  *	@author Sascha Diatschuk
  */
 class FormulaParserTests
 {
 public:
   static void TestConstructor()
   {
     std::map<std::string, double> varMap;
-    FormulaParser *nullParser = NULL, *parser = NULL;
+    FormulaParser *nullParser = nullptr, *parser = nullptr;
 
-    TEST_NOTHROW(nullParser = new FormulaParser(NULL),
+    TEST_NOTHROW(nullParser = new FormulaParser(nullptr),
       "Testing constructor with NULL argument");
     TEST_NOTHROW(parser = new FormulaParser(&varMap),
       "Testing constructor with valid argument");
 
     delete nullParser;
     delete parser;
   }
 
   static void TestLookupVariable()
   {
     // variable map is NULL
-    FormulaParser *nullParser = new FormulaParser(NULL);
+    FormulaParser *nullParser = new FormulaParser(nullptr);
     MITK_TEST_FOR_EXCEPTION(FormulaParserException, nullParser->lookupVariable("test"));
     delete nullParser;
 
     // variable map is empty
     std::map<std::string, double> varMap;
     FormulaParser *parser = new FormulaParser(&varMap);
     MITK_TEST_FOR_EXCEPTION(FormulaParserException, parser->lookupVariable("test"));
 
     // lookup should succeed
     double var;
     varMap["test"] = 17;
     TEST_NOTHROW(var = parser->lookupVariable("test"),
       "Testing if lookupVariable throws unwanted exceptions");
     MITK_TEST_CONDITION_REQUIRED(var == 17,
       "Testing if lookupVariable returns the correct value");
 
     delete parser;
   }
 
   static void TestParse()
   {
     std::map<std::string, double> varMap;
     varMap["test"] = 17;
     FormulaParser *parser = new FormulaParser(&varMap);
 
     // empty string
     MITK_TEST_FOR_EXCEPTION(FormulaParserException, parser->parse(""));
 
     // grammar can't process string
     MITK_TEST_FOR_EXCEPTION(FormulaParserException, parser->parse("_"));
 
     // unexpected character
     MITK_TEST_FOR_EXCEPTION(FormulaParserException, parser->parse("5="));
 
     // unknown variable
     MITK_TEST_FOR_EXCEPTION(FormulaParserException, parser->parse("a"));
 
     double d;
 
     // addition
     TEST_NOTHROW(d = parser->parse("1+2"),
       "Testing if addition throws an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(d == 3,
       "Testing if addition produces the correct result");
 
     // subtraction
     TEST_NOTHROW(d = parser->parse("5-1"),
       "Testing if subtraction throws an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(d == 4,
       "Testing if subtraction produces the correct result");
 
     // multiplication
     TEST_NOTHROW(d = parser->parse("3*4"),
       "Testing if multiplication throws an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(d == 12,
       "Testing if multiplication produces the correct result");
 
     // division
     TEST_NOTHROW(d = parser->parse("28/4"),
       "Testing if division throws an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(d == 7,
       "Testing if division produces the correct result");
 
     /*!	@TODO:	Reactivate as soon as exponentiation works again */
     // exponentiation
     //TEST_NOTHROW(d = parser->parse("2^3"),
     //	"Testing if exponentiation throws an unwanted exception");
     //MITK_TEST_CONDITION_REQUIRED(d == 8,
     //	"Testing if exponentiation produces the correct result");
 
     // algebraic signs
     TEST_NOTHROW(d = parser->parse("-7 + +1 - -1"),
       "Testing if algebraic signs throw an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(d == -5,
       "Testing if algebraic signs produce the correct result");
 
     // parentheses
     TEST_NOTHROW(d = parser->parse("(1+2)*(4-2)"),
       "Testing if parentheses throw an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(d == 6,
       "Testing if parentheses produce the correct result");
 
     // variables
     TEST_NOTHROW(d = parser->parse("2*test-test"),
       "Testing if variables throw an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(d == 17,
       "Testing if variables produce the correct result");
 
     // abs
     TEST_NOTHROW(d = parser->parse("abs(-5)"),
       "Testing if abs throws an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(d == 5,
       "Testing if abs produces the correct result");
 
     const double eps = 0.0001;
 
     // exp
     TEST_NOTHROW(d = parser->parse("exp(1)"),
       "Testing if exp throws an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(std::abs(d - 2.71828182846) < eps,
       "Testing if exp produces the correct result");
 
     // sin
     TEST_NOTHROW(d = parser->parse("sin(1.57079632679)"),
       "Testing if sin throws an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(std::abs(d - 1) < eps,
       "Testing if sin produces the correct result");
 
     // cos
     TEST_NOTHROW(d = parser->parse("cos(3.14159265359)"),
       "Testing if cos throws an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(std::abs(d + 1) < eps,
       "Testing if cos produces the correct result");
 
     // tan
     TEST_NOTHROW(d = parser->parse("tan(0.46364760899)"),
       "Testing if tan throws an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(std::abs(d - 0.5) < eps,
       "Testing if tan produces the correct result");
 
     // sind
     TEST_NOTHROW(d = parser->parse("sind(145)"),
       "Testing if sind throws an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(std::abs(d - 0.57357643635) < eps,
       "Testing if sind produces the correct result");
 
     // cosd
     TEST_NOTHROW(d = parser->parse("cosd(90)"),
       "Testing if cosd throws an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(d < eps,
       "Testing if cosd produces the correct result");
 
     // tand
     TEST_NOTHROW(d = parser->parse("tand(15)"),
       "Testing if tand throws an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(std::abs(d - 0.26794919243) < eps,
       "Testing if tand produces the correct result");
 
     // fresnelS
     TEST_NOTHROW(d = parser->parse("fresnelS(1)"),
       "Testing if fresnelS throws an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(std::abs(d - 0.310268) < eps,
       "Testing if fresnelS produces the correct result");
 
     TEST_NOTHROW(d = parser->parse("fresnelC(1)"),
       "Testing if fresnelC throws an unwanted exception");
     MITK_TEST_CONDITION_REQUIRED(std::abs(d - 0.904524) < eps,
       "Testing if fresnelC produces the correct result");
 
     delete parser;
   }
 };
 
 int mitkFormulaParserTest(int, char *[])
 {
   MITK_TEST_BEGIN("FormulaParser Test");
 
   FormulaParserTests::TestConstructor();
   FormulaParserTests::TestLookupVariable();
   FormulaParserTests::TestParse();
 
   MITK_TEST_END();
 }
diff --git a/Modules/ModelFit/test/mitkLevenbergMarquardtModelFitFunctorTest.cpp b/Modules/ModelFit/test/mitkLevenbergMarquardtModelFitFunctorTest.cpp
index d1ec7a5eaf..e1cbdde196 100644
--- a/Modules/ModelFit/test/mitkLevenbergMarquardtModelFitFunctorTest.cpp
+++ b/Modules/ModelFit/test/mitkLevenbergMarquardtModelFitFunctorTest.cpp
@@ -1,89 +1,89 @@
 /*===================================================================
 
 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 <iostream>
 #include "mitkTestingMacros.h"
 
 #include "itkImage.h"
 #include "itkImageRegionIterator.h"
 
 #include "mitkLevenbergMarquardtModelFitFunctor.h"
 
 #include "mitkLinearModel.h"
 
 int mitkLevenbergMarquardtModelFitFunctorTest(int  /*argc*/, char*[] /*argv[]*/)
 {
   // always start with this!
   MITK_TEST_BEGIN("LevenbergMarquardtModelFitFunctor")
 
   //Prepare test artifacts and helper
 
   mitk::ModelBase::TimeGridType grid(10);
 
   typedef std::vector<double> ValueArrayType;
 
   ValueArrayType sample1(10);
   ValueArrayType sample2(10);
 
   for (int i = 0; i < 10; ++i)
   {
     grid[i] = i;
     sample1[i] = 5 * i;
     sample2[i] = 2 * i + 10;
   }
 
   mitk::LinearModel::Pointer model = mitk::LinearModel::New();
   model->SetTimeGrid(grid);
 
   mitk::LinearModel::ParametersType initParams;
   initParams.SetSize(2);
   initParams.Fill(0.0);
 
 
   mitk::LevenbergMarquardtModelFitFunctor::Pointer testFunctor =
     mitk::LevenbergMarquardtModelFitFunctor::New();
 
   //Test functor for sample1
 
-  MITK_TEST_FOR_EXCEPTION(::itk::ExceptionObject, testFunctor->GetNumberOfOutputs(NULL));
+  MITK_TEST_FOR_EXCEPTION(::itk::ExceptionObject, testFunctor->GetNumberOfOutputs(nullptr));
 
   CPPUNIT_ASSERT_MESSAGE("Check number of outputs with model set.", 4 == testFunctor->GetNumberOfOutputs(model));
 
   ValueArrayType output = testFunctor->Compute(sample1, model, initParams);
 
   CPPUNIT_ASSERT_MESSAGE("Check number of values in functor output.", 4 == output.size());
 
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(5, output[0], 1e-6, true) == true,
                                "Check fitted parameter 1 (slope) for sample 1.");
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(0, output[1], 1e-6, true) == true,
                                "Check fitted parameter 2 (offset) for sample 1.");
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(0, output[2], 1e-6, true) == true,
                                "Check derived parameter 1 (x-intercept) for sample 1.");
 
   //Test functor for sample2
   output = testFunctor->Compute(sample2, model, initParams);
 
   CPPUNIT_ASSERT_MESSAGE("Check number of values in functor output.", 4 == output.size());
 
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(2, output[0], 1e-6, true) == true,
                                "Check fitted parameter 1 (slope) for sample 2.");
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(10, output[1], 1e-6, true) == true,
                                "Check fitted parameter 2 (offset) for sample 2.")
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(-5, output[2], 1e-6, true) == true,
                                "Check derived parameter 1 (x-intercept) for sample 2.");
 
   MITK_TEST_END()
 }
diff --git a/Modules/ModelFit/test/mitkMVConstrainedCostFunctionDecoratorTest.cpp b/Modules/ModelFit/test/mitkMVConstrainedCostFunctionDecoratorTest.cpp
index e5901acddc..d812ac5399 100644
--- a/Modules/ModelFit/test/mitkMVConstrainedCostFunctionDecoratorTest.cpp
+++ b/Modules/ModelFit/test/mitkMVConstrainedCostFunctionDecoratorTest.cpp
@@ -1,157 +1,157 @@
 /*===================================================================
 
 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 <iostream>
 #include "mitkTestingMacros.h"
 
 #include "mitkSimpleBarrierConstraintChecker.h"
 #include "mitkMVConstrainedCostFunctionDecorator.h"
 #include "mitkLinearModel.h"
 
 class TestCostFunction : public mitk::MVModelFitCostFunction
 {
 public:
 
     typedef TestCostFunction Self;
     typedef mitk::MVModelFitCostFunction Superclass;
     typedef itk::SmartPointer< Self >                            Pointer;
     typedef itk::SmartPointer< const Self >                      ConstPointer;
 
     itkNewMacro(Self);
 
     typedef Superclass::SignalType SignalType;
 
     mutable unsigned int m_calls;
 
 protected:
 
     MeasureType CalcMeasure(const ParametersType &parameters, const SignalType& signal) const override
     {
       MeasureType result = signal;
       result[0] = parameters[0];
       result[1] = parameters[1];
       ++m_calls;
       return result;
     };
 	
     TestCostFunction()
     {
       m_calls = 0;
     }
 
     ~TestCostFunction() override{}
 };
 
 int mitkMVConstrainedCostFunctionDecoratorTest(int  /*argc*/, char*[] /*argv[]*/)
 {
 	MITK_TEST_BEGIN("mitkMVConstrainedCostFunctionDecoratorTest")
 
   mitk::SimpleBarrierConstraintChecker::Pointer checker = mitk::SimpleBarrierConstraintChecker::New();
   mitk::MVConstrainedCostFunctionDecorator::Pointer decorator = mitk::MVConstrainedCostFunctionDecorator::New();
   TestCostFunction::Pointer innerCF = TestCostFunction::New();
   mitk::LinearModel::Pointer model = mitk::LinearModel::New();
   decorator->SetModel(model);
   innerCF->SetModel(model);
 
   mitk::MVModelFitCostFunction::SignalType signal(5);
   signal.Fill(0.0);
   decorator->SetSample(signal);
   innerCF->SetSample(signal);
   
   mitk::LinearModel::TimeGridType grid(5);
   grid[0] = 0;
   grid[1] = 1;
   grid[2] = 2;
   grid[3] = 3;
   grid[4] = 4;
 
   model->SetTimeGrid(grid);
 
   mitk::SimpleBarrierConstraintChecker::ParametersType p1(2);
   p1[0] = 0;
   p1[1] = 50;
   mitk::SimpleBarrierConstraintChecker::ParametersType p2(2);
   p2[0] = 10;
   p2[1] = 50;
   mitk::SimpleBarrierConstraintChecker::ParametersType p3(2);
   p3[0] = 100;
   p3[1] = 50;
   mitk::SimpleBarrierConstraintChecker::ParametersType p4(2);
   p4[0] = 2;
   p4[1] = 50;
 
   checker->SetLowerBarrier(0,1,4);
   checker->SetUpperBarrier(0,100);
 
   double defaultMaxPenalty = 1e15;
 
   ///////////////////////
   //Tests
 
   //check freshly created checker; 
-  MITK_TEST_CONDITION_REQUIRED(decorator->GetWrappedCostFunction() == NULL,
+  MITK_TEST_CONDITION_REQUIRED(decorator->GetWrappedCostFunction() == nullptr,
 								 "Testing GetWrappedCostFunction for new decorator.");
-  MITK_TEST_CONDITION_REQUIRED(decorator->GetConstraintChecker() == NULL,
+  MITK_TEST_CONDITION_REQUIRED(decorator->GetConstraintChecker() == nullptr,
 								 "Testing GetWrappedCostFunction for new decorator.");
   MITK_TEST_CONDITION_REQUIRED(decorator->GetFailureThreshold() == defaultMaxPenalty,
 								 "Testing GetWrappedCostFunction for new decorator.");
 
   MITK_TEST_FOR_EXCEPTION(mitk::Exception, decorator->GetValue(p1));
   decorator->SetWrappedCostFunction(innerCF);
   MITK_TEST_FOR_EXCEPTION(mitk::Exception, decorator->GetValue(p1));
-  decorator->SetWrappedCostFunction(NULL);
+  decorator->SetWrappedCostFunction(nullptr);
   decorator->SetConstraintChecker(checker);
   MITK_TEST_FOR_EXCEPTION(mitk::Exception, decorator->GetValue(p1));
   decorator->SetWrappedCostFunction(innerCF);
 
 
   mitk::MVModelFitCostFunction::MeasureType measure = decorator->GetValue(p1);
   MITK_TEST_CONDITION_REQUIRED(measure[0] == defaultMaxPenalty, "Testing measure 1 with parameters p1.");
   MITK_TEST_CONDITION_REQUIRED(measure[1] == defaultMaxPenalty, "Testing measure 2 with parameters p1.");
   MITK_TEST_CONDITION_REQUIRED(measure[2] == defaultMaxPenalty, "Testing measure 3 with parameters p1.");
   MITK_TEST_CONDITION_REQUIRED(measure[3] == defaultMaxPenalty, "Testing measure 3 with parameters p1.");
   MITK_TEST_CONDITION_REQUIRED(measure[4] == defaultMaxPenalty, "Testing measure 3 with parameters p1.");
   MITK_TEST_CONDITION_REQUIRED(innerCF->m_calls == 0, "Checking calls with parameters p1.");
 
   measure = decorator->GetValue(p2);
   MITK_TEST_CONDITION_REQUIRED(measure[0] == 10, "Testing measure 1 with parameters p2.");
   MITK_TEST_CONDITION_REQUIRED(measure[1] == 50, "Testing measure 2 with parameters p2.");
   MITK_TEST_CONDITION_REQUIRED(measure[2] == 70, "Testing measure 3 with parameters p2.");
   MITK_TEST_CONDITION_REQUIRED(innerCF->m_calls == 1, "Checking calls with parameters p2.");
 
   measure = decorator->GetValue(p3);
   MITK_TEST_CONDITION_REQUIRED(measure[0] == defaultMaxPenalty, "Testing measure 1 with parameters p3.");
   MITK_TEST_CONDITION_REQUIRED(measure[1] == defaultMaxPenalty, "Testing measure 2 with parameters p3.");
   MITK_TEST_CONDITION_REQUIRED(measure[2] == defaultMaxPenalty, "Testing measure 3 with parameters p3.");
   MITK_TEST_CONDITION_REQUIRED(innerCF->m_calls == 1, "Checking calls with parameters p3.");
 
   decorator->SetActivateFailureThreshold(false);
   measure = decorator->GetValue(p3);
   MITK_TEST_CONDITION_REQUIRED(measure[0] == 100+defaultMaxPenalty, "Testing measure 1 with parameters p3 (deactiveated threshold).");
   MITK_TEST_CONDITION_REQUIRED(measure[1] == 50+defaultMaxPenalty, "Testing measure 2 with parameters p3 (deactiveated threshold).");
   MITK_TEST_CONDITION_REQUIRED(measure[2] == 250+defaultMaxPenalty, "Testing measure 3 with parameters p3 (deactiveated threshold).");
   MITK_TEST_CONDITION_REQUIRED(innerCF->m_calls ==2, "Checking calls with parameters p3 (deactiveated threshold).");
   decorator->SetActivateFailureThreshold(true);
 
   measure = decorator->GetValue(p4);
   MITK_TEST_CONDITION_REQUIRED(measure[0] == 2+(-1*log(1/4.)), "Testing measure 1 with parameters p4.");
   MITK_TEST_CONDITION_REQUIRED(measure[1] == 50+(-1*log(1/4.)), "Testing measure 2 with parameters p4.");
   MITK_TEST_CONDITION_REQUIRED(measure[2] == 54+(-1*log(1/4.)), "Testing measure 3 with parameters p4.");
   MITK_TEST_CONDITION_REQUIRED(innerCF->m_calls == 3, "Checking calls with parameters p4.");
 
 
   MITK_TEST_END()
 }
diff --git a/Modules/ModelFit/test/mitkModelFitInfoTest.cpp b/Modules/ModelFit/test/mitkModelFitInfoTest.cpp
index 7528aee218..bce79d1eb7 100644
--- a/Modules/ModelFit/test/mitkModelFitInfoTest.cpp
+++ b/Modules/ModelFit/test/mitkModelFitInfoTest.cpp
@@ -1,271 +1,271 @@
 /*===================================================================
 
 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 <iostream>
 #include "mitkTestingMacros.h"
 #include "mitkProperties.h"
 #include "mitkStandaloneDataStorage.h"
 
 #include "mitkModelFitInfo.h"
 #include "mitkModelFitConstants.h"
 #include "mitkModelFitException.h"
 
 mitk::DataNode::Pointer generateModelFitTestNode()
 {
   mitk::DataNode::Pointer node = mitk::DataNode::New();
   node->SetName("Param1");
   auto testImage = mitk::Image::New();
   node->SetData(testImage);
   testImage->SetProperty("modelfit.testEmpty", mitk::StringProperty::New(""));
   testImage->SetProperty("modelfit.testValid", mitk::StringProperty::New("test"));
   mitk::EnsureModelFitUID(node);
 
   testImage->SetProperty(mitk::ModelFitConstants::FIT_UID_PROPERTY_NAME().c_str(), mitk::StringProperty::New("Fit1"));
   testImage->SetProperty(mitk::ModelFitConstants::FIT_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New("MyName"));
   testImage->SetProperty(mitk::ModelFitConstants::FIT_TYPE_PROPERTY_NAME().c_str(), mitk::StringProperty::New(mitk::ModelFitConstants::FIT_TYPE_VALUE_PIXELBASED().c_str()));
   testImage->SetProperty(mitk::ModelFitConstants::FIT_INPUT_IMAGEUID_PROPERTY_NAME().c_str(), mitk::StringProperty::New("input UID"));
 
   testImage->SetProperty(mitk::ModelFitConstants::MODEL_TYPE_PROPERTY_NAME().c_str(), mitk::StringProperty::New("TestModels"));
   testImage->SetProperty(mitk::ModelFitConstants::MODEL_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New("TestModel_1"));
   testImage->SetProperty(mitk::ModelFitConstants::MODEL_FUNCTION_PROPERTY_NAME().c_str(), mitk::StringProperty::New(""));
   testImage->SetProperty(mitk::ModelFitConstants::MODEL_FUNCTION_CLASS_PROPERTY_NAME().c_str(), mitk::StringProperty::New("ModelClass"));
   testImage->SetProperty(mitk::ModelFitConstants::MODEL_X_PROPERTY_NAME().c_str(), mitk::StringProperty::New("myX"));
 
   testImage->SetProperty(mitk::ModelFitConstants::XAXIS_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New(mitk::ModelFitConstants::XAXIS_NAME_VALUE_DEFAULT().c_str()));
   testImage->SetProperty(mitk::ModelFitConstants::XAXIS_UNIT_PROPERTY_NAME().c_str(), mitk::StringProperty::New("h"));
   testImage->SetProperty(mitk::ModelFitConstants::YAXIS_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New(mitk::ModelFitConstants::YAXIS_NAME_VALUE_DEFAULT().c_str()));
   testImage->SetProperty(mitk::ModelFitConstants::YAXIS_UNIT_PROPERTY_NAME().c_str(), mitk::StringProperty::New("kg"));
 
   return node;
 }
 
 mitk::StandaloneDataStorage::Pointer generateModelFitTestStorage()
 {
   mitk::StandaloneDataStorage::Pointer storage = mitk::StandaloneDataStorage::New();
 
   //create input node
   mitk::DataNode::Pointer inputNode = mitk::DataNode::New();
   inputNode->SetName("Input");
   mitk::Image::Pointer image = mitk::Image::New();
   inputNode->SetData(image);
   mitk::NodeUIDType inputUID = mitk::EnsureModelFitUID(inputNode);
 
   storage->Add(inputNode);
 
   mitk::DataStorage::SetOfObjects::Pointer parents = mitk::DataStorage::SetOfObjects::New();
   parents->push_back(inputNode);
 
   //create first result for Fit1
   mitk::DataNode::Pointer node1 = mitk::DataNode::New();
   mitk::Image::Pointer paramImage = mitk::Image::New();
   node1->SetData(paramImage);
   node1->SetName("Param1");
   mitk::EnsureModelFitUID(node1);
   paramImage->SetProperty(mitk::ModelFitConstants::FIT_UID_PROPERTY_NAME().c_str(), mitk::StringProperty::New("Fit1"));
   paramImage->SetProperty(mitk::ModelFitConstants::FIT_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New("MyName1"));
   paramImage->SetProperty(mitk::ModelFitConstants::FIT_TYPE_PROPERTY_NAME().c_str(), mitk::StringProperty::New(mitk::ModelFitConstants::FIT_TYPE_VALUE_PIXELBASED().c_str()));
   paramImage->SetProperty(mitk::ModelFitConstants::FIT_INPUT_IMAGEUID_PROPERTY_NAME().c_str(), mitk::StringProperty::New(inputUID.c_str()));
 
   paramImage->SetProperty(mitk::ModelFitConstants::MODEL_TYPE_PROPERTY_NAME().c_str(), mitk::StringProperty::New("TestModels"));
   paramImage->SetProperty(mitk::ModelFitConstants::MODEL_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New("TestModel_1"));
   paramImage->SetProperty(mitk::ModelFitConstants::MODEL_FUNCTION_PROPERTY_NAME().c_str(), mitk::StringProperty::New(""));
   paramImage->SetProperty(mitk::ModelFitConstants::MODEL_FUNCTION_CLASS_PROPERTY_NAME().c_str(), mitk::StringProperty::New("ModelClass"));
   paramImage->SetProperty(mitk::ModelFitConstants::MODEL_X_PROPERTY_NAME().c_str(), mitk::StringProperty::New("myX"));
 
   paramImage->SetProperty(mitk::ModelFitConstants::XAXIS_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New(mitk::ModelFitConstants::XAXIS_NAME_VALUE_DEFAULT().c_str()));
   paramImage->SetProperty(mitk::ModelFitConstants::XAXIS_UNIT_PROPERTY_NAME().c_str(), mitk::StringProperty::New("h"));
   paramImage->SetProperty(mitk::ModelFitConstants::YAXIS_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New(mitk::ModelFitConstants::YAXIS_NAME_VALUE_DEFAULT().c_str()));
   paramImage->SetProperty(mitk::ModelFitConstants::YAXIS_UNIT_PROPERTY_NAME().c_str(), mitk::StringProperty::New("kg"));
 
   paramImage->SetProperty(mitk::ModelFitConstants::PARAMETER_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New("Param1"));
   paramImage->SetProperty(mitk::ModelFitConstants::PARAMETER_UNIT_PROPERTY_NAME().c_str(), mitk::StringProperty::New("b"));
   paramImage->SetProperty(mitk::ModelFitConstants::PARAMETER_TYPE_PROPERTY_NAME().c_str(), mitk::StringProperty::New(mitk::ModelFitConstants::PARAMETER_TYPE_VALUE_PARAMETER().c_str()));
 
   storage->Add(node1,parents);
 
   //create second result for Fit1
   mitk::DataNode::Pointer node2 = mitk::DataNode::New();
   node2->SetName("Param2");
   mitk::Image::Pointer paramImage2 = mitk::Image::New();
   node2->SetData(paramImage2);
   mitk::EnsureModelFitUID(node2);
   paramImage2->SetProperty(mitk::ModelFitConstants::FIT_UID_PROPERTY_NAME().c_str(), mitk::StringProperty::New("Fit1"));
   paramImage2->SetProperty(mitk::ModelFitConstants::FIT_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New("MyName1"));
   paramImage2->SetProperty(mitk::ModelFitConstants::FIT_TYPE_PROPERTY_NAME().c_str(), mitk::StringProperty::New(mitk::ModelFitConstants::FIT_TYPE_VALUE_PIXELBASED().c_str()));
   paramImage2->SetProperty(mitk::ModelFitConstants::FIT_INPUT_IMAGEUID_PROPERTY_NAME().c_str(), mitk::StringProperty::New(inputUID.c_str()));
 
   paramImage2->SetProperty(mitk::ModelFitConstants::MODEL_TYPE_PROPERTY_NAME().c_str(), mitk::StringProperty::New("TestModels"));
   paramImage2->SetProperty(mitk::ModelFitConstants::MODEL_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New("TestModel_1"));
   paramImage2->SetProperty(mitk::ModelFitConstants::MODEL_FUNCTION_PROPERTY_NAME().c_str(), mitk::StringProperty::New(""));
   paramImage2->SetProperty(mitk::ModelFitConstants::MODEL_FUNCTION_CLASS_PROPERTY_NAME().c_str(), mitk::StringProperty::New("ModelClass"));
   paramImage2->SetProperty(mitk::ModelFitConstants::MODEL_X_PROPERTY_NAME().c_str(), mitk::StringProperty::New("myX"));
 
   paramImage2->SetProperty(mitk::ModelFitConstants::XAXIS_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New(mitk::ModelFitConstants::XAXIS_NAME_VALUE_DEFAULT().c_str()));
   paramImage2->SetProperty(mitk::ModelFitConstants::XAXIS_UNIT_PROPERTY_NAME().c_str(), mitk::StringProperty::New("h"));
   paramImage2->SetProperty(mitk::ModelFitConstants::YAXIS_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New(mitk::ModelFitConstants::YAXIS_NAME_VALUE_DEFAULT().c_str()));
   paramImage2->SetProperty(mitk::ModelFitConstants::YAXIS_UNIT_PROPERTY_NAME().c_str(), mitk::StringProperty::New("kg"));
 
   paramImage2->SetProperty(mitk::ModelFitConstants::PARAMETER_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New("Param2"));
   paramImage2->SetProperty(mitk::ModelFitConstants::PARAMETER_UNIT_PROPERTY_NAME().c_str(), mitk::StringProperty::New("a"));
   paramImage2->SetProperty(mitk::ModelFitConstants::PARAMETER_TYPE_PROPERTY_NAME().c_str(), mitk::StringProperty::New(mitk::ModelFitConstants::PARAMETER_TYPE_VALUE_DERIVED_PARAMETER().c_str()));
 
   storage->Add(node2, parents);
 
   //create result for Fit 2
   mitk::DataNode::Pointer node3 = mitk::DataNode::New();
   node3->SetName("Param_Other");
   mitk::Image::Pointer paramImage3 = mitk::Image::New();
   node3->SetData(paramImage3);
   mitk::EnsureModelFitUID(node3);
   paramImage3->SetProperty(mitk::ModelFitConstants::FIT_UID_PROPERTY_NAME().c_str(), mitk::StringProperty::New("Fit2"));
   paramImage3->SetProperty(mitk::ModelFitConstants::FIT_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New("MyName2"));
   paramImage3->SetProperty(mitk::ModelFitConstants::FIT_TYPE_PROPERTY_NAME().c_str(), mitk::StringProperty::New(mitk::ModelFitConstants::FIT_TYPE_VALUE_PIXELBASED().c_str()));
   paramImage3->SetProperty(mitk::ModelFitConstants::FIT_INPUT_IMAGEUID_PROPERTY_NAME().c_str(), mitk::StringProperty::New(inputUID.c_str()));
 
   paramImage3->SetProperty(mitk::ModelFitConstants::MODEL_TYPE_PROPERTY_NAME().c_str(), mitk::StringProperty::New("TestModels"));
   paramImage3->SetProperty(mitk::ModelFitConstants::MODEL_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New("TestModel_2"));
   paramImage3->SetProperty(mitk::ModelFitConstants::MODEL_FUNCTION_PROPERTY_NAME().c_str(), mitk::StringProperty::New(""));
   paramImage3->SetProperty(mitk::ModelFitConstants::MODEL_FUNCTION_CLASS_PROPERTY_NAME().c_str(), mitk::StringProperty::New("ModelClass_B"));
 
   paramImage3->SetProperty(mitk::ModelFitConstants::PARAMETER_NAME_PROPERTY_NAME().c_str(), mitk::StringProperty::New("Param_Other"));
   paramImage3->SetProperty(mitk::ModelFitConstants::PARAMETER_UNIT_PROPERTY_NAME().c_str(), mitk::StringProperty::New("a"));
 
   storage->Add(node3, parents);
 
   return storage;
 }
 
 int mitkModelFitInfoTest(int  /*argc*/, char*[] /*argv[]*/)
 {
 	MITK_TEST_BEGIN("mitkModelFitTest")
 
 	mitk::modelFit::Parameter::Pointer p = mitk::modelFit::Parameter::New();
 	p->name = "p";
 	mitk::modelFit::ModelFitInfo::Pointer fit = mitk::modelFit::ModelFitInfo::New();
 	fit->AddParameter(p);
 	MITK_TEST_CONDITION_REQUIRED(fit->GetParameters().size() == 1,
 								 "Testing if AddParameter successfully adds a parameter.");
 
 	mitk::modelFit::Parameter::ConstPointer resultParam = fit->GetParameter("test",
 			mitk::modelFit::Parameter::ParameterType);
 	MITK_TEST_CONDITION_REQUIRED(resultParam.IsNull(),
 								 "Testing if GetParameter returns NULL for wrong parameter.");
 
 	resultParam = fit->GetParameter("p", mitk::modelFit::Parameter::ParameterType);
 	MITK_TEST_CONDITION_REQUIRED(resultParam == p,
 								 "Testing if GetParameter returns the correct parameter.");
 
 	p->type = mitk::modelFit::Parameter::CriterionType;
 	resultParam = fit->GetParameter("p", mitk::modelFit::Parameter::CriterionType);
 	MITK_TEST_CONDITION_REQUIRED(resultParam == p,
 								 "Testing if GetParameter returns the correct parameter with a " <<
 								 "non-default type.");
 
 	fit->DeleteParameter("test", mitk::modelFit::Parameter::CriterionType);
 	MITK_TEST_CONDITION_REQUIRED(fit->GetParameters().size() == 1,
 								 "Testing if DeleteParameter fails for wrong parameter.");
 
 	fit->DeleteParameter("p", mitk::modelFit::Parameter::CriterionType);
 	MITK_TEST_CONDITION_REQUIRED(fit->GetParameters().size() == 0,
 								 "Testing if DeleteParameter successfully removes a parameter.");
 
 	mitk::DataNode::Pointer node = generateModelFitTestNode();
   mitk::DataNode::Pointer invalideNode = mitk::DataNode::New();
 
   MITK_TEST_FOR_EXCEPTION(mitk::modelFit::ModelFitException,
 							mitk::modelFit::GetMandatoryProperty(node.GetPointer(), "modelfit.testInvalid"));
   MITK_TEST_FOR_EXCEPTION(mitk::modelFit::ModelFitException,
     mitk::modelFit::GetMandatoryProperty(node.GetPointer(), "modelfit.testEmpty"));
 
 	MITK_TEST_CONDITION_REQUIRED(mitk::modelFit::GetMandatoryProperty(node.GetPointer(), "modelfit.testValid")
 								 == "test",
 								 "Testing if GetMandatoryProperty returns the correct value.");
 
   mitk::StandaloneDataStorage::Pointer storage = generateModelFitTestStorage();
 
-  MITK_TEST_CONDITION_REQUIRED(mitk::modelFit::CreateFitInfoFromNode("Fit1",NULL).IsNull(),
+  MITK_TEST_CONDITION_REQUIRED(mitk::modelFit::CreateFitInfoFromNode("Fit1",nullptr).IsNull(),
 								 "Testing if CreateFitInfoFromNode returns NULL for invalid node.");
 
 	MITK_TEST_CONDITION_REQUIRED(mitk::modelFit::CreateFitInfoFromNode("invalide_UID",storage).IsNull(),
 								 "Testing if CreateFitInfoFromNode returns NULL for node with " <<
 								 "missing properties.");
 
   mitk::DataNode::Pointer testNode = storage->GetNamedNode("Param1");
 	mitk::modelFit::ModelFitInfo::Pointer resultFit = mitk::modelFit::CreateFitInfoFromNode("Fit1", storage);
   MITK_TEST_CONDITION_REQUIRED(resultFit.IsNotNull(),
     "Testing if CreateFitInfoFromNode returns a valid model fit info.");
   MITK_TEST_CONDITION_REQUIRED(resultFit->fitType == mitk::ModelFitConstants::FIT_TYPE_VALUE_PIXELBASED() &&
     resultFit->uid == "Fit1" &&
     resultFit->fitName == "MyName1" &&
     resultFit->modelType == "TestModels" &&
     resultFit->modelName == "TestModel_1" &&
     resultFit->function == ""&&
     resultFit->functionClassID == "ModelClass" &&
     resultFit->x == "myX" &&
     resultFit->xAxisName == mitk::ModelFitConstants::XAXIS_NAME_VALUE_DEFAULT() &&
     resultFit->xAxisUnit == "h" &&
     resultFit->yAxisName == mitk::ModelFitConstants::YAXIS_NAME_VALUE_DEFAULT() &&
     resultFit->yAxisUnit == "kg" &&
     resultFit->GetParameters().size() == 2,
     "Testing if CreateFitInfoFromNode creates a fit with correct attributes.");
 
   mitk::modelFit::Parameter::ConstPointer param = resultFit->GetParameter("Param1",mitk::modelFit::Parameter::ParameterType);
   MITK_TEST_CONDITION_REQUIRED(param.IsNotNull(),
     "Testing if param 1 exists.");
 
   MITK_TEST_CONDITION_REQUIRED(param->name == "Param1" && param->unit == "b" && param->image == testNode->GetData(),
     "Testing if param 1 is configured correctly.");
 
   mitk::modelFit::Parameter::ConstPointer param2 = resultFit->GetParameter("Param2",mitk::modelFit::Parameter::DerivedType);
   MITK_TEST_CONDITION_REQUIRED(param2.IsNotNull(),
     "Testing if param 2 exists.");
 
   testNode = storage->GetNamedNode("Param2");
   MITK_TEST_CONDITION_REQUIRED(param2->name == "Param2" && param2->unit == "a" && param2->image == testNode->GetData(),
     "Testing if param 2 is configured correctly.");
 
   MITK_TEST_CONDITION_REQUIRED(mitk::modelFit::GetNodesOfFit(resultFit->uid,storage)->Size() == 2,
     "Testing if GetNodesOfFit works correctly for Fit1");
 
   MITK_TEST_CONDITION_REQUIRED(mitk::modelFit::GetNodesOfFit("Fit2",storage)->Size() == 1,
     "Testing if GetNodesOfFit works correctly for Fit1");
 
   MITK_TEST_CONDITION_REQUIRED(mitk::modelFit::GetNodesOfFit("unkown_fit",storage)->Size() == 0,
     "Testing if GetNodesOfFit works correctly for unkown fits.");
 
-  MITK_TEST_CONDITION_REQUIRED(mitk::modelFit::GetNodesOfFit("unkown_fit",NULL).IsNull(),
+  MITK_TEST_CONDITION_REQUIRED(mitk::modelFit::GetNodesOfFit("unkown_fit",nullptr).IsNull(),
     "Testing if GetNodesOfFit works correctly for illegal calls.");
 
   testNode = storage->GetNamedNode("Input");
   mitk::modelFit::NodeUIDSetType uidSet = mitk::modelFit::GetFitUIDsOfNode(testNode,storage);
 
   MITK_TEST_CONDITION_REQUIRED(uidSet.size() == 2 &&
     uidSet.find("Fit1")!=uidSet.end() &&
     uidSet.find("Fit2")!=uidSet.end(),
     "Testing if GetFitUIDsOfNode works correctly.");
 
-  uidSet = mitk::modelFit::GetFitUIDsOfNode(NULL,storage);
+  uidSet = mitk::modelFit::GetFitUIDsOfNode(nullptr,storage);
 
   MITK_TEST_CONDITION_REQUIRED(uidSet.size() == 0,
     "Testing if GetFitUIDsOfNode works correctly with invalid node.");
 
-  uidSet = mitk::modelFit::GetFitUIDsOfNode(testNode,NULL);
+  uidSet = mitk::modelFit::GetFitUIDsOfNode(testNode,nullptr);
 
   MITK_TEST_CONDITION_REQUIRED(uidSet.size() == 0,
     "Testing if GetFitUIDsOfNode works correctly with invalid storage.");
 
   MITK_TEST_END()
 }
diff --git a/Modules/ModelFitUI/Qmitk/QmitkFitParameterModel.h b/Modules/ModelFitUI/Qmitk/QmitkFitParameterModel.h
index 63416521ed..03c8725c7e 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkFitParameterModel.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkFitParameterModel.h
@@ -1,81 +1,81 @@
 /*===================================================================
 
 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 QmitkFitParameterModel_h
 #define QmitkFitParameterModel_h
 
 #include <QAbstractTableModel>
 
 #include "mitkModelFitInfo.h"
 #include "mitkPointSet.h"
 
 #include "MitkModelFitUIExports.h"
 
 
 /*!
 \class QmitkFitParameterModel
 Model that can be used to display the parameter values of ModelFitInfo instances for different world coordinate positions.
 If more then one ModelFitInfo instance is given the model will use a tree hirarchy. The first level are the fits,
 the seconds level are the parameter of the fit.
 */
 class MITKMODELFITUI_EXPORT QmitkFitParameterModel : public QAbstractTableModel
 {
   Q_OBJECT
 
 public:
   using FitVectorType = std::vector<mitk::modelFit::ModelFitInfo::ConstPointer>;
 
-  QmitkFitParameterModel(QObject* parent = NULL);
+  QmitkFitParameterModel(QObject* parent = nullptr);
   ~QmitkFitParameterModel() override {};
 
   const FitVectorType& getFits() const;
 
   mitk::Point3D getCurrentPosition() const;
 
   const mitk::PointSet* getPositionBookmarks() const;
 
   Qt::ItemFlags flags(const QModelIndex& index) const override;
   QVariant data(const QModelIndex& index, int role) const override;
   QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
   int rowCount(const QModelIndex& parent = QModelIndex()) const override;
   int columnCount(const QModelIndex& parent = QModelIndex()) const override;
   bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
 
 public Q_SLOTS:
 
   void setFits(const FitVectorType& fits);
 
   void setCurrentPosition(const mitk::Point3D& currentPos);
 
   void setPositionBookmarks(const mitk::PointSet* bookmarks);
 
 
 protected:
 
   std::size_t getBookmarksCount() const;
 
 private:
 
   bool hasSingleFit() const;
 
   FitVectorType m_Fits;
   mitk::PointSet::ConstPointer m_Bookmarks;
   mitk::Point3D m_CurrentPos;
 
 };
 
 #endif // QmitkFitParameterModel_h
 
diff --git a/Modules/ModelFitUI/Qmitk/QmitkFitParameterWidget.h b/Modules/ModelFitUI/Qmitk/QmitkFitParameterWidget.h
index 8eb1ae9cd0..e7ac5e7b24 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkFitParameterWidget.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkFitParameterWidget.h
@@ -1,81 +1,81 @@
 /*===================================================================
 
 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 QMITK_FIT_PARAMETER_WIDGET_H
 #define QMITK_FIT_PARAMETER_WIDGET_H
 
 #include "mitkModelFitInfo.h"
 #include "mitkPointSet.h"
 
 #include "MitkModelFitUIExports.h"
 
 #include "ui_QmitkFitParameterWidget.h"
 #include <QWidget>
 
 
 class QmitkFitParameterModel;
 
 /**
 * \class QmitkFitParameterWidget
 * Widget that displays the parameters of all set ModelFitInfo instances for all given
 * world coordinate points.
 * In addition it allows to transfer this information as CSV into the clipboard or a file.
 */
 class MITKMODELFITUI_EXPORT QmitkFitParameterWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   using FitVectorType = std::vector<mitk::modelFit::ModelFitInfo::ConstPointer>;
 
-  QmitkFitParameterWidget(QWidget* parent = 0);
+  QmitkFitParameterWidget(QWidget* parent = nullptr);
   ~QmitkFitParameterWidget() override;
 
   const FitVectorType& getFits() const;
 
   mitk::Point3D getCurrentPosition() const;
 
   const mitk::PointSet* getPositionBookmarks() const;
 
 public Q_SLOTS:
 
   void setFits(const FitVectorType& fits);
 
   void setCurrentPosition(const mitk::Point3D& currentPos);
 
   void setPositionBookmarks(const mitk::PointSet* bookmarks);
 
 protected Q_SLOTS:
   void OnExportClicked() const;
 
   /** @brief Saves the results table to clipboard */
   void OnClipboardResultsButtonClicked() const;
 
 protected:
   std::string streamModelToString() const;
 
   QmitkFitParameterModel * m_InternalModel;
 
   Ui::QmitkFitParameterWidget m_Controls;
 
 };
 
 /** Helper function to sanatize strings before used in a csv export
  Moved to header in order to be reusabel for other ModelFitUI widgets.*/
 std::string SanatizeString(std::string str);
 
 #endif // QmitkFitParameterWidget_H
diff --git a/Modules/ModelFitUI/Qmitk/QmitkFitPlotDataModel.h b/Modules/ModelFitUI/Qmitk/QmitkFitPlotDataModel.h
index c6f5e87f8c..c54e0cd4fb 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkFitPlotDataModel.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkFitPlotDataModel.h
@@ -1,65 +1,65 @@
 /*===================================================================
 
 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 QmitkFitPlotDataModel_h
 #define QmitkFitPlotDataModel_h
 
 #include <QAbstractTableModel>
 
 #include "mitkModelFitPlotDataHelper.h"
 #include "MitkModelFitUIExports.h"
 
 /*!
 \class QmitkFitPlotDataModel
 Model that can be used to display the values of an ModelFitPlotData instance.
 */
 class MITKMODELFITUI_EXPORT QmitkFitPlotDataModel : public QAbstractTableModel
 {
   Q_OBJECT
 
 public:
   using FitVectorType = std::vector<mitk::modelFit::ModelFitInfo::ConstPointer>;
 
-  QmitkFitPlotDataModel(QObject* parent = NULL);
+  QmitkFitPlotDataModel(QObject* parent = nullptr);
   ~QmitkFitPlotDataModel() override {};
 
   const mitk::ModelFitPlotData* GetPlotData() const;
   const std::string& GetXName() const;
 
   Qt::ItemFlags flags(const QModelIndex& index) const override;
   QVariant data(const QModelIndex& index, int role) const override;
   QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
   int rowCount(const QModelIndex& parent = QModelIndex()) const override;
   int columnCount(const QModelIndex& parent = QModelIndex()) const override;
   bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
 
 public Q_SLOTS:
 
   void SetPlotData(const mitk::ModelFitPlotData* data);
   void SetXName(const std::string& xName);
 
 protected:
   std::pair<std::string, const mitk::PlotDataCurve*> GetCurveByColumn(int col) const;
   std::pair<bool, mitk::ModelFitPlotData::PositionalCollectionMap::value_type> GetPositionalCurvePoint(const mitk::PlotDataCurve*) const;
 
 private:
   mitk::ModelFitPlotData m_PlotData;
   std::string m_XName;
 
 };
 
 #endif // QmitkFitPlotDataModel_h
 
diff --git a/Modules/ModelFitUI/Qmitk/QmitkFitPlotDataWidget.h b/Modules/ModelFitUI/Qmitk/QmitkFitPlotDataWidget.h
index 94cf7c9ecc..c7d9fb7c16 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkFitPlotDataWidget.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkFitPlotDataWidget.h
@@ -1,69 +1,69 @@
 /*===================================================================
 
 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 QMITK_FIT_PLOT_DATA_WIDGET_H
 #define QMITK_FIT_PLOT_DATA_WIDGET_H
 
 #include "mitkModelFitPlotDataHelper.h"
 
 #include "MitkModelFitUIExports.h"
 
 #include "ui_QmitkFitPlotDataWidget.h"
 #include <QWidget>
 #include <memory>
 
 class QmitkFitPlotDataModel;
 
 /**
 * \class QmitkFitPlotDataWidget
 * Widget that displays the content of a ModelFitPlotData instance.
 * In addition it allows to transfer this information as CSV into the clipboard or a file.
 */
 class MITKMODELFITUI_EXPORT QmitkFitPlotDataWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   using FitVectorType = std::vector<mitk::modelFit::ModelFitInfo::ConstPointer>;
 
-  QmitkFitPlotDataWidget(QWidget* parent = 0);
+  QmitkFitPlotDataWidget(QWidget* parent = nullptr);
   ~QmitkFitPlotDataWidget() override;
 
   const mitk::ModelFitPlotData* GetPlotData() const;
   const std::string& GetXName() const;
 
 public Q_SLOTS:
 
   void SetPlotData(const mitk::ModelFitPlotData* data);
   void SetXName(const std::string& xName);
 
 protected Q_SLOTS:
   void OnExportClicked() const;
 
   /** @brief Saves the results table to clipboard */
   void OnClipboardResultsButtonClicked() const;
 
 protected:
   std::string StreamModelToString() const;
 
   QmitkFitPlotDataModel * m_InternalModel;
 
   Ui::QmitkFitPlotDataWidget m_Controls;
 
 };
 
 #endif // QmitkFitPlotDataWidget_H
diff --git a/Modules/ModelFitUI/Qmitk/QmitkInitialValuesDelegate.h b/Modules/ModelFitUI/Qmitk/QmitkInitialValuesDelegate.h
index 0b9372389a..04f06a2e3e 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkInitialValuesDelegate.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkInitialValuesDelegate.h
@@ -1,64 +1,64 @@
 /*===================================================================
 
 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 QmitkInitialValuesDelegate_h
 #define QmitkInitialValuesDelegate_h
 
 
 /// Toolkit includes.
 #include <mitkDataStorage.h>
 #include <mitkNodePredicateBase.h>
 
 #include <QStyledItemDelegate>
 
 #include "MitkModelFitUIExports.h"
 
 
 /** \class QmitkInitialValuesDelegate
 \brief An item delegate for rendering and editing the initial value (source) for a parameter.
 The delegate assumes the following: 1) the data requested with the
 edit role, will be an double if it is an simple scalar type. If the type is image,
 it will be a pointer to the currently selected data node. If nothing is selected now it will be
 a nullptr.*/
 class MITKMODELFITUI_EXPORT QmitkInitialValuesDelegate : public QStyledItemDelegate
 {
   Q_OBJECT
 
 public:
 
-  QmitkInitialValuesDelegate(QObject* parent = 0);
+  QmitkInitialValuesDelegate(QObject* parent = nullptr);
 
   QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option
                         , const QModelIndex& index) const override;
 
   void setEditorData(QWidget* editor, const QModelIndex& index) const override;
 
   void setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const override;
 
   void setDataStorage(mitk::DataStorage* storage);
   void setNodePredicate(mitk::NodePredicateBase* predicate);
 
 protected:
   int valueType(const QModelIndex& index) const;
 
   /**Storage is used as source for potantial initial value images.*/
   mitk::DataStorage::Pointer m_Storage;
   /**Predicates that is used to filter for potential/allowed images in the data storage*/
   mitk::NodePredicateBase::Pointer m_Predicate;
 
 };
 
 #endif
diff --git a/Modules/ModelFitUI/Qmitk/QmitkInitialValuesManagerWidget.h b/Modules/ModelFitUI/Qmitk/QmitkInitialValuesManagerWidget.h
index c094b30276..87558f0ee8 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkInitialValuesManagerWidget.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkInitialValuesManagerWidget.h
@@ -1,88 +1,88 @@
 /*===================================================================
 
 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 QMITK_INITIAL_VALUES_MANAGER_WIDGET_H
 #define QMITK_INITIAL_VALUES_MANAGER_WIDGET_H
 
 #include "MitkModelFitUIExports.h"
 
 #include "ui_QmitkInitialValuesManagerWidget.h"
 #include <QWidget>
 
 #include "mitkModelTraitsInterface.h"
 #include "mitkInitialParameterizationDelegateBase.h"
 
 /*forward declarations*/
 class QmitkInitialValuesModel;
 class QmitkInitialValuesTypeDelegate;
 class QmitkInitialValuesDelegate;
 
 namespace mitk
 {
   class DataStorage;
   class BaseGeometry;
 }
 
 /**
 * \class QmitkInitialValuesManagerWidget
 * \brief Widget that allows to edit the initial values of an model.
 */
 class MITKMODELFITUI_EXPORT QmitkInitialValuesManagerWidget : public QWidget
 {
   Q_OBJECT
 
 public:
-  QmitkInitialValuesManagerWidget(QWidget* parent = 0);
+  QmitkInitialValuesManagerWidget(QWidget* parent = nullptr);
   ~QmitkInitialValuesManagerWidget() override;
 
   /** Returns the current set initial values of the model.*/
   mitk::ModelTraitsInterface::ParametersType getInitialValues() const;
   mitk::InitialParameterizationDelegateBase::Pointer getInitialParametrizationDelegate() const;
 
   bool hasValidInitialValues() const;
 
 signals:
   void initialValuesChanged();
 
 public Q_SLOTS:
   /** Sets the names and the values of the initial parameter set for the model.
    @param names List of all possible parameter names. It is assumed that the
    index of the list equals the parameter index in the respective fitting model and its parameter values.
    @values Default values to start with.*/
   void setInitialValues(const mitk::ModelTraitsInterface::ParameterNamesType& names,
                         const mitk::ModelTraitsInterface::ParametersType values);
   void setInitialValues(const mitk::ModelTraitsInterface::ParameterNamesType& names);
 
   void setDataStorage(mitk::DataStorage* storage);
 
   void setReferenceImageGeometry(mitk::BaseGeometry* refgeo);
 
 protected:
 
   QmitkInitialValuesModel* m_InternalModel;
 
   QmitkInitialValuesTypeDelegate* m_TypeDelegate;
   QmitkInitialValuesDelegate* m_ValuesDelegate;
 
   Ui::QmitkInitialValuesManagerWidget m_Controls;
 
 protected Q_SLOTS:
   void OnModelReset();
 
 };
 
 #endif // QmitkInitialValuesManagerWidget_H
diff --git a/Modules/ModelFitUI/Qmitk/QmitkInitialValuesModel.h b/Modules/ModelFitUI/Qmitk/QmitkInitialValuesModel.h
index 7e93702150..c38ab6e79e 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkInitialValuesModel.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkInitialValuesModel.h
@@ -1,98 +1,98 @@
 /*===================================================================
 
 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 QmitkInitialValuesModel_h
 #define QmitkInitialValuesModel_h
 
 #include <QAbstractTableModel>
 
 #include "mitkSimpleBarrierConstraintChecker.h"
 #include "mitkModelTraitsInterface.h"
 #include "mitkDataNode.h"
 #include "mitkInitialParameterizationDelegateBase.h"
 
 #include "MitkModelFitUIExports.h"
 
 
 /*!
 \class QmitkInitialValuesModel
 Model that handles the definition of inital model values.
 */
 class MITKMODELFITUI_EXPORT QmitkInitialValuesModel : public QAbstractTableModel
 {
   Q_OBJECT
 
 public:
-  QmitkInitialValuesModel(QObject* parent = NULL);
+  QmitkInitialValuesModel(QObject* parent = nullptr);
   ~QmitkInitialValuesModel() override {};
 
   /** Sets the names and the values of the initial parameter set for the model.
    @param names List of all possible parameter names. It is assumed that the
    index of the list equals the parameter index in the respective fitting model and its parameter values.
    @values Default values to start with.*/
   void setInitialValues(const mitk::ModelTraitsInterface::ParameterNamesType& names,
                         const mitk::ModelTraitsInterface::ParametersType values);
   /**@overload
    Convinience method that sets the default initial values always to zero.*/
   void setInitialValues(const mitk::ModelTraitsInterface::ParameterNamesType& names);
 
   /** Adds an image as a source for the initial value of a parameter.
   * @param node Pointer to the image that is the value source.
   * @param paramIndex Indicates which parameter is defined by the source image.
   * It equals the position of the vector defined by setInitialValues().
   * @remark setting an image for an index overwrites the value for this index set by
   * SetInitialParameterization.
   * @pre paramIndex must be in bound of the initial parametrization vector.
   * @pre node must be a valid image instance*/
   void addInitialParameterImage(const mitk::DataNode* node, mitk::ModelTraitsInterface::ParametersType::size_type paramIndex);
 
   bool hasValidInitialValues() const;
 
   void resetInitialParameterImage();
 
   /** Returns a pointer to a delegate instance that represents the parameterization of the model.*/
   mitk::InitialParameterizationDelegateBase::Pointer getInitialParametrizationDelegate() const;
   /** Returns the current set initial values of the model.
    * @Remark: this are only the simpel scalar initial values. If an source image was set, this is missed here.
    * Use getInitialParametrizationDelegate() to get everything at once.*/
   mitk::ModelTraitsInterface::ParametersType getInitialValues() const;
 
   Qt::ItemFlags flags(const QModelIndex& index) const override;
   QVariant data(const QModelIndex& index, int role) const override;
   QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
   int rowCount(const QModelIndex& parent = QModelIndex()) const override;
   int columnCount(const QModelIndex& parent = QModelIndex()) const override;
   bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
 
   /**Indicates if the content of the model was modified since the data was set via setInitialValues()*/
   bool isModified();
 
 private:
   int valueType(const QModelIndex& index) const;
 
   mitk::ModelTraitsInterface::ParametersType m_Values;
   mitk::ModelTraitsInterface::ParameterNamesType m_ParameterNames;
 
   typedef std::map<mitk::ModelTraitsInterface::ParametersType::size_type, mitk::DataNode::ConstPointer> ImageMapType;
   ImageMapType m_ParameterImageMap;
 
   /** Indicates if the data of the model was modified, since the model was set. */
   bool m_modified;
 
 };
 
 #endif // QmitkInitialValuesModel_h
 
diff --git a/Modules/ModelFitUI/Qmitk/QmitkInitialValuesTypeDelegate.h b/Modules/ModelFitUI/Qmitk/QmitkInitialValuesTypeDelegate.h
index 934b876f58..c924d957aa 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkInitialValuesTypeDelegate.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkInitialValuesTypeDelegate.h
@@ -1,45 +1,45 @@
 /*===================================================================
 
 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 QmitkInitialValuesTypeDelegate_h
 #define QmitkInitialValuesTypeDelegate_h
 
 
 #include <QStyledItemDelegate>
 
 #include "MitkModelFitUIExports.h"
 
 
 /** \class QmitkInitialValuesTypeDelegate
 \brief An item delegate for rendering and editing the type of a initial value.
 It assumes that the type is encoded as int. 0: simple scalar, 1: image.*/
 class MITKMODELFITUI_EXPORT QmitkInitialValuesTypeDelegate : public QStyledItemDelegate
 {
   Q_OBJECT
 
 public:
 
-  QmitkInitialValuesTypeDelegate(QObject* parent = 0);
+  QmitkInitialValuesTypeDelegate(QObject* parent = nullptr);
 
   QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option
                         , const QModelIndex& index) const override;
 
   void setEditorData(QWidget* editor, const QModelIndex& index) const override;
 
   void setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const override;
 };
 
 #endif
diff --git a/Modules/ModelFitUI/Qmitk/QmitkInspectionPositionWidget.h b/Modules/ModelFitUI/Qmitk/QmitkInspectionPositionWidget.h
index fbce8969af..b07febb4c9 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkInspectionPositionWidget.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkInspectionPositionWidget.h
@@ -1,72 +1,72 @@
 /*===================================================================
 
 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 QMITK_INSPECTION_POSITION_WIDGET_H
 #define QMITK_INSPECTION_POSITION_WIDGET_H
 
 #include "mitkModelFitInfo.h"
 #include "mitkPointSet.h"
 
 #include "MitkModelFitUIExports.h"
 
 #include "ui_QmitkInspectionPositionWidget.h"
 #include <QWidget>
 
 
 class QmitkFitParameterModel;
 
 /**
 * \class QmitkInspectionPositionWidget
 * \brief Widget that allows manage the positions that should be used to inspect fits.
 */
 class MITKMODELFITUI_EXPORT QmitkInspectionPositionWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   using FitVectorType = std::vector<mitk::modelFit::ModelFitInfo::ConstPointer>;
 
-  QmitkInspectionPositionWidget(QWidget* parent = 0);
+  QmitkInspectionPositionWidget(QWidget* parent = nullptr);
   ~QmitkInspectionPositionWidget() override;
 
   mitk::Point3D GetCurrentPosition() const;
 
   const mitk::PointSet* GetPositionBookmarks() const;
 
   /** @brief assign a point set (contained in a node of DataStorage) for observation */
   void SetPositionBookmarkNode(mitk::DataNode *newNode);
   mitk::DataNode *GetPositionBookmarkNode();
 
 public Q_SLOTS:
 
   void SetCurrentPosition(const mitk::Point3D& currentPos);
   void OnPointListChanged();
   void OnAddCurrentPositionClicked();
 
 Q_SIGNALS:
   /** Is emitted as soon as the position bookmarks changed.*/
   void PositionBookmarksChanged();
 
 protected:
 
   mitk::Point3D m_CurrentPosition;
 
   Ui::QmitkInspectionPositionWidget m_Controls;
 
 };
 
 #endif // QmitkInspectionPositionWidget_H
diff --git a/Modules/ModelFitUI/Qmitk/QmitkParameterFitBackgroundJob.h b/Modules/ModelFitUI/Qmitk/QmitkParameterFitBackgroundJob.h
index b4dc74fea8..886a0d4810 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkParameterFitBackgroundJob.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkParameterFitBackgroundJob.h
@@ -1,84 +1,84 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Software Development for
 Integrated Diagnostic and Therapy. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #ifndef __QMITK_PARAMETER_FIT_BACKGROUND_JOB_H
 #define __QMITK_PARAMETER_FIT_BACKGROUND_JOB_H
 
 
 //QT
 #include <QRunnable>
 #include <QObject>
 
 //MITK
 #include <mitkDataNode.h>
 
 #include <mitkParameterFitImageGeneratorBase.h>
 #include <mitkModelFitResultHelper.h>
 #include <mitkModelFitInfo.h>
 
 // ITK
 #include <itkCommand.h>
 
 #include "MitkModelFitUIExports.h"
 
 class MITKMODELFITUI_EXPORT ParameterFitBackgroundJob : public QObject, public QRunnable
 {
     // this is needed for all Qt objects that should have a Qt meta-object
     // (everything that derives from QObject and wants to have signal/slots)
     Q_OBJECT
 
 public:
-  ParameterFitBackgroundJob(mitk::ParameterFitImageGeneratorBase* generator, const mitk::modelFit::ModelFitInfo* fitInfo, mitk::DataNode* parentNode = NULL);
+  ParameterFitBackgroundJob(mitk::ParameterFitImageGeneratorBase* generator, const mitk::modelFit::ModelFitInfo* fitInfo, mitk::DataNode* parentNode = nullptr);
   /** */
   ParameterFitBackgroundJob(mitk::ParameterFitImageGeneratorBase* generator, const mitk::modelFit::ModelFitInfo* fitInfo, mitk::DataNode* parentNode, mitk::modelFit::ModelFitResultNodeVectorType additionalRelevantNodes);
 
   ~ParameterFitBackgroundJob() override;
 
 		void run() override;
 
     /**Returns the node (if defined), that is the parent object for the results of the job.
     May be null.*/
     mitk::DataNode* GetParentNode() const;
 
     mitk::modelFit::ModelFitResultNodeVectorType GetAdditionalRelevantNodes() const;
 
 signals:
     void Finished();
     void Error(QString err);
     void ResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType resultMap, const ParameterFitBackgroundJob* pJob);
     void JobProgress(double progress);
     void JobStatusChanged(QString info);
 
 protected:
 	//Inputs
 	mitk::ParameterFitImageGeneratorBase::Pointer m_Generator;
   mitk::modelFit::ModelFitInfo::ConstPointer m_ModelFitInfo;
   mitk::DataNode::Pointer m_ParentNode;
   mitk::modelFit::ModelFitResultNodeVectorType m_AdditionalRelevantNodes;
 
   // Results
   mitk::modelFit::ModelFitResultNodeVectorType m_Results;
 
   ::itk::MemberCommand<ParameterFitBackgroundJob>::Pointer m_spCommand;
   unsigned long m_ObserverID;
 
   void OnFitEvent(::itk::Object *, const itk::EventObject &event);
 };
 
 #endif
 
diff --git a/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierManagerWidget.h b/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierManagerWidget.h
index 8f61c64953..730dd75f3e 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierManagerWidget.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierManagerWidget.h
@@ -1,81 +1,81 @@
 /*===================================================================
 
 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 QMITK_SIMPLE_BARRIER_MANAGER_WIDGET_H
 #define QMITK_SIMPLE_BARRIER_MANAGER_WIDGET_H
 
 #include "MitkModelFitUIExports.h"
 
 #include "ui_QmitkSimpleBarrierManagerWidget.h"
 #include <QWidget>
 
 #include "mitkSimpleBarrierConstraintChecker.h"
 
 /*forward declarations*/
 class QmitkSimpleBarrierParametersDelegate;
 class QmitkSimpleBarrierTypeDelegate;
 class QmitkSimpleBarrierModel;
 
 /**
 * \class QmitkSimpleBarrierManagerWidget
 * \brief Widget that allows to edit the constraints of SimpleBarrierConstraintChecker.
 */
 class MITKMODELFITUI_EXPORT QmitkSimpleBarrierManagerWidget : public QWidget
 {
   Q_OBJECT
 
 public:
-  QmitkSimpleBarrierManagerWidget(QWidget* parent = 0);
+  QmitkSimpleBarrierManagerWidget(QWidget* parent = nullptr);
   ~QmitkSimpleBarrierManagerWidget() override;
 
 signals:
   void ConstraintChanged(mitk::SimpleBarrierConstraintChecker::Constraint constraint);
 
 public Q_SLOTS:
   /** Sets the data handled by the model and resets the modified flag
    @param pChecker Pointer to the checker instance that should be managed.
    @param names List of all possible parameter names. It is assumed that the
    index of the list equals the parameter index in the respective fitting model.*/
   void setChecker(mitk::SimpleBarrierConstraintChecker* pChecker,
                   const mitk::ModelTraitsInterface::ParameterNamesType& names);
 
 protected Q_SLOTS:
   void OnShowContextMenuIsoSet(const QPoint& pos);
   void OnAddConstraint(bool checked);
   void OnDelConstraint(bool checked);
 
 protected:
 
   /**
   * \brief Updates the widget according to its current settings.
   */
   void update();
 
   mitk::SimpleBarrierConstraintChecker::Pointer m_Checker;
   mitk::ModelTraitsInterface::ParameterNamesType m_ParameterNames;
 
   QmitkSimpleBarrierModel* m_InternalModel;
   QmitkSimpleBarrierTypeDelegate* m_TypeDelegate;
   QmitkSimpleBarrierParametersDelegate* m_ParametersDelegate;
 
   bool m_InternalUpdate;
 
   Ui::QmitkSimpleBarrierManagerWidget m_Controls;
 
 };
 
 #endif // QmitkSimpleBarrierManagerWidget_H
diff --git a/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierModel.h b/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierModel.h
index 198e075d07..4b1e607274 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierModel.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierModel.h
@@ -1,72 +1,72 @@
 /*===================================================================
 
 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 QmitkSimpleBarrierModel_h
 #define QmitkSimpleBarrierModel_h
 
 #include <QAbstractTableModel>
 
 #include "mitkSimpleBarrierConstraintChecker.h"
 #include "mitkModelTraitsInterface.h"
 
 #include "MitkModelFitUIExports.h"
 
 
 /*!
 \class QmitkSimpleBarrierModel
 Model that handles a SimpleBarrierConstraintChecker and his defined constraints.
 It allows to couple a SimpleBarrierConstraintChecker with a Qt table view in
 Order to view and edit its contents. E.g. used in the QmitkSimpleBarrierManagerWidget.
 */
 class MITKMODELFITUI_EXPORT QmitkSimpleBarrierModel : public QAbstractTableModel
 {
   Q_OBJECT
 
 public:
-  QmitkSimpleBarrierModel(QObject* parent = NULL);
+  QmitkSimpleBarrierModel(QObject* parent = nullptr);
   ~QmitkSimpleBarrierModel() override {};
 
   /** Sets the data handled by the model and resets the modified flag
    @param pChecker Pointer to the checker instance that should be managed.
    @param names List of all possible parameter names. It is assumed that the
    index of the list equals the parameter index in the respective fitting model.*/
   void setChecker(mitk::SimpleBarrierConstraintChecker* pChecker,
                   const mitk::ModelTraitsInterface::ParameterNamesType& names);
 
   Qt::ItemFlags flags(const QModelIndex& index) const override;
   QVariant data(const QModelIndex& index, int role) const override;
   QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
   int rowCount(const QModelIndex& parent = QModelIndex()) const override;
   int columnCount(const QModelIndex& parent = QModelIndex()) const override;
   bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
 
   void addConstraint();
   void deleteConstraint(const QModelIndex& index);
 
   /**Indicates if the content of the model was modified since the data was set via setChecker()*/
   bool isModified();
 
 private:
   mitk::SimpleBarrierConstraintChecker::Pointer m_Checker;
   mitk::ModelTraitsInterface::ParameterNamesType m_ParameterNames;
 
   /** Indicates if the data of the model was modified, since the model was set. */
   bool m_modified;
 
 };
 
 #endif // QmitkSimpleBarrierModel_h
 
diff --git a/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierParametersDelegate.h b/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierParametersDelegate.h
index 98b00d49a1..3cf9c7da4f 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierParametersDelegate.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierParametersDelegate.h
@@ -1,53 +1,53 @@
 /*===================================================================
 
 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 QmitkSimpleBarrierParametersDelegate_h
 #define QmitkSimpleBarrierParametersDelegate_h
 
 
 /// Toolkit includes.
 #include <QStyledItemDelegate>
 
 #include "MitkModelFitUIExports.h"
 
 
 /** \class QmitkSimpleBarrierParametersDelegate
 \brief An item delegate for rendering and editing the parameters relevant for
 a barrier constraint. The delegate assumes the following: 1) if the data is requested with the
 edit role, it gets a string list of all possible options. 2) if the data is requested with the
 display role it gets only a list of all currently selected options.
 If the data is transfered back to the model it contains all selected parameter names in a string list.*/
 class MITKMODELFITUI_EXPORT QmitkSimpleBarrierParametersDelegate : public QStyledItemDelegate
 {
   Q_OBJECT
 
 public:
 
-  QmitkSimpleBarrierParametersDelegate(QObject* parent = 0);
+  QmitkSimpleBarrierParametersDelegate(QObject* parent = nullptr);
 
   void paint(QPainter* painter, const QStyleOptionViewItem& option
              , const QModelIndex& index) const override;
 
   QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option
                         , const QModelIndex& index) const override;
 
   void setEditorData(QWidget* editor, const QModelIndex& index) const override;
 
   void setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const override;
 
 };
 
 #endif
diff --git a/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierTypeDelegate.h b/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierTypeDelegate.h
index 92e8e5d5d8..84db92037c 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierTypeDelegate.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkSimpleBarrierTypeDelegate.h
@@ -1,45 +1,45 @@
 /*===================================================================
 
 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 QmitkSimpleBarrierTypeDelegate_h
 #define QmitkSimpleBarrierTypeDelegate_h
 
 
 #include <QStyledItemDelegate>
 
 #include "MitkModelFitUIExports.h"
 
 
 /** \class QmitkSimpleBarrierTypeDelegate
 \brief An item delegate for rendering and editing the type of a simple barrier constraint.
 It assumes that the type is encoded as int. 0: lower border, 1: upper border.*/
 class MITKMODELFITUI_EXPORT QmitkSimpleBarrierTypeDelegate : public QStyledItemDelegate
 {
   Q_OBJECT
 
 public:
 
-  QmitkSimpleBarrierTypeDelegate(QObject* parent = 0);
+  QmitkSimpleBarrierTypeDelegate(QObject* parent = nullptr);
 
   QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option
                         , const QModelIndex& index) const override;
 
   void setEditorData(QWidget* editor, const QModelIndex& index) const override;
 
   void setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const override;
 };
 
 #endif
diff --git a/Modules/Pharmacokinetics/include/mitkAterialInputFunctionGenerator.h b/Modules/Pharmacokinetics/include/mitkAterialInputFunctionGenerator.h
index e300b970ff..4e5fb41c3b 100644
--- a/Modules/Pharmacokinetics/include/mitkAterialInputFunctionGenerator.h
+++ b/Modules/Pharmacokinetics/include/mitkAterialInputFunctionGenerator.h
@@ -1,111 +1,111 @@
 /*===================================================================
 
  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 ATERIALINPUTFUNCTIONGENERATOR_H
 #define ATERIALINPUTFUNCTIONGENERATOR_H
 
 #include <mitkImage.h>
 #include "mitkAIFBasedModelBase.h"
 #include "MitkPharmacokineticsExports.h"
 
 
 namespace mitk
 {
   /** \class AterialInputFunctionGenerator
   * \brief Compute the Aterial Input Function from a given dynamic image and a mask defining the tumour supplying artery
   *
   * The AterialInputFunctionGenerator takes a given 4D dynamic image and a corresponding mask and returns an array of the averaged values and
   * an array of the corresponding TimeGrid
   * within the mask over time. No conversion is performed, so  conversion from signal to concentration has to be performed in advanced
   * and the resulting image is fed into the Generator.
   * The generator checks wether both image and mask  are set and passes them to the itkMaskedNaryStatisticsImageFilter and the mitkExtractTimeGrid, to
   * calculate the mean of every time slice within the ROI and extract the corresponding time grid from the date set.
   */
   class MITKPHARMACOKINETICS_EXPORT AterialInputFunctionGenerator : public itk::Object
   {
   public:
 
     mitkClassMacroItkParent(AterialInputFunctionGenerator, itk::Object);
     itkNewMacro(Self);
 
     /** @brief Setter and Getter for Input Image for calculation of AIF, already converted to concentrations
     * Getter calls CheckValidInputs() and CalculateAIFAndGetResult() if HasOutdatedResults() is true */
     itkSetConstObjectMacro(DynamicImage, Image);
     itkGetConstObjectMacro(DynamicImage, Image);
 
     /** @brief Setter and Getter for mask defining the tumour feeding atery
     * Getter calls CheckValidInputs() and CalculateAIFAndGetResult() if HasOutdatedResults() is true */
     itkSetConstObjectMacro(Mask, Image);
     itkGetConstObjectMacro(Mask, Image);
 
     /** @brief Setter and Getter for the hematocritlevel, important for conversion to plasma curve*/
     itkSetMacro(HCL, double);
     itkGetConstReferenceMacro(HCL, double);
 
     //Common Value for Hematocrit level is 0.45
     static const double DEFAULT_HEMATOCRIT_LEVEL;
 
     void SetDefaultHematocritLevel()
     {
         this->m_HCL = DEFAULT_HEMATOCRIT_LEVEL;
     };
     double GetDefaultHematocritLevel()
     {
         return DEFAULT_HEMATOCRIT_LEVEL;
     }
 
     AIFBasedModelBase::AterialInputFunctionType GetAterialInputFunction();
     ModelBase::TimeGridType GetAterialInputFunctionTimeGrid();
 
   protected:
     AterialInputFunctionGenerator()
     {
-      m_Mask = NULL;
-      m_DynamicImage = NULL;
+      m_Mask = nullptr;
+      m_DynamicImage = nullptr;
       this->SetDefaultHematocritLevel();
     };
 
     ~AterialInputFunctionGenerator() override {};
 
     //template <typename TPixel, unsigned int VDim>
     //void DoCalculateAIF(itk::Image<TPixel, VDim>* image);
 
     /** @brief Passes m_DynamicImage and m_Mask to the itkMaskedNaryStatisticsImageFilter and mitkExtractTimeGrid
      * and inserts the result into m_AIFValues and m_AIFTimeGrid and modiefies the Timestamp*/
     virtual void CalculateAIFAndGetResult();
 
     /** @brief Makes sure that m_DynamicImage and m_Mask are set */
     virtual void CheckValidInputs() const;
 
     bool HasOutdatedResults();
 
 
     itk::TimeStamp m_GenerationTimeStamp;
 
   private:
     Image::ConstPointer m_DynamicImage;
     Image::ConstPointer m_Mask;
 
 
     AIFBasedModelBase::AterialInputFunctionType m_AIFValues;
     ModelBase::TimeGridType m_AIFTimeGrid;
 
     double m_HCL;
   };
 
 }
 
 #endif // ATERIALINPUTFUNCTIONGENERATOR_H
diff --git a/Modules/Pharmacokinetics/include/mitkPixelBasedDescriptionParameterImageGenerator.h b/Modules/Pharmacokinetics/include/mitkPixelBasedDescriptionParameterImageGenerator.h
index 416fe3b98c..ea9f479fa4 100644
--- a/Modules/Pharmacokinetics/include/mitkPixelBasedDescriptionParameterImageGenerator.h
+++ b/Modules/Pharmacokinetics/include/mitkPixelBasedDescriptionParameterImageGenerator.h
@@ -1,104 +1,104 @@
 /*===================================================================
 
  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 __MITK_PIXEL_BASED_DESCRIPTION_PARAMETER_IMAGE_GENERATOR_H_
 #define __MITK_PIXEL_BASED_DESCRIPTION_PARAMETER_IMAGE_GENERATOR_H_
 
 #include <map>
 
 #include <mitkImage.h>
 
 #include "mitkCurveParameterFunctor.h"
 #include "mitkDescriptionParameterImageGeneratorBase.h"
 
 #include "MitkPharmacokineticsExports.h"
 
 namespace mitk
 {
 
   /** Class for generating curve descriptor images based on a given 4D mitk image.
    * The class uses curve parameter functor to generate the curve description image(s).
    * Depending on the chosen functor several images may be generated as output.
    * @remark This generator fits every pixel on its own. If you want to fit the mean value of the given mask use
    * ROIBasedDescriptionParameterImageGenerator.
    */
   class MITKPHARMACOKINETICS_EXPORT PixelBasedDescriptionParameterImageGenerator : public DescriptionParameterImageGeneratorBase
   {
   public:
     mitkClassMacro(PixelBasedDescriptionParameterImageGenerator, DescriptionParameterImageGeneratorBase);
 
     itkNewMacro(Self);
 
 
     typedef ScalarType ParameterImagePixelType;
     typedef std::vector<ParameterImagePixelType> FunctorValueArrayType;
 
     typedef CurveParameterFunctor FunctorType;
 
     typedef DescriptionParameterImageGeneratorBase::ParameterNameType ParameterNameType;
     typedef DescriptionParameterImageGeneratorBase::ParameterImageMapType ParameterImageMapType;
 
     itkSetObjectMacro(DynamicImage, Image);
     itkGetConstObjectMacro(DynamicImage, Image);
 
     itkSetObjectMacro(Mask, Image);
     itkGetConstObjectMacro(Mask, Image);
 
     itkSetObjectMacro(Functor, FunctorType);
     itkGetObjectMacro(Functor, FunctorType);
 
     double GetProgress() const override;
 
   protected:
     PixelBasedDescriptionParameterImageGenerator() : m_Progress(0)
     {
-      m_InternalMask = NULL;
-      m_Mask = NULL;
-      m_DynamicImage = NULL;
+      m_InternalMask = nullptr;
+      m_Mask = nullptr;
+      m_DynamicImage = nullptr;
     };
 
     ~PixelBasedDescriptionParameterImageGenerator() override {};
 
     template <typename TPixel, unsigned int VDim>
     void DoParameterCalculation(itk::Image<TPixel, VDim>* image);
 
     template <typename TPixel, unsigned int VDim>
     void DoPrepareMask(itk::Image<TPixel, VDim>* image);
 
     void onFitProgressEvent(::itk::Object* caller, const ::itk::EventObject& eventObject);
 
     bool HasOutdatedResult() const override;
     void CheckValidInputs() const override;
     void DoParameterCalculationAndGetResults(ParameterImageMapType& parameterImages) override;
 
   private:
     Image::Pointer m_DynamicImage;
     Image::Pointer m_Mask;
 
     typedef itk::Image<unsigned char, 3> InternalMaskType;
     InternalMaskType::Pointer m_InternalMask;
 
     FunctorType::Pointer m_Functor;
 
 
     ParameterImageMapType m_TempResultMap;
 
     double m_Progress;
   };
 
 }
 
 #endif // __MITK_PIXEL_BASED_DESCRIPTION_PARAMETER_IMAGE_GENERATOR_H_
diff --git a/Modules/Pharmacokinetics/src/Common/mitkPixelBasedDescriptionParameterImageGenerator.cpp b/Modules/Pharmacokinetics/src/Common/mitkPixelBasedDescriptionParameterImageGenerator.cpp
index c4f240d5c6..f8aed403d1 100644
--- a/Modules/Pharmacokinetics/src/Common/mitkPixelBasedDescriptionParameterImageGenerator.cpp
+++ b/Modules/Pharmacokinetics/src/Common/mitkPixelBasedDescriptionParameterImageGenerator.cpp
@@ -1,195 +1,195 @@
 /*===================================================================
 
 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 "itkCommand.h"
 #include "itkMultiOutputNaryFunctorImageFilter.h"
 
 #include "mitkPixelBasedDescriptionParameterImageGenerator.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include "mitkSimpleFunctorPolicy.h"
 #include "mitkModelBase.h"
 
 void
   mitk::PixelBasedDescriptionParameterImageGenerator::
   onFitProgressEvent(::itk::Object* caller, const ::itk::EventObject& /*eventObject*/)
 {
   this->InvokeEvent(::itk::ProgressEvent());
 
   itk::ProcessObject* process = dynamic_cast<itk::ProcessObject*>(caller);
   if (process)
   {
     this->m_Progress = process->GetProgress();
   }
 };
 
 template <typename TPixel, unsigned int VDim>
 void 
   mitk::PixelBasedDescriptionParameterImageGenerator::DoPrepareMask(itk::Image<TPixel, VDim>* image)
 {
   m_InternalMask = dynamic_cast<InternalMaskType*>(image);
 
   if (m_InternalMask.IsNull())
   {
     MITK_INFO << "Parameter Fit Generator. Need to cast mask for parameter fit.";
     typedef itk::Image<TPixel, VDim> InputImageType;
     typedef itk::CastImageFilter< InputImageType, InternalMaskType > CastFilterType;
     typename CastFilterType::Pointer  spImageCaster =  CastFilterType::New();
 
     spImageCaster->SetInput(image);
 
     m_InternalMask = spImageCaster->GetOutput();
     spImageCaster->Update();
   }
 }
 
 template<typename TImage>
 mitk::PixelBasedDescriptionParameterImageGenerator::ParameterImageMapType StoreResultImages(const mitk::CurveParameterFunctor::ParameterNamesType &paramNames, itk::ImageSource<TImage>* source)
 {
   if (source->GetNumberOfOutputs() != paramNames.size())
   {
     mitkThrow() << "Error while generating fitted parameter images. Number of sources does not match expected parameter number. Output size: " << source->GetNumberOfOutputs() << "; number of param names: " << paramNames.size();
   }
 
   mitk::PixelBasedDescriptionParameterImageGenerator::ParameterImageMapType result;
   for (mitk::CurveParameterFunctor::ParameterNamesType::size_type j = 0; j < paramNames.size(); ++j)
   {
     mitk::Image::Pointer paramImage = mitk::Image::New();
     typename TImage::ConstPointer outputImg = source->GetOutput(j);
     mitk::CastToMitkImage(outputImg, paramImage);
 
     result.insert(std::make_pair(paramNames[j],paramImage));
   }
 
   return result;
 }
 
 template <typename TPixel, unsigned int VDim>
 void 
   mitk::PixelBasedDescriptionParameterImageGenerator::DoParameterCalculation(itk::Image<TPixel, VDim>* /*image*/)
 {
   typedef itk::Image<TPixel, VDim-1> InputFrameImageType;
   typedef itk::Image<ScalarType, VDim-1> ParameterImageType;
 
   typedef itk::MultiOutputNaryFunctorImageFilter<InputFrameImageType, ParameterImageType, SimpleFunctorPolicy, InternalMaskType> DescriptorFilterType;
 
   typename DescriptorFilterType::Pointer descFilter = DescriptorFilterType::New();
 
   typename ::itk::MemberCommand<Self>::Pointer spProgressCommand = ::itk::MemberCommand<Self>::New();
   spProgressCommand->SetCallbackFunction(this, &Self::onFitProgressEvent);
   descFilter->AddObserver(::itk::ProgressEvent(), spProgressCommand);
 
   //add the time frames to the descriptor filter
   std::vector<Image::Pointer> frameCache;
   for (unsigned int i = 0; i < this->m_DynamicImage->GetTimeSteps(); ++i)
   {
     typename InputFrameImageType::Pointer frameImage;
     mitk::ImageTimeSelector::Pointer imageTimeSelector =	mitk::ImageTimeSelector::New();
     imageTimeSelector->SetInput(this->m_DynamicImage);
     imageTimeSelector->SetTimeNr(i);
     imageTimeSelector->UpdateLargestPossibleRegion();
 
     Image::Pointer frameMITKImage = imageTimeSelector->GetOutput();
     frameCache.push_back(frameMITKImage);
     mitk::CastToItkImage(frameMITKImage, frameImage);
     descFilter->SetInput(i,frameImage);
   }
 
 
   SimpleFunctorPolicy functor;
 
   functor.SetFunctor(this->m_Functor);
   descFilter->SetFunctor(functor);
   if (this->m_InternalMask.IsNotNull())
   {
     descFilter->SetMask(this->m_InternalMask);
   }
 
   //generate the fits
   descFilter->Update();
 
   //convert the outputs into mitk images and fill the parameter image map
   CurveParameterFunctor::ParameterNamesType paramNames = this->m_Functor->GetDescriptionParameterNames();
 
   if (descFilter->GetNumberOfOutputs() != (paramNames.size()))
   {
     mitkThrow() << "Error while generating fitted parameter images. Fit filter output size does not match expected parameter number. Output size: "<< descFilter->GetNumberOfOutputs();
   }
 
   this->m_TempResultMap = StoreResultImages<ParameterImageType>(paramNames,descFilter);
 }
 
 bool
   mitk::PixelBasedDescriptionParameterImageGenerator::HasOutdatedResult() const
 {
   bool result = Superclass::HasOutdatedResult();
 
   if (m_DynamicImage.IsNotNull())
   {
     if (m_DynamicImage->GetMTime() > this->m_GenerationTimeStamp)
     {
       result = true;
     }
   }
 
   if (m_Mask.IsNotNull())
   {
     if (m_Mask->GetMTime() > this->m_GenerationTimeStamp)
     {
       result = true;
     }
   }
 
   return result;
 
 };
 
 void
   mitk::PixelBasedDescriptionParameterImageGenerator::CheckValidInputs() const
 {
   Superclass::CheckValidInputs();
 
   if (m_DynamicImage.IsNull())
   {
     mitkThrow() << "Cannot generate fitted parameter images. Input dynamic image is not set.";
   }
 
 };
 
 void mitk::PixelBasedDescriptionParameterImageGenerator::DoParameterCalculationAndGetResults(ParameterImageMapType& parameterImages)
 {
   this->m_Progress = 0;
 
   if(this->m_Mask.IsNotNull())
   {
     AccessFixedDimensionByItk(m_Mask, mitk::PixelBasedDescriptionParameterImageGenerator::DoPrepareMask, 3);
   }
   else
   {
-    this->m_InternalMask = NULL;
+    this->m_InternalMask = nullptr;
   }
 
   AccessFixedDimensionByItk(m_DynamicImage, mitk::PixelBasedDescriptionParameterImageGenerator::DoParameterCalculation, 4);
 
   parameterImages = this->m_TempResultMap;
  };
 
 double
   mitk::PixelBasedDescriptionParameterImageGenerator::GetProgress() const
 {
   return m_Progress;
 };
diff --git a/Modules/Pharmacokinetics/src/Functors/mitkCurveParameterFunctor.cpp b/Modules/Pharmacokinetics/src/Functors/mitkCurveParameterFunctor.cpp
index af7f89376c..ea886097a2 100644
--- a/Modules/Pharmacokinetics/src/Functors/mitkCurveParameterFunctor.cpp
+++ b/Modules/Pharmacokinetics/src/Functors/mitkCurveParameterFunctor.cpp
@@ -1,141 +1,141 @@
 /*===================================================================
 
 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 "mitkCurveParameterFunctor.h"
 
 mitk::SimpleFunctorBase::OutputPixelVectorType
 mitk::CurveParameterFunctor::Compute(const mitk::SimpleFunctorBase::InputPixelVectorType& value)
 const
 {
   if (this->m_Grid.GetSize() == 0)
   {
     itkExceptionMacro("Error. Cannot compute Curve Description Parameters. No Curve Grid set!");
   }
 
   if (this->m_DescriptorMap.size() == 0)
   {
     itkGenericExceptionMacro( <<
                               "Error. Cannot compute Curve Description Parameters. No Parameters registered!");
   }
 
   CurveDescriptionParameterBase::CurveType sample(value.size());
 
   for (CurveDescriptionParameterBase::CurveType::SizeValueType i = 0; i < sample.Size(); ++i)
   {
     sample[i] = value [i];
   }
 
   mitk::SimpleFunctorBase::OutputPixelVectorType result;
   result.reserve(m_DescriptorMap.size()); //we will have at least this number of values
 
   unsigned int i = 0;
 
   for (DescriptionParameterMapType::const_iterator pos = m_DescriptorMap.begin();
        pos != m_DescriptorMap.end(); ++pos, ++i)
   {
     CurveDescriptionParameterBase* paramFct = const_cast<CurveDescriptionParameterBase*>
         (pos->second.GetPointer());
 
     CurveDescriptionParameterBase::DescriptionParameterResultsType fctResults =
       paramFct->GetCurveDescriptionParameter(sample, this->m_Grid);
     result.insert(result.end(), fctResults.begin(), fctResults.end());
   }
 
   if (this->GetDescriptionParameterNames().size() != result.size())
   {
     itkGenericExceptionMacro( <<
                               "Error. Curve parameter functor has an invalid state. Number of parameter names and number of computed values does not match. Names count: "
                               << this->GetDescriptionParameterNames().size() << "; value count: " << result.size());
   }
 
   return result;
 };
 
 unsigned int
 mitk::CurveParameterFunctor::GetNumberOfOutputs() const
 {
   return GetDescriptionParameterNames().size();
 };
 
 mitk::CurveParameterFunctor::GridArrayType
 mitk::CurveParameterFunctor::GetGrid() const
 {
   return m_Grid;
 };
 
 void
 mitk::CurveParameterFunctor::ResetDescriptionParameters()
 {
   m_DescriptorMap.clear();
 };
 
 void
 mitk::CurveParameterFunctor::RegisterDescriptionParameter(const std::string& parameterName,
     CurveDescriptionParameterBase* parameterFunction)
 {
   CurveDescriptionParameterBase::Pointer paramFunctPtr = parameterFunction;
 
   m_DescriptorMap.insert(std::make_pair(parameterName, paramFunctPtr));
 };
 
 mitk::CurveParameterFunctor::ParameterNamesType
 mitk::CurveParameterFunctor::GetDescriptionParameterNames() const
 {
   ParameterNamesType result;
 
   for (auto descriptor : m_DescriptorMap)
   {
     CurveDescriptionParameterBase::DescriptionParameterNamesType fctResults =
       descriptor.second->GetDescriptionParameterName();
 
     if (fctResults.size() > 1)
     {
       for (auto fctName : fctResults)
       {
         result.push_back(descriptor.first + "_" + fctName);
       }
     }
     else
     { //if the descriptor has only one parameter just use the registered descriptor name.
       result.push_back(descriptor.first);
     }
   }
 
   return result;
 };
 
 const mitk::CurveDescriptionParameterBase*
 mitk::CurveParameterFunctor::GetDescriptionParameterFunction(const std::string& parameterName) const
 {
-  const CurveDescriptionParameterBase* result = NULL;
+  const CurveDescriptionParameterBase* result = nullptr;
 
   DescriptionParameterMapType::const_iterator pos = m_DescriptorMap.find(parameterName);
 
   if (pos != m_DescriptorMap.end())
   {
     result = (pos->second).GetPointer();
   }
 
   return result;
 };
 
 mitk::CurveParameterFunctor::
 CurveParameterFunctor()
 {};
 
 mitk::CurveParameterFunctor::
 ~CurveParameterFunctor() {};
 
diff --git a/Modules/PharmacokineticsUI/Qmitk/QmitkDescriptionParameterBackgroundJob.h b/Modules/PharmacokineticsUI/Qmitk/QmitkDescriptionParameterBackgroundJob.h
index 263eba0ff0..b1e4c03e78 100644
--- a/Modules/PharmacokineticsUI/Qmitk/QmitkDescriptionParameterBackgroundJob.h
+++ b/Modules/PharmacokineticsUI/Qmitk/QmitkDescriptionParameterBackgroundJob.h
@@ -1,79 +1,79 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Software Development for
 Integrated Diagnostic and Therapy. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #ifndef __QMITK_DESCRIPTION_PARAMETER_BACKGROUND_JOB_H
 #define __QMITK_DESCRIPTION_PARAMETER_BACKGROUND_JOB_H
 
 
 //QT
 #include <QRunnable>
 #include <QObject>
 
 //MITK
 #include <mitkDataNode.h>
 
 #include <mitkDescriptionParameterImageGeneratorBase.h>
 #include <mitkModelFitResultHelper.h>
 #include <mitkModelFitInfo.h>
 
 // ITK
 #include <itkCommand.h>
 
 #include "MitkPharmacokineticsUIExports.h"
 
 class MITKPHARMACOKINETICSUI_EXPORT DescriptionParameterBackgroundJob : public QObject, public QRunnable
 {
     // this is needed for all Qt objects that should have a Qt meta-object
     // (everything that derives from QObject and wants to have signal/slots)
     Q_OBJECT
 
 public:
-  DescriptionParameterBackgroundJob(mitk::DescriptionParameterImageGeneratorBase* generator, mitk::DataNode* parentNode = NULL);
+  DescriptionParameterBackgroundJob(mitk::DescriptionParameterImageGeneratorBase* generator, mitk::DataNode* parentNode = nullptr);
     ~DescriptionParameterBackgroundJob() override;
 
 		void run() override;
 
     /**Returns the node (if defined), that is the parent object for the results of the job.
     May be null.*/
     mitk::DataNode* GetParentNode() const;
 
 signals:
     void Finished();
     void Error(QString err);
     void ResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType resultMap, const DescriptionParameterBackgroundJob* pJob);
     void JobProgress(double progress);
     void JobStatusChanged(QString info);
 
 protected:
   static mitk::modelFit::ModelFitResultNodeVectorType CreateResultNodes(const mitk::DescriptionParameterImageGeneratorBase::ParameterImageMapType& paramimages);
 
 	//Inputs
 	mitk::DescriptionParameterImageGeneratorBase::Pointer m_Generator;
   mitk::DataNode::Pointer m_ParentNode;
 
   // Results
   mitk::modelFit::ModelFitResultNodeVectorType m_Results;
 
   ::itk::MemberCommand<DescriptionParameterBackgroundJob>::Pointer m_spCommand;
   unsigned long m_ObserverID;
 
   void OnComputeEvent(::itk::Object *, const itk::EventObject &event);
 };
 
 #endif
 
diff --git a/Modules/QtPython/QmitkCtkPythonShell.h b/Modules/QtPython/QmitkCtkPythonShell.h
index 94e66d482d..9cba0db147 100644
--- a/Modules/QtPython/QmitkCtkPythonShell.h
+++ b/Modules/QtPython/QmitkCtkPythonShell.h
@@ -1,60 +1,60 @@
 /*===================================================================
 
 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 QmitkCtkPythonShell_h
 #define QmitkCtkPythonShell_h
 
 #include <ctkPythonConsole.h>
 #include <QString>
 #include <MitkQtPythonExports.h>
 
 ///
 /// forward declarations
 ///
 struct QmitkCtkPythonShellData;
 class ctkAbstractPythonManager;
 class QDragEnterEvent;
 class QDropEvent;
 class QMimeData;
 
 ///
 /// Reimplements the ctkPythonConsole with drag and drop functionality for text
 /// Furthermore it calls NotifyObserver() on the IPythonService to inform listeners
 ///
 class MITKQTPYTHON_EXPORT QmitkCtkPythonShell : public ctkPythonConsole
 {
   Q_OBJECT
 
 public:
-  QmitkCtkPythonShell(QWidget* parent = 0);
+  QmitkCtkPythonShell(QWidget* parent = nullptr);
   ~QmitkCtkPythonShell() override;
 public slots:
   void Paste( const QString& command );
 protected:
   void dragEnterEvent(QDragEnterEvent *event) override;
   void dropEvent(QDropEvent *event) override;
   bool canInsertFromMimeData( const QMimeData *source ) const;
   void executeCommand(const QString& command) override;
 
 private:
   QmitkCtkPythonShellData* d;
 };
 
 
 
 
 #endif // QmitkCtkPythonShell_h
 
diff --git a/Modules/QtPython/QmitkPythonSnippets.h b/Modules/QtPython/QmitkPythonSnippets.h
index 976df8fc7d..03621a9358 100644
--- a/Modules/QtPython/QmitkPythonSnippets.h
+++ b/Modules/QtPython/QmitkPythonSnippets.h
@@ -1,105 +1,105 @@
 /*===================================================================
 
 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 _QmitkPythonSnippets_H
 #define _QmitkPythonSnippets_H
 
 #include <QWidget>
 #include <QMap>
 #include <MitkQtPythonExports.h>
 struct QmitkPythonSnippetsData;
 
 ///
 /// a widget that holds snippets and serializes the snippets to a certain places
 class MITKQTPYTHON_EXPORT QmitkPythonSnippets: public QWidget
 {
   Q_OBJECT
 
   public:
     static const QString DEFAULT_SNIPPET_FILE;
     static const QString SNIPPETS_ROOT_XML_ELEMENT_NAME;
     static const QString SNIPPETS_XML_ELEMENT_NAME;
     ///
     /// typedef for string map
     typedef QMap<QString, QString> QStringMap;
     ///
     /// build ui here
     /// the snippets will be loaded from _AutoSaveFileName if not empty and readable
     /// otherwise the default snippets will be loaded
-    QmitkPythonSnippets( const QString& _AutoSaveFileName="", QWidget* parent=0 );
+    QmitkPythonSnippets( const QString& _AutoSaveFileName="", QWidget* parent=nullptr );
     ///
     /// delete d pointer
     ~QmitkPythonSnippets() override;
     ///
     /// read string map from xml file
     static bool LoadStringMap( const QString& filename, QStringMap& oldMap );
 
 signals:
     ///
     /// this class whishes to paste sth command
     void PasteCommandRequested(const QString& command);
 
   protected slots:
     ///
     /// emits PasteCommandRequested signal
     void on_PasteSnippet_triggered( bool checked = false );
     ///
     /// ask for name as long as it exists, call update()
     void on_RenameSnippet_triggered( bool checked = false );
     ///
     /// ask for name, create snippet, call update()
     void on_AddSnippet_triggered( bool checked = false );
     ///
     /// remove the current snippet, call update()
     void on_RemoveSnippet_triggered( bool checked = false );
     ///
     /// call LoadStringMap with d->m_DefaultSnippetsAutoSaveFileName
     void on_RestoreDefaultSnippets_triggered( bool checked = false );
     ///
     /// update action state (enable/disable), update text box
     void on_Name_currentIndexChanged( int i );
     ///
     /// save changed snippet
     void on_Content_textChanged();
     ///
     /// ask for file, save snippets
     void on_SaveSnippets_triggered( bool checked = false );
     ///
     /// ask for file, load snippets (do not replace)
     void on_LoadSnippets_triggered( bool checked = false );
 
   protected:
     ///
     /// write string map to xml file
     void SaveStringMap( const QString& filename, const QStringMap& map ) const;
     ///
     /// creates a name which does not exist in the list
     QString CreateUniqueName(const QString &name) const;
     ///
     /// update combo box
     /// if name is passed, the according element will be selected
     void Update(const QString &name = "");
   private:
     ///
     /// d pointer declaration (holds members)
     QmitkPythonSnippetsData* d;
 };
 
 
 
 
 #endif // _QmitkPythonSnippets_H_INCLUDED
 
diff --git a/Modules/QtPython/QmitkPythonTextEditor.h b/Modules/QtPython/QmitkPythonTextEditor.h
index 1cd44d02a6..db701f2c82 100644
--- a/Modules/QtPython/QmitkPythonTextEditor.h
+++ b/Modules/QtPython/QmitkPythonTextEditor.h
@@ -1,53 +1,53 @@
 /*===================================================================
 
 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 QMITKPYTHONTEXTEDITOR_H_
 #define QMITKPYTHONTEXTEDITOR_H_
 
 #include <QTextEdit>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <MitkQtPythonExports.h>
 struct QmitkPythonTextEditorData;
 
 ///
 /// this is a python text editor with syntax highlightning
 class MITKQTPYTHON_EXPORT QmitkPythonTextEditor : public QWidget
 {
   Q_OBJECT
 
 public:
-  QmitkPythonTextEditor(QWidget *parent = 0);
+  QmitkPythonTextEditor(QWidget *parent = nullptr);
   ~QmitkPythonTextEditor() override;
 public slots:
   void Paste(const QString& command);
 
 protected slots:
   void on_SaveScript_triggered(bool checked=false);
   void on_LoadScript_triggered(bool checked=false);
   void on_RunScript_triggered(bool checked=false);
 
 protected:
   void dragEnterEvent(QDragEnterEvent *event) override;
   void dropEvent(QDropEvent *event) override;
   //bool canInsertFromMimeData( const QMimeData *source ) const;
   QString ReadFile(const QString &filename);
 
 private:
   QmitkPythonTextEditorData* d;
 };
 
 #endif
diff --git a/Modules/QtPython/QmitkPythonVariableStackTableModel.cpp b/Modules/QtPython/QmitkPythonVariableStackTableModel.cpp
index 04c810e1ee..93d57881a4 100755
--- a/Modules/QtPython/QmitkPythonVariableStackTableModel.cpp
+++ b/Modules/QtPython/QmitkPythonVariableStackTableModel.cpp
@@ -1,225 +1,225 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkPythonVariableStackTableModel.h"
 #include <QMimeData>
 #include <usModuleContext.h>
 #include <mitkDataNode.h>
 #include <usGetModuleContext.h>
 #include <QStringList>
 #include <QMessageBox>
 #include "QmitkMimeTypes.h"
 
 const QString QmitkPythonVariableStackTableModel::MITK_IMAGE_VAR_NAME = "mitkImage";
 const QString QmitkPythonVariableStackTableModel::MITK_SURFACE_VAR_NAME = "mitkSurface";
 
 QmitkPythonVariableStackTableModel::QmitkPythonVariableStackTableModel(QObject *parent)
     :QAbstractTableModel(parent)
 {
     us::ModuleContext* context = us::GetModuleContext();
     m_PythonServiceRef = context->GetServiceReference<mitk::IPythonService>();
     m_PythonService = context->GetService<mitk::IPythonService>(m_PythonServiceRef);
     m_PythonService->AddPythonCommandObserver( this );
 }
 
 QmitkPythonVariableStackTableModel::~QmitkPythonVariableStackTableModel()
 {
   us::ModuleContext* context = us::GetModuleContext();
   context->UngetService( m_PythonServiceRef );
   m_PythonService->RemovePythonCommandObserver( this );
 }
 
 bool QmitkPythonVariableStackTableModel::dropMimeData(const QMimeData * data, Qt::DropAction action, int, int, const QModelIndex &)
 {
     // Early exit, returning true, but not actually doing anything (ignoring data).
     if (action == Qt::IgnoreAction)
         return true;
 
     // Note, we are returning true if we handled it, and false otherwise
     bool returnValue = false;
 
     if(data->hasFormat(QmitkMimeTypes::DataNodePtrs))
     {
         MITK_DEBUG("QmitkPythonVariableStackTableModel") << "dropped MITK DataNode";
         returnValue = true;
 
         int i = 0;
         QList<mitk::DataNode*> dataNodeList = QmitkMimeTypes::ToDataNodePtrList(data);
         mitk::DataNode* node = nullptr;
         foreach(node, dataNodeList)
         {
           mitk::Image* mitkImage = dynamic_cast<mitk::Image*>(node->GetData());
-          MITK_DEBUG("QmitkPythonVariableStackTableModel") << "mitkImage is not null " << (mitkImage != 0? "true": "false");
+          MITK_DEBUG("QmitkPythonVariableStackTableModel") << "mitkImage is not null " << (mitkImage != nullptr? "true": "false");
 
           QRegExp rx("^\\d");
           QString varName(node->GetName().c_str());
           // regex replace every character that is not allowed in a python variable
           varName = varName.replace(QRegExp("[.\\+\\-*\\s\\/\\n\\t\\r]"),QString("_"));
 
           if( mitkImage )
           {
             if ( varName.isEmpty() )
               varName = MITK_IMAGE_VAR_NAME;
             if ( rx.indexIn(varName) == 0)
               varName.prepend("_").prepend(MITK_IMAGE_VAR_NAME);
 
             if( i > 0 )
               varName = QString("%1%2").arg(varName).arg(i);
             MITK_DEBUG("QmitkPythonVariableStackTableModel") << "varName" << varName.toStdString();
 
             bool exportAsCvImage = mitkImage->GetDimension() == 2 && m_PythonService->IsOpenCvPythonWrappingAvailable();
 
             if( exportAsCvImage )
             {
               int ret = QMessageBox::question(nullptr, "Export option",
                 "2D image detected. Export as OpenCV image to Python instead of an SimpleITK image?",
                                               QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
               exportAsCvImage = ret == QMessageBox::Yes;
               if(exportAsCvImage)
               {
                 m_PythonService->CopyToPythonAsCvImage( mitkImage, varName.toStdString() );
                 ++i;
               }
             }
             if( !exportAsCvImage )
             {
               if( m_PythonService->IsSimpleItkPythonWrappingAvailable() )
               {
                 m_PythonService->CopyToPythonAsSimpleItkImage( mitkImage, varName.toStdString() );
                 ++i;
               }
               else
               {
                 MITK_ERROR << "SimpleITK Python wrapping not available. Skipping export for image " << node->GetName();
               }
             }
           }
           else
           {
             mitk::Surface* surface = dynamic_cast<mitk::Surface*>(node->GetData());
             MITK_DEBUG("QmitkPythonVariableStackTableModel") << "found surface";
 
             if( surface )
             {
               if (varName.isEmpty() )
                 varName =  MITK_SURFACE_VAR_NAME;
               if ( rx.indexIn(varName) == 0)
                 varName.prepend("_").prepend(MITK_SURFACE_VAR_NAME);
 
               MITK_DEBUG("QmitkPythonVariableStackTableModel") << "varName" << varName;
 
               if( m_PythonService->IsVtkPythonWrappingAvailable() )
               {
                 m_PythonService->CopyToPythonAsVtkPolyData( surface, varName.toStdString() );
               }
               else
               {
                 MITK_ERROR << "VTK Python wrapping not available. Skipping export for surface " << node->GetName();
               }
             }
           }
         }
     }
     return returnValue;
 }
 
 QVariant QmitkPythonVariableStackTableModel::headerData(int section, Qt::Orientation orientation,
                                                         int role) const
 {
     QVariant headerData;
 
     // show only horizontal header
     if ( role == Qt::DisplayRole )
     {
         if( orientation == Qt::Horizontal )
         {
             // first column: "Attribute"
             if(section == 0)
                 headerData = "Attribute";
             else if(section == 1)
                 headerData = "Type";
             else if(section == 2)
                 headerData = "Value";
         }
     }
 
     return headerData;
 }
 
 Qt::ItemFlags QmitkPythonVariableStackTableModel::flags(const QModelIndex &index) const
 {
     Qt::ItemFlags flags = QAbstractItemModel::flags(index);
 
     if(index.isValid())
         return Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | flags;
     else
         return Qt::ItemIsDropEnabled | flags;
 }
 
 int QmitkPythonVariableStackTableModel::rowCount(const QModelIndex &) const
 {
     return m_VariableStack.size();
 }
 
 int QmitkPythonVariableStackTableModel::columnCount(const QModelIndex &) const
 {
     return 3;
 }
 
 QVariant QmitkPythonVariableStackTableModel::data(const QModelIndex &index, int role) const
 {
     if (index.isValid() && !m_VariableStack.empty())
     {
         if(role == Qt::DisplayRole)
         {
             mitk::PythonVariable item = m_VariableStack.at(index.row());
             if(index.column() == 0)
               return QString::fromStdString(item.m_Name);
             if(index.column() == 1)
                 return QString::fromStdString(item.m_Type);
             if(index.column() == 2)
                 return QString::fromStdString(item.m_Value);
         }
     }
     return QVariant();
 }
 
 QStringList QmitkPythonVariableStackTableModel::mimeTypes() const
 {
     return QAbstractTableModel::mimeTypes();
     QStringList types;
     types << "application/x-mitk-datanodes";
     types << "application/x-qabstractitemmodeldatalist";
     return types;
 }
 
 Qt::DropActions QmitkPythonVariableStackTableModel::supportedDropActions() const
 {
     return Qt::CopyAction | Qt::MoveAction;
 }
 
 void QmitkPythonVariableStackTableModel::CommandExecuted(const std::string& pythonCommand)
 {
   MITK_DEBUG("QmitkPythonVariableStackTableModel") << "command was executed " << pythonCommand;
     m_VariableStack = m_PythonService->GetVariableStack();
     QAbstractTableModel::beginResetModel();
     QAbstractTableModel::endResetModel();
 }
 
 std::vector<mitk::PythonVariable> QmitkPythonVariableStackTableModel::GetVariableStack() const
 {
     return m_VariableStack;
 }
diff --git a/Modules/QtPython/QmitkPythonVariableStackTableModel.h b/Modules/QtPython/QmitkPythonVariableStackTableModel.h
index 03f0379a52..cbcd798f70 100755
--- a/Modules/QtPython/QmitkPythonVariableStackTableModel.h
+++ b/Modules/QtPython/QmitkPythonVariableStackTableModel.h
@@ -1,63 +1,63 @@
 /*===================================================================
 
 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 QmitkPythonVariableStackTableModel_h
 #define QmitkPythonVariableStackTableModel_h
 
 #include <QAbstractTableModel>
 #include <QVariant>
 #include <QModelIndex>
 #include "mitkIPythonService.h"
 #include <MitkQtPythonExports.h>
 #include <usServiceReference.h>
 
 ///
 /// implements a table model to show the variables of the Python "__main__" dictionary
 /// furthermore implements dragging and dropping of datanodes (conversion from and to python)
 ///
 class MITKQTPYTHON_EXPORT QmitkPythonVariableStackTableModel : public QAbstractTableModel, public mitk::PythonCommandObserver
 {
   Q_OBJECT
 
 public:
   static const QString MITK_IMAGE_VAR_NAME;
   static const QString MITK_SURFACE_VAR_NAME;
 
-  QmitkPythonVariableStackTableModel(QObject *parent = 0);
+  QmitkPythonVariableStackTableModel(QObject *parent = nullptr);
   ~QmitkPythonVariableStackTableModel() override;
 
   int rowCount(const QModelIndex &parent = QModelIndex()) const override;
   int columnCount(const QModelIndex &parent = QModelIndex()) const override;
   QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
   Qt::ItemFlags flags( const QModelIndex& index ) const override;
   QVariant headerData(int section, Qt::Orientation orientation,
                               int role) const override;
 
   QStringList mimeTypes() const override;
   bool dropMimeData ( const QMimeData *, Qt::DropAction, int, int, const QModelIndex & ) override;
   Qt::DropActions supportedDropActions() const override;
   //Qt::DropActions supportedDragActions() const;
 
   void CommandExecuted(const std::string& pythonCommand) override;
 
   std::vector<mitk::PythonVariable> GetVariableStack() const;
 private:
   std::vector<mitk::PythonVariable> m_VariableStack;
   mitk::IPythonService* m_PythonService;
   us::ServiceReference<mitk::IPythonService> m_PythonServiceRef;
 };
 
 #endif // QmitkPythonVariableStackTableModel_h
diff --git a/Modules/QtPython/QmitkPythonVariableStackTableView.cpp b/Modules/QtPython/QmitkPythonVariableStackTableView.cpp
index 8529a0ca64..768b03ab7d 100755
--- a/Modules/QtPython/QmitkPythonVariableStackTableView.cpp
+++ b/Modules/QtPython/QmitkPythonVariableStackTableView.cpp
@@ -1,116 +1,116 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkPythonVariableStackTableView.h"
 #include <usModuleContext.h>
 #include <usServiceReference.h>
 #include <usGetModuleContext.h>
 #include <mitkRenderingManager.h>
 #include <mitkSurface.h>
 #include <vtkPolyData.h>
 
 QmitkPythonVariableStackTableView::QmitkPythonVariableStackTableView(QWidget *parent)
     :QTableView(parent)
 {
     m_TableModel = new QmitkPythonVariableStackTableModel(parent);
     m_TableModel->CommandExecuted("");
 
     this->setSelectionBehavior( QAbstractItemView::SelectRows );
     this->setAlternatingRowColors(true);
     this->setDropIndicatorShown(true);
     this->setAcceptDrops(true);
     this->setModel( m_TableModel );
 
     us::ModuleContext* context = us::GetModuleContext();
     us::ServiceReference<mitk::IPythonService> serviceRef = context->GetServiceReference<mitk::IPythonService>();
     m_PythonService = context->GetService<mitk::IPythonService>(serviceRef);
 
     connect( this, SIGNAL(doubleClicked ( const QModelIndex& )), this, SLOT( OnVariableStackDoubleClicked(const QModelIndex&) ) );
 }
 
 QmitkPythonVariableStackTableView::~QmitkPythonVariableStackTableView()
 {
 }
 
 void QmitkPythonVariableStackTableView::SetDataStorage(mitk::DataStorage *_DataStorage)
 {
     m_DataStorage = _DataStorage;
 }
 
 void QmitkPythonVariableStackTableView::OnVariableStackDoubleClicked(const QModelIndex &index)
 {
-    if( m_DataStorage.IsNull() || m_PythonService == 0 )
+    if( m_DataStorage.IsNull() || m_PythonService == nullptr )
     {
         MITK_ERROR << "QmitkPythonVariableStackTableView not configured correctly. Quit";
         return;
     }
 
     int row = index.row();
     std::vector<mitk::PythonVariable> variableStack = m_TableModel->GetVariableStack();
     {
       MITK_DEBUG("QmitkPythonVariableStackTableView") << "row " << row;
       MITK_DEBUG("QmitkPythonVariableStackTableView") << "variableStack.size(): " << variableStack.size();
     }
 
     QString varName = QString::fromStdString( variableStack.at(row).m_Name );
     QString type = QString::fromStdString( variableStack.at(row).m_Type );
     QString value = QString::fromStdString( variableStack.at(row).m_Value );
 
     {
       MITK_DEBUG("QmitkPythonVariableStackTableView") << "varName: " << varName.toStdString();
       MITK_DEBUG("QmitkPythonVariableStackTableView") << "type: " << type.toStdString();
     }
 
     mitk::Image::Pointer mitkImage;
     mitk::Surface::Pointer mitkSurface;
 
     if( type.startsWith("Image") )
     {
       mitkImage = m_PythonService->CopySimpleItkImageFromPython(varName.toStdString());
     }
     else if( type.startsWith("numpy.ndarray") )
     {
       mitkImage = m_PythonService->CopyCvImageFromPython(varName.toStdString());
     }
     else if( value.startsWith("(vtkCommonDataModelPython.vtkPolyData)") )
     {
       mitkSurface = m_PythonService->CopyVtkPolyDataFromPython(varName.toStdString());
     }
 
     std::string nodeName = varName.toStdString();
     mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode(nodeName);
 
     // only create data node if it does not exist
     if ( node.IsNull() )
     {
       node = mitk::DataNode::New();
       node->SetName ( nodeName );
       m_DataStorage->Add(node);
     }
 
     if( mitkImage.IsNotNull() )
     {
       node->SetData( mitkImage );
     }
     else if( mitkSurface.IsNotNull() )
     {
       node->SetData( mitkSurface );
       // init renderwindow geometry
       mitk::RenderingManager::GetInstance()->InitializeViews(mitkSurface->GetGeometry());
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
diff --git a/Modules/QtPython/QmitkPythonVariableStackTableView.h b/Modules/QtPython/QmitkPythonVariableStackTableView.h
index 018abeef54..96596fc924 100755
--- a/Modules/QtPython/QmitkPythonVariableStackTableView.h
+++ b/Modules/QtPython/QmitkPythonVariableStackTableView.h
@@ -1,50 +1,50 @@
 /*===================================================================
 
 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 QmitkPythonVariableStackTableView_h
 #define QmitkPythonVariableStackTableView_h
 
 #include <QTableView>
 #include <mitkDataStorage.h>
 #include "QmitkPythonVariableStackTableModel.h"
 #include <mitkIPythonService.h>
 #include <MitkQtPythonExports.h>
 
 ///
 /// implements the table view for the variable stack
 /// purpose of this class: 1. Setup the view correctly, 2. Implement the double click to write back results
 /// to the datastorage
 ///
 class MITKQTPYTHON_EXPORT QmitkPythonVariableStackTableView : public QTableView
 {
   Q_OBJECT
 
 public:
-  QmitkPythonVariableStackTableView(QWidget *parent = 0);
+  QmitkPythonVariableStackTableView(QWidget *parent = nullptr);
   ~QmitkPythonVariableStackTableView() override;
 
   void SetDataStorage(mitk::DataStorage* _DataStorage);
 
 protected slots:
   void OnVariableStackDoubleClicked(const QModelIndex &index);
 
 private:
   QmitkPythonVariableStackTableModel* m_TableModel;
   mitk::DataStorage::Pointer m_DataStorage;
   mitk::IPythonService* m_PythonService;
 };
 
 #endif // QmitkPythonVariableStackTableView_h
diff --git a/Modules/QtWidgets/include/QmitkDataStorageTreeModelInternalItem.h b/Modules/QtWidgets/include/QmitkDataStorageTreeModelInternalItem.h
index 0fa945b1ea..9590cac01a 100644
--- a/Modules/QtWidgets/include/QmitkDataStorageTreeModelInternalItem.h
+++ b/Modules/QtWidgets/include/QmitkDataStorageTreeModelInternalItem.h
@@ -1,101 +1,101 @@
 /*===================================================================
 
 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 QMITKDATASTORAGETREEMODELINTERNALITEM_H_
 #define QMITKDATASTORAGETREEMODELINTERNALITEM_H_
 
 #include <MitkQtWidgetsExports.h>
 
 #include <mitkDataNode.h>
 
 #include <string>
 #include <vector>
 
   ///
   /// Helper class to represent a tree structure of DataNodes
   ///
   class MITKQTWIDGETS_EXPORT QmitkDataStorageTreeModelInternalItem
   {
   public:
     ///
     /// Constructs a new QmitkDataStorageTreeModelInternalItem with the given DataNode (must not be 0)
     ///
-    QmitkDataStorageTreeModelInternalItem(mitk::DataNode *_DataNode, QmitkDataStorageTreeModelInternalItem *_Parent = 0);
+    QmitkDataStorageTreeModelInternalItem(mitk::DataNode *_DataNode, QmitkDataStorageTreeModelInternalItem *_Parent = nullptr);
     ///
     /// Removes itself as child from its parent-> Does not delete its children
     /// \sa Delete()
     ///
     virtual ~QmitkDataStorageTreeModelInternalItem();
     ///
     /// Find the index of an item
     ///
     int IndexOfChild(const QmitkDataStorageTreeModelInternalItem *item) const;
     ///
     /// \return The child at pos index or 0 if it not exists
     ///
     QmitkDataStorageTreeModelInternalItem *GetChild(int index) const;
     ///
     /// Find the QmitkDataStorageTreeModelInternalItem containing a special tree node (recursive tree function)
     ///
     QmitkDataStorageTreeModelInternalItem *Find(const mitk::DataNode *_DataNode) const;
     ///
     /// Get the amount of children
     ///
     int GetChildCount() const;
     ///
     /// \return the index of this node in its parent list
     ///
     int GetIndex() const;
     ///
     /// \return the parent of this tree item
     ///
     QmitkDataStorageTreeModelInternalItem *GetParent() const;
     ///
     /// Return the DataNode associated with this node
     ///
     mitk::DataNode::Pointer GetDataNode() const;
     ///
     /// Get all children as vector
     ///
     std::vector<QmitkDataStorageTreeModelInternalItem *> GetChildren() const;
 
     ///
     /// add another item as a child of this (only if not already in that list)
     ///
     void AddChild(QmitkDataStorageTreeModelInternalItem *item);
     ///
     /// remove another item as child from this
     ///
     void RemoveChild(QmitkDataStorageTreeModelInternalItem *item);
     ///
     /// inserts a child at the given position. if pos is not in range
     /// the element is added at the end
     ///
     void InsertChild(QmitkDataStorageTreeModelInternalItem *item, int index = -1);
     /// Sets the parent on the QmitkDataStorageTreeModelInternalItem
     void SetParent(QmitkDataStorageTreeModelInternalItem *_Parent);
     ///
     /// Deletes the whole tree branch
     ///
     void Delete();
 
   protected:
     QmitkDataStorageTreeModelInternalItem *m_Parent;
     std::vector<QmitkDataStorageTreeModelInternalItem *> m_Children;
     mitk::WeakPointer<mitk::DataNode> m_DataNode;
   };
 
 #endif /* QMITKDATASTORAGETREEMODEL_H_ */
diff --git a/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h b/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h
index 65b46e63cf..8541f0cb2b 100644
--- a/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h
+++ b/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h
@@ -1,58 +1,58 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 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 QMITKMULTIWIDGETLAYOUTSELECTIONWIDGET_H
 #define QMITKMULTIWIDGETLAYOUTSELECTIONWIDGET_H
 
 #include "MitkQtWidgetsExports.h"
 
 #include "ui_QmitkMultiWidgetLayoutSelectionWidget.h"
 
 // qt
 #include "QWidget"
 
 /**
 * @brief 
 *
 *
 */
 class MITKQTWIDGETS_EXPORT QmitkMultiWidgetLayoutSelectionWidget : public QWidget
 {
   Q_OBJECT
 
 public:
 
-  QmitkMultiWidgetLayoutSelectionWidget(QWidget* parent = 0);
+  QmitkMultiWidgetLayoutSelectionWidget(QWidget* parent = nullptr);
 
 Q_SIGNALS:
 
   void LayoutSet(int row, int column);
 
 private Q_SLOTS:
 
   void OnTableItemSelectionChanged();
   void OnSetLayoutButtonClicked();
 
 private:
 
   void Init();
 
 
   Ui::QmitkMultiWidgetLayoutSelectionWidget ui;
 
 };
 
 #endif // QMITKMULTIWIDGETLAYOUTSELECTIONWIDGET_H
diff --git a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
index 4b0de0fed0..8b9f7ecd3b 100644
--- a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
@@ -1,154 +1,154 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 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 QMITKMXNMULTIWIDGET_H
 #define QMITKMXNMULTIWIDGET_H
 
 // qt widgets module
 #include "MitkQtWidgetsExports.h"
 #include "QmitkRenderWindowWidget.h"
 
 // mitk core
 #include <mitkBaseRenderer.h>
 #include <mitkDataStorage.h>
 #include <mitkDisplayActionEventBroadcast.h>
 #include <mitkDisplayActionEventHandler.h>
 #include <mitkInteractionSchemeSwitcher.h>
 
 // qt
 #include <QWidget>
 
 class QHBoxLayout;
 class QVBoxLayout;
 class QGridLayout;
 class QSpacerItem;
 class QmitkRenderWindow;
 
 namespace mitk
 {
   class RenderingManager;
 }
 
 /**
 * @brief The 'QmitkMxNMultiWidget' is a QWidget that is used to display multiple render windows at once.
 *        Render windows can dynamically be added and removed to change the layout of the multi widget. This
 *        is done by using the 'ResetLayout'-function to define a layout. This will automatically add or remove
 *        the appropriate number of render window widgets.
 *        Several functions exist to retrieve specific render window(s) (widgets) by their position or name.
 *
 *        The class uses the 'DisplayActionEventBroadcast' and 'DisplayActionEventHandler' classes to
 *        load a state machine and set an event configuration. PACS mode is used per default.
 *        Using the 'Synchronize' function the user can enable or disable the synchronization of display action events.
 *        See 'DisplayActionEventFunctions'-class for the different synchronized and non-synchronized functions used.
 */
 class MITKQTWIDGETS_EXPORT QmitkMxNMultiWidget : public QWidget
 {
   Q_OBJECT
 
 public:
 
   using RenderWindowWidgetPointer = std::shared_ptr<QmitkRenderWindowWidget>;
   using RenderWindowWidgetMap = std::map<QString, std::shared_ptr<QmitkRenderWindowWidget>>;
   using RenderWindowHash = QHash<QString, QmitkRenderWindow*>;
 
-  QmitkMxNMultiWidget(QWidget* parent = 0,
-                         Qt::WindowFlags f = 0,
+  QmitkMxNMultiWidget(QWidget* parent = nullptr,
+                         Qt::WindowFlags f = nullptr,
                          mitk::RenderingManager* renderingManager = nullptr,
                          mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard,
                          const QString& multiWidgetName = "mxnmulti");
 
   ~QmitkMxNMultiWidget() override = default;
   
   void SetDataStorage(mitk::DataStorage* dataStorage);
   void InitializeRenderWindowWidgets();
 
   mitk::InteractionEventHandler::Pointer GetInteractionEventHandler() { return m_DisplayActionEventBroadcast.GetPointer(); };
 
   void ResetLayout(int row, int column);
   void Synchronize(bool synchronized);
   void SetInteractionScheme(mitk::InteractionSchemeSwitcher::InteractionScheme scheme);
 
   RenderWindowWidgetMap GetRenderWindowWidgets() const;
   RenderWindowWidgetPointer GetRenderWindowWidget(int row, int column) const;
   RenderWindowWidgetPointer GetRenderWindowWidget(const QString& widgetName) const;
   RenderWindowHash GetRenderWindows() const;
   QmitkRenderWindow* GetRenderWindow(int row, int column) const;
   QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const;
 
   void SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget);
   RenderWindowWidgetPointer GetActiveRenderWindowWidget() const;
   RenderWindowWidgetPointer GetFirstRenderWindowWidget() const;
   RenderWindowWidgetPointer GetLastRenderWindowWidget() const;
   
   unsigned int GetNumberOfRenderWindowWidgets() const;
 
   void RequestUpdate(const QString& widgetName);
   void RequestUpdateAll();
   void ForceImmediateUpdate(const QString& widgetName);
   void ForceImmediateUpdateAll();
 
   void ActivateAllCrosshairs(bool activate);
   const mitk::Point3D GetSelectedPosition(const QString& widgetName) const;
 
 public Q_SLOTS:
 
   void SetSelectedPosition(const QString& widgetName, const mitk::Point3D& newPosition);
 
   // mouse events
   void wheelEvent(QWheelEvent* e) override;
 
   void mousePressEvent(QMouseEvent* e) override;
 
   void moveEvent(QMoveEvent* e) override;
 
 Q_SIGNALS:
 
   void WheelMoved(QWheelEvent *);
   void Moved();
 
 private:
 
   void InitializeGUI();
   void InitializeDisplayActionEventHandling();
 
   void CreateRenderWindowWidget();
   void DestroyRenderWindowWidget();
   void FillMultiWidgetLayout();
 
   QString GetNameFromIndex(int row, int column) const;
   QString GetNameFromIndex(size_t index) const;
 
   QGridLayout* m_MxNMultiWidgetLayout;
   RenderWindowWidgetMap m_RenderWindowWidgets;
 
   RenderWindowWidgetPointer m_ActiveRenderWindowWidget;
 
   int m_MultiWidgetRows;
   int m_MultiWidgetColumns;
 
   int m_PlaneMode;
 
   mitk::RenderingManager* m_RenderingManager;
   mitk::BaseRenderer::RenderingMode::Type m_RenderingMode;
   QString m_MultiWidgetName;
 
   mitk::DisplayActionEventBroadcast::Pointer m_DisplayActionEventBroadcast;
   std::unique_ptr<mitk::DisplayActionEventHandler> m_DisplayActionEventHandler;
 
   mitk::DataStorage::Pointer m_DataStorage;
 };
 
 #endif // QMITKMXNMULTIWIDGET_H
diff --git a/Modules/QtWidgets/src/QmitkDataStorageSimpleTreeModel.cpp b/Modules/QtWidgets/src/QmitkDataStorageSimpleTreeModel.cpp
index 0189f5df4d..52ed2575cf 100644
--- a/Modules/QtWidgets/src/QmitkDataStorageSimpleTreeModel.cpp
+++ b/Modules/QtWidgets/src/QmitkDataStorageSimpleTreeModel.cpp
@@ -1,370 +1,370 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 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 <QmitkDataStorageSimpleTreeModel.h>
 #include <QmitkDataStorageTreeModelInternalItem.h>
 #include <QmitkNodeDescriptorManager.h>
 
 // qt widgets module
 #include "QmitkCustomVariants.h"
 #include "QmitkEnums.h"
 
 QmitkDataStorageSimpleTreeModel::QmitkDataStorageSimpleTreeModel(QObject *parent)
   : QmitkAbstractDataStorageModel(parent), m_Root(nullptr)
 {
   ResetTree();
 }
 
 QmitkDataStorageSimpleTreeModel::~QmitkDataStorageSimpleTreeModel()
 {
   m_Root->Delete();
   m_Root = nullptr;
 };
 
 void QmitkDataStorageSimpleTreeModel::ResetTree()
 {
   mitk::DataNode::Pointer rootDataNode = mitk::DataNode::New();
   rootDataNode->SetName("Data Storage");
-  m_Root = new TreeItem(rootDataNode, 0);
+  m_Root = new TreeItem(rootDataNode, nullptr);
 }
 
 void QmitkDataStorageSimpleTreeModel::DataStorageChanged()
 {
   if (m_Root)
   {
     m_Root->Delete();
   }
 
   ResetTree();
   UpdateModelData();
 }
 
 void QmitkDataStorageSimpleTreeModel::NodePredicateChanged()
 {
   ResetTree();
   UpdateModelData();
 }
 
 void QmitkDataStorageSimpleTreeModel::NodeAdded(const mitk::DataNode *node)
 {
   if (node == nullptr || m_DataStorage.IsExpired() || !m_DataStorage.Lock()->Exists(node) ||
       m_Root->Find(node) != nullptr)
     return;
 
   this->AddNodeInternal(node);
 }
 
 void QmitkDataStorageSimpleTreeModel::NodeChanged(const mitk::DataNode *node)
 {
   TreeItem *treeItem = m_Root->Find(node);
   if (treeItem)
   {
     TreeItem *parentTreeItem = treeItem->GetParent();
     // as the root node should not be removed one should always have a parent item
     if (!parentTreeItem)
       return;
     QModelIndex index = this->createIndex(treeItem->GetIndex(), 0, treeItem);
 
     // now emit the dataChanged signal
     emit dataChanged(index, index);
   }
 }
 
 void QmitkDataStorageSimpleTreeModel::NodeRemoved(const mitk::DataNode *node)
 {
   if (node == nullptr || !m_Root)
     return;
 
   TreeItem *treeItem = m_Root->Find(node);
   if (!treeItem)
     return; // return because there is no treeitem containing this node
 
   TreeItem *parentTreeItem = treeItem->GetParent();
   QModelIndex parentIndex = this->IndexFromTreeItem(parentTreeItem);
 
   // emit beginRemoveRows event (QModelIndex is empty because we dont have a tree model)
   this->beginRemoveRows(parentIndex, treeItem->GetIndex(), treeItem->GetIndex());
 
   // remove node
   std::vector<TreeItem *> children = treeItem->GetChildren();
   m_TreeItems.remove(treeItem);
   delete treeItem; //delete in tree
 
   if (!children.empty())
   {
     //if not empty we have to rebuild the whole representation,
     //because the children could be now top level, or at another
     //source/parent.
     this->UpdateModelData();
   }
 }
 
 QModelIndex QmitkDataStorageSimpleTreeModel::index(int row, int column, const QModelIndex &parent) const
 {
   TreeItem *parentItem;
 
   if (!parent.isValid() || parent.model() != this)
     parentItem = m_Root;
   else
     parentItem = static_cast<TreeItem *>(parent.internalPointer());
 
   if (parentItem)
   {
     TreeItem *childItem = parentItem->GetChild(row);
     if (childItem)
       return createIndex(row, column, childItem);
   }
 
   return QModelIndex();
 }
 
 QModelIndex QmitkDataStorageSimpleTreeModel::parent(const QModelIndex &child) const
 {
   if (!child.isValid() || !m_Root || child.model() != this)
     return QModelIndex();
 
   TreeItem *childItem = this->TreeItemFromIndex(child);
 
   if (!childItem)
     return QModelIndex();
 
   TreeItem *parentItem = childItem->GetParent();
 
   if (parentItem == m_Root)
     return QModelIndex();
 
   return this->createIndex(parentItem->GetIndex(), 0, parentItem);
 }
 
 QmitkDataStorageSimpleTreeModel::TreeItem *QmitkDataStorageSimpleTreeModel::TreeItemFromIndex(
   const QModelIndex &index) const
 {
   if (index.isValid() && index.model() == this)
   {
     auto item = static_cast<TreeItem *>(index.internalPointer());
     auto finding = std::find(std::begin(m_TreeItems), std::end(m_TreeItems), item);
     if (finding == std::end(m_TreeItems))
     {
       return nullptr;
     }
     return item;
   }    
   else
     return m_Root;
 }
 
 int QmitkDataStorageSimpleTreeModel::rowCount(const QModelIndex &parent) const
 {
   TreeItem *parentTreeItem = this->TreeItemFromIndex(parent);
   if (parentTreeItem)
     return parentTreeItem->GetChildCount();
   else
     return 0;
 }
 
 int QmitkDataStorageSimpleTreeModel::columnCount(const QModelIndex &/*parent*/) const
 {
   return 1;
 }
 
 QVariant QmitkDataStorageSimpleTreeModel::data(const QModelIndex &index, int role) const
 {
   if (!index.isValid() || index.model() != this)
   {
     return QVariant();
   }
 
   auto treeItem = this->TreeItemFromIndex(index);
   if (!treeItem)
     return QVariant();
 
   mitk::DataNode *dataNode = treeItem->GetDataNode();
 
   QString nodeName = QString::fromStdString(dataNode->GetName());
   if (nodeName.isEmpty())
   {
     nodeName = "unnamed";
   }
 
   if (role == Qt::DisplayRole)
     return nodeName;
   else if (role == Qt::ToolTipRole)
     return nodeName;
   else if (role == Qt::DecorationRole)
   {
     QmitkNodeDescriptor *nodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(dataNode);
     return nodeDescriptor->GetIcon(dataNode);
   }
   else if (role == QmitkDataNodeRole)
   {
     return QVariant::fromValue<mitk::DataNode::Pointer>(mitk::DataNode::Pointer(dataNode));
   }
   else if (role == QmitkDataNodeRawPointerRole)
   {
     return QVariant::fromValue<mitk::DataNode *>(dataNode);
   }
 
   return QVariant();
 }
 
 bool QmitkDataStorageSimpleTreeModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
   if (!index.isValid() || index.model() != this)
     return false;
 
   auto treeItem = this->TreeItemFromIndex(index);
   if (!treeItem)
     return false;
 
   mitk::DataNode *dataNode = treeItem->GetDataNode();
   if (!dataNode)
     return false;
 
   if (role == Qt::EditRole && !value.toString().isEmpty())
   {
     dataNode->SetName(value.toString().toStdString().c_str());
   }
   else if (role == Qt::CheckStateRole)
   {
     // Please note: value.toInt() returns 2, independentely from the actual checkstate of the index element.
     // Therefore the checkstate is being estimated again here.
 
     QVariant qcheckstate = index.data(Qt::CheckStateRole);
     int checkstate = qcheckstate.toInt();
     bool isVisible = bool(checkstate);
     dataNode->SetVisibility(!isVisible);
   }
   // inform listeners about changes
   emit dataChanged(index, index);
   return true;
 }
 
 QVariant QmitkDataStorageSimpleTreeModel::headerData(int /*section*/, Qt::Orientation orientation, int role) const
 {
   if (orientation == Qt::Horizontal && role == Qt::DisplayRole && m_Root)
     return QString::fromStdString(m_Root->GetDataNode()->GetName());
 
   return QVariant();
 }
 
 Qt::ItemFlags QmitkDataStorageSimpleTreeModel::flags(const QModelIndex &index) const
 {
   if (index.isValid() && index.model() == this)
   {
     auto treeItem = this->TreeItemFromIndex(index);
     if (!treeItem)
       return Qt::NoItemFlags;
 
     const auto dataNode = treeItem->GetDataNode();
     if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(dataNode))
     {
       return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable;
     }
     else
     {
       return Qt::NoItemFlags;
     }
 
   }
 
   return Qt::NoItemFlags;
 }
 
 mitk::DataNode *QmitkDataStorageSimpleTreeModel::GetParentNode(const mitk::DataNode *node) const
 {
   mitk::DataNode *dataNode = nullptr;
 
   mitk::DataStorage::SetOfObjects::ConstPointer _Sources = m_DataStorage.Lock()->GetSources(node);
 
   if (_Sources->Size() > 0)
     dataNode = _Sources->front();
 
   return dataNode;
 }
 
 void QmitkDataStorageSimpleTreeModel::AddNodeInternal(const mitk::DataNode *node)
 {
-  if (node == nullptr || m_DataStorage.IsExpired() || !m_DataStorage.Lock()->Exists(node) || m_Root->Find(node) != 0)
+  if (node == nullptr || m_DataStorage.IsExpired() || !m_DataStorage.Lock()->Exists(node) || m_Root->Find(node) != nullptr)
     return;
 
   // find out if we have a root node
   TreeItem *parentTreeItem = m_Root;
   QModelIndex index;
   mitk::DataNode *parentDataNode = this->GetParentNode(node);
 
   if (parentDataNode) // no top level data node
   {
     parentTreeItem = m_Root->Find(parentDataNode); // find the corresponding tree item
     if (!parentTreeItem)
     {
       this->NodeAdded(parentDataNode);
       parentTreeItem = m_Root->Find(parentDataNode);
       if (!parentTreeItem)
         return;
     }
 
     // get the index of this parent with the help of the grand parent
     index = this->createIndex(parentTreeItem->GetIndex(), 0, parentTreeItem);
   }
 
   int firstRowWithASiblingBelow = 0;
   int nodeLayer = -1;
   node->GetIntProperty("layer", nodeLayer);
   for (TreeItem *siblingTreeItem : parentTreeItem->GetChildren())
   {
     int siblingLayer = -1;
     if (mitk::DataNode *siblingNode = siblingTreeItem->GetDataNode())
     {
       siblingNode->GetIntProperty("layer", siblingLayer);
     }
     if (nodeLayer > siblingLayer)
     {
       break;
     }
     ++firstRowWithASiblingBelow;
   }
   beginInsertRows(index, firstRowWithASiblingBelow, firstRowWithASiblingBelow);
   auto newNode = new TreeItem(const_cast<mitk::DataNode *>(node));
   parentTreeItem->InsertChild(newNode, firstRowWithASiblingBelow);
   m_TreeItems.push_back(newNode);
 
   endInsertRows();
 }
 
 QModelIndex QmitkDataStorageSimpleTreeModel::IndexFromTreeItem(TreeItem *item) const
 {
   if (item == m_Root)
     return QModelIndex();
   else
     return this->createIndex(item->GetIndex(), 0, item);
 }
 
 void QmitkDataStorageSimpleTreeModel::UpdateModelData()
 {
   if (!m_DataStorage.IsExpired())
   {
     auto nodeset = m_DataStorage.Lock()->GetAll();
     if (m_NodePredicate != nullptr)
     {
       nodeset = m_DataStorage.Lock()->GetSubset(m_NodePredicate);
     }
 
     for (const auto& node : *nodeset)
     {
       this->AddNodeInternal(node);
     }
   }
 }
diff --git a/Modules/QtWidgets/src/QmitkDataStorageTreeModelInternalItem.cpp b/Modules/QtWidgets/src/QmitkDataStorageTreeModelInternalItem.cpp
index bc6ddb599f..cd647f19ea 100644
--- a/Modules/QtWidgets/src/QmitkDataStorageTreeModelInternalItem.cpp
+++ b/Modules/QtWidgets/src/QmitkDataStorageTreeModelInternalItem.cpp
@@ -1,144 +1,144 @@
 /*===================================================================
 
 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 "QmitkDataStorageTreeModelInternalItem.h"
 
 #include "QmitkNodeDescriptorManager.h"
 #include <QmitkCustomVariants.h>
 #include <QmitkEnums.h>
 #include <QmitkMimeTypes.h>
 
 QmitkDataStorageTreeModelInternalItem::QmitkDataStorageTreeModelInternalItem(mitk::DataNode *_DataNode, QmitkDataStorageTreeModelInternalItem *_Parent)
   : m_Parent(_Parent), m_DataNode(_DataNode)
 {
   if (m_Parent)
     m_Parent->AddChild(this);
 }
 
 QmitkDataStorageTreeModelInternalItem::~QmitkDataStorageTreeModelInternalItem()
 {
   if (m_Parent)
     m_Parent->RemoveChild(this);
 }
 
 void QmitkDataStorageTreeModelInternalItem::Delete()
 {
   while (m_Children.size() > 0)
     delete m_Children.back();
 
   delete this;
 }
 
 QmitkDataStorageTreeModelInternalItem *QmitkDataStorageTreeModelInternalItem::Find(const mitk::DataNode *_DataNode) const
 {
   QmitkDataStorageTreeModelInternalItem *item = nullptr;
   if (_DataNode)
   {
     if (m_DataNode == _DataNode)
       item = const_cast<QmitkDataStorageTreeModelInternalItem *>(this);
     else
     {
       for (std::vector<QmitkDataStorageTreeModelInternalItem *>::const_iterator it = m_Children.begin(); it != m_Children.end(); ++it)
       {
         if (item)
           break;
         item = (*it)->Find(_DataNode);
       }
     }
   }
   return item;
 }
 
 int QmitkDataStorageTreeModelInternalItem::IndexOfChild(const QmitkDataStorageTreeModelInternalItem *item) const
 {
   std::vector<QmitkDataStorageTreeModelInternalItem *>::const_iterator it = std::find(m_Children.begin(), m_Children.end(), item);
   return it != m_Children.end() ? std::distance(m_Children.begin(), it) : -1;
 }
 
 QmitkDataStorageTreeModelInternalItem *QmitkDataStorageTreeModelInternalItem::GetChild(int index) const
 {
-  return (m_Children.size() > 0 && index >= 0 && index < (int)m_Children.size()) ? m_Children.at(index) : 0;
+  return (m_Children.size() > 0 && index >= 0 && index < (int)m_Children.size()) ? m_Children.at(index) : nullptr;
 }
 
 void QmitkDataStorageTreeModelInternalItem::AddChild(QmitkDataStorageTreeModelInternalItem *item)
 {
   this->InsertChild(item);
 }
 
 void QmitkDataStorageTreeModelInternalItem::RemoveChild(QmitkDataStorageTreeModelInternalItem *item)
 {
   std::vector<QmitkDataStorageTreeModelInternalItem *>::iterator it = std::find(m_Children.begin(), m_Children.end(), item);
   if (it != m_Children.end())
   {
     m_Children.erase(it);
-    item->SetParent(0);
+    item->SetParent(nullptr);
   }
 }
 
 int QmitkDataStorageTreeModelInternalItem::GetChildCount() const
 {
   return m_Children.size();
 }
 
 int QmitkDataStorageTreeModelInternalItem::GetIndex() const
 {
   if (m_Parent)
     return m_Parent->IndexOfChild(this);
 
   return 0;
 }
 
 QmitkDataStorageTreeModelInternalItem *QmitkDataStorageTreeModelInternalItem::GetParent() const
 {
   return m_Parent;
 }
 
 mitk::DataNode::Pointer QmitkDataStorageTreeModelInternalItem::GetDataNode() const
 {
   return m_DataNode.Lock();
 }
 
 void QmitkDataStorageTreeModelInternalItem::InsertChild(QmitkDataStorageTreeModelInternalItem *item, int index)
 {
   std::vector<QmitkDataStorageTreeModelInternalItem *>::iterator it = std::find(m_Children.begin(), m_Children.end(), item);
   if (it == m_Children.end())
   {
     if (m_Children.size() > 0 && index >= 0 && index < (int)m_Children.size())
     {
       it = m_Children.begin();
       std::advance(it, index);
       m_Children.insert(it, item);
     }
     else
       m_Children.push_back(item);
 
     // add parent if necessary
     if (item->GetParent() != this)
       item->SetParent(this);
   }
 }
 
 std::vector<QmitkDataStorageTreeModelInternalItem *> QmitkDataStorageTreeModelInternalItem::GetChildren() const
 {
   return m_Children;
 }
 
 void QmitkDataStorageTreeModelInternalItem::SetParent(QmitkDataStorageTreeModelInternalItem *_Parent)
 {
   m_Parent = _Parent;
   if (m_Parent)
     m_Parent->AddChild(this);
 }
diff --git a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
index 2a174404c3..c79582fbdc 100644
--- a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
@@ -1,445 +1,445 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 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 "QmitkMxNMultiWidget.h"
 
 #include <QList>
 #include <QMouseEvent>
 #include <QTimer>
 #include <QVBoxLayout>
 
 // mitk core
 #include <mitkDisplayActionEventFunctions.h>
 #include <mitkDisplayActionEvents.h>
 
 #include <mitkUIDGenerator.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkCameraController.h>
 #include <mitkDataStorage.h>
 #include <mitkImage.h>
 #include <mitkInteractionConst.h>
 #include <mitkLine.h>
 #include <mitkNodePredicateBase.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkProperties.h>
 #include <mitkStatusBar.h>
 #include <mitkVtkLayerController.h>
 #include <vtkSmartPointer.h>
 
 #include <iomanip>
 
 // qt
 #include <QGridLayout>
 
 QmitkMxNMultiWidget::QmitkMxNMultiWidget(QWidget* parent,
                                                Qt::WindowFlags f/* = 0*/,
                                                mitk::RenderingManager* renderingManager/* = nullptr*/,
                                                mitk::BaseRenderer::RenderingMode::Type renderingMode/* = mitk::BaseRenderer::RenderingMode::Standard*/,
                                                const QString& multiWidgetName/* = "mxnmulti"*/)
   : QWidget(parent, f)
   , m_MxNMultiWidgetLayout(nullptr)
   , m_MultiWidgetRows(0)
   , m_MultiWidgetColumns(0)
   , m_PlaneMode(0)
   , m_RenderingManager(renderingManager)
   , m_RenderingMode(renderingMode)
   , m_MultiWidgetName(multiWidgetName)
   , m_DisplayActionEventBroadcast(nullptr)
   , m_DisplayActionEventHandler(nullptr)
   , m_DataStorage(nullptr)
 {
   InitializeGUI();
   InitializeDisplayActionEventHandling();
   resize(QSize(364, 477).expandedTo(minimumSizeHint()));
 }
 
 void QmitkMxNMultiWidget::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (dataStorage == m_DataStorage)
   {
     return;
   }
 
   m_DataStorage = dataStorage;
   // set new data storage for the render window widgets
   for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
     renderWindowWidget.second->SetDataStorage(m_DataStorage);
   }
 }
 
 void QmitkMxNMultiWidget::InitializeRenderWindowWidgets()
 {
   m_MultiWidgetRows = 1;
   m_MultiWidgetColumns = 1;
   CreateRenderWindowWidget();
   InitializeGUI();
 }
 
 void QmitkMxNMultiWidget::ResetLayout(int row, int column)
 {
   m_MultiWidgetRows = row;
   m_MultiWidgetColumns = column;
 
   int requiredRenderWindowWidgets = m_MultiWidgetRows * m_MultiWidgetColumns;
   int existingRenderWindowWidgets = m_RenderWindowWidgets.size();
 
   int difference = requiredRenderWindowWidgets - existingRenderWindowWidgets;
   while(0 < difference)
   {
     // more render window widgets needed
     CreateRenderWindowWidget();
     --difference;
   }
   while(0 > difference)
   {
     // less render window widgets needed
     DestroyRenderWindowWidget();
     ++difference;
   }
 
   InitializeGUI();
 }
 
 void QmitkMxNMultiWidget::Synchronize(bool synchronized)
 {
   auto allObserverTags = m_DisplayActionEventHandler->GetAllObserverTags();
   for (auto observerTag : allObserverTags)
   {
     m_DisplayActionEventHandler->DisconnectObserver(observerTag);
   }
 
   if (synchronized)
   {
     mitk::StdFunctionCommand::ActionFunction actionFunction = mitk::DisplayActionEventFunctions::MoveCameraSynchronizedAction();
     m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayMoveEvent(nullptr, mitk::Vector2D()), actionFunction);
 
     actionFunction = mitk::DisplayActionEventFunctions::SetCrosshairSynchronizedAction();
     m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplaySetCrosshairEvent(nullptr, mitk::Point3D()), actionFunction);
 
     actionFunction = mitk::DisplayActionEventFunctions::ZoomCameraSynchronizedAction();
     m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayZoomEvent(nullptr, 0.0, mitk::Point2D()), actionFunction);
 
     actionFunction = mitk::DisplayActionEventFunctions::ScrollSliceStepperSynchronizedAction();
     m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayScrollEvent(nullptr, 0), actionFunction);
   }
   else
   {
     mitk::StdFunctionCommand::ActionFunction actionFunction = mitk::DisplayActionEventFunctions::MoveSenderCameraAction();
     m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayMoveEvent(nullptr, mitk::Vector2D()), actionFunction);
 
     actionFunction = mitk::DisplayActionEventFunctions::SetCrosshairAction();
     m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplaySetCrosshairEvent(nullptr, mitk::Point3D()), actionFunction);
 
     actionFunction = mitk::DisplayActionEventFunctions::ZoomSenderCameraAction();
     m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayZoomEvent(nullptr, 0.0, mitk::Point2D()), actionFunction);
 
     actionFunction = mitk::DisplayActionEventFunctions::ScrollSliceStepperAction();
     m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplayScrollEvent(nullptr, 0), actionFunction);
   }
 
   // use the standard 'set level window' action for both modes
   mitk::StdFunctionCommand::ActionFunction actionFunction = mitk::DisplayActionEventFunctions::SetLevelWindowAction();
   m_DisplayActionEventHandler->ConnectDisplayActionEvent(mitk::DisplaySetLevelWindowEvent(nullptr, mitk::ScalarType(), mitk::ScalarType()), actionFunction);
 }
 
 void QmitkMxNMultiWidget::SetInteractionScheme(mitk::InteractionSchemeSwitcher::InteractionScheme scheme)
 {
   auto interactionSchemeSwitcher = mitk::InteractionSchemeSwitcher::New();
   auto interactionEventHandler = GetInteractionEventHandler();
   try
   {
     interactionSchemeSwitcher->SetInteractionScheme(interactionEventHandler, scheme);
   }
   catch (const mitk::Exception&)
   {
     return;
   }
 }
 
 QmitkMxNMultiWidget::RenderWindowWidgetMap QmitkMxNMultiWidget::GetRenderWindowWidgets() const
 {
   return m_RenderWindowWidgets;
 }
 
 QmitkMxNMultiWidget::RenderWindowWidgetPointer QmitkMxNMultiWidget::GetRenderWindowWidget(int row, int column) const
 {
   return GetRenderWindowWidget(GetNameFromIndex(row, column));
 }
 
 QmitkMxNMultiWidget::RenderWindowWidgetPointer QmitkMxNMultiWidget::GetRenderWindowWidget(const QString& widgetName) const
 {
   RenderWindowWidgetMap::const_iterator it = m_RenderWindowWidgets.find(widgetName);
   if (it != m_RenderWindowWidgets.end())
   {
     return it->second;
   }
 
   return nullptr;
 }
 
 QmitkMxNMultiWidget::RenderWindowHash QmitkMxNMultiWidget::GetRenderWindows() const
 {
   RenderWindowHash result;
   // create QHash on demand
   auto renderWindowWidgets = GetRenderWindowWidgets();
   for (const auto& renderWindowWidget : renderWindowWidgets)
   {
     result.insert(renderWindowWidget.first, renderWindowWidget.second->GetRenderWindow());
   }
 
   return result;
 }
 
 QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(int row, int column) const
 {
   return GetRenderWindow(GetNameFromIndex(row, column));
 }
 
 QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const QString& widgetName) const
 {
   RenderWindowWidgetPointer renderWindowWidget = GetRenderWindowWidget(widgetName);
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->GetRenderWindow();
   }
 
   return nullptr;
 }
 
 void QmitkMxNMultiWidget::SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget)
 {
   m_ActiveRenderWindowWidget = activeRenderWindowWidget;
 }
 
 QmitkMxNMultiWidget::RenderWindowWidgetPointer QmitkMxNMultiWidget::GetActiveRenderWindowWidget() const
 {
   return m_ActiveRenderWindowWidget;
 }
 
 QmitkMxNMultiWidget::RenderWindowWidgetPointer QmitkMxNMultiWidget::GetFirstRenderWindowWidget() const
 {
   if (!m_RenderWindowWidgets.empty())
   {
     return m_RenderWindowWidgets.begin()->second;
   }
   else
   {
     return nullptr;
   }
 }
 
 QmitkMxNMultiWidget::RenderWindowWidgetPointer QmitkMxNMultiWidget::GetLastRenderWindowWidget() const
 {
   if (!m_RenderWindowWidgets.empty())
   {
     return m_RenderWindowWidgets.rbegin()->second;
   }
   else
   {
     return nullptr;
   }
 }
 
 unsigned int QmitkMxNMultiWidget::GetNumberOfRenderWindowWidgets() const
 {
   return m_RenderWindowWidgets.size();
 }
 
 void QmitkMxNMultiWidget::RequestUpdate(const QString& widgetName)
 {
   RenderWindowWidgetPointer renderWindowWidget = GetRenderWindowWidget(widgetName);
   if (nullptr != renderWindowWidget)
   {
     return renderWindowWidget->RequestUpdate();
   }
 }
 
 void QmitkMxNMultiWidget::RequestUpdateAll()
 {
   for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
     renderWindowWidget.second->RequestUpdate();
   }
 }
 
 void QmitkMxNMultiWidget::ForceImmediateUpdate(const QString& widgetName)
 {
   RenderWindowWidgetPointer renderWindowWidget = GetRenderWindowWidget(widgetName);
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->ForceImmediateUpdate();
   }
 }
 
 void QmitkMxNMultiWidget::ForceImmediateUpdateAll()
 {
   for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
     renderWindowWidget.second->ForceImmediateUpdate();
   }
 }
 
 void QmitkMxNMultiWidget::ActivateAllCrosshairs(bool activate)
 {
   for (const auto& renderWindowWidget : m_RenderWindowWidgets)
   {
     renderWindowWidget.second->ActivateCrosshair(activate);
   }
 }
 
 const mitk::Point3D QmitkMxNMultiWidget::GetSelectedPosition(const QString& /*widgetName*/) const
 {
   // see T26208
   return mitk::Point3D();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PUBLIC SLOTS
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidget::SetSelectedPosition(const QString& widgetName, const mitk::Point3D& newPosition)
 {
   RenderWindowWidgetPointer renderWindowWidget;
   if (widgetName.isNull())
   {
     renderWindowWidget = GetActiveRenderWindowWidget();
   }
   else
   {
     renderWindowWidget = GetRenderWindowWidget(widgetName);
   }
 
   if (nullptr != renderWindowWidget)
   {
     renderWindowWidget->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
     renderWindowWidget->RequestUpdate();
     return;
   }
 
   MITK_ERROR << "Position can not be set for an unknown render window widget.";
 }
 
 //////////////////////////////////////////////////////////////////////////
 // MOUSE EVENTS
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidget::wheelEvent(QWheelEvent* e)
 {
   emit WheelMoved(e);
 }
 
 void QmitkMxNMultiWidget::mousePressEvent(QMouseEvent* /*e*/)
 {
 }
 
 void QmitkMxNMultiWidget::moveEvent(QMoveEvent* e)
 {
   QWidget::moveEvent(e);
 
   // it is necessary to readjust the position of the overlays as the MultiWidget has moved
   // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
   emit Moved();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidget::InitializeGUI()
 {
   delete m_MxNMultiWidgetLayout;
   m_MxNMultiWidgetLayout = new QGridLayout(this);
   m_MxNMultiWidgetLayout->setContentsMargins(0, 0, 0, 0);
   setLayout(m_MxNMultiWidgetLayout);
 
   FillMultiWidgetLayout();
 }
 
 void QmitkMxNMultiWidget::InitializeDisplayActionEventHandling()
 {
   m_DisplayActionEventBroadcast = mitk::DisplayActionEventBroadcast::New();
   m_DisplayActionEventBroadcast->LoadStateMachine("DisplayInteraction.xml");
   m_DisplayActionEventBroadcast->SetEventConfig("DisplayConfigMITK.xml");
 
   m_DisplayActionEventHandler = std::make_unique<mitk::DisplayActionEventHandler>();
   m_DisplayActionEventHandler->SetObservableBroadcast(m_DisplayActionEventBroadcast);
 
   Synchronize(true);
 }
 
 void QmitkMxNMultiWidget::CreateRenderWindowWidget()
 {
   // create the render window widget and connect signals / slots
   QString renderWindowWidgetName = GetNameFromIndex(m_RenderWindowWidgets.size());
   RenderWindowWidgetPointer renderWindowWidget = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, m_DataStorage);
   renderWindowWidget->SetCornerAnnotationText(renderWindowWidgetName.toStdString());
 
   // store the newly created render window widget with the UID
   m_RenderWindowWidgets.insert(std::make_pair(renderWindowWidgetName, renderWindowWidget));
 }
 
 void QmitkMxNMultiWidget::DestroyRenderWindowWidget()
 {
   auto iterator = m_RenderWindowWidgets.find(GetNameFromIndex(m_RenderWindowWidgets.size() - 1));
   if (iterator == m_RenderWindowWidgets.end())
   {
     return;
   }
 
   // disconnect each signal of this render window widget
   RenderWindowWidgetPointer renderWindowWidgetToRemove = iterator->second;
-  disconnect(renderWindowWidgetToRemove.get(), 0, 0, 0);
+  disconnect(renderWindowWidgetToRemove.get(), nullptr, nullptr, nullptr);
 
   // erase the render window from the map
   m_RenderWindowWidgets.erase(iterator);
 }
 
 void QmitkMxNMultiWidget::FillMultiWidgetLayout()
 {
   for (int row = 0; row < m_MultiWidgetRows; ++row)
   {
     for (int column = 0; column < m_MultiWidgetColumns; ++column)
     {
       RenderWindowWidgetPointer renderWindowWidget = GetRenderWindowWidget(row, column);
       if (nullptr != renderWindowWidget)
       {
         m_MxNMultiWidgetLayout->addWidget(renderWindowWidget.get(), row, column);
         SetActiveRenderWindowWidget(renderWindowWidget);
       }
     }
   }
 }
 
 QString QmitkMxNMultiWidget::GetNameFromIndex(int row, int column) const
 {
   if (0 <= row && m_MultiWidgetRows > row && 0 <= column && m_MultiWidgetColumns > column)
   {
     return GetNameFromIndex(row * m_MultiWidgetColumns + column);
   }
 
   return QString();
 }
 
 QString QmitkMxNMultiWidget::GetNameFromIndex(size_t index) const
 {
   if (index <= m_RenderWindowWidgets.size())
   {
     return m_MultiWidgetName + ".widget" + QString::number(index);
   }
 
   return QString();
 }
diff --git a/Modules/TubeGraph/include/mitkTubeGraphDataInteractor.h b/Modules/TubeGraph/include/mitkTubeGraphDataInteractor.h
index 29c30145b4..ef22157c4e 100644
--- a/Modules/TubeGraph/include/mitkTubeGraphDataInteractor.h
+++ b/Modules/TubeGraph/include/mitkTubeGraphDataInteractor.h
@@ -1,126 +1,126 @@
 /*===================================================================
 
 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 mitkTubeGraphDataInteractor3D_h_
 #define mitkTubeGraphDataInteractor3D_h_
 
 #include <MitkTubeGraphExports.h>
 
 #include <mitkBaseRenderer.h>
 #include <mitkDataInteractor.h>
 
 #include "mitkTubeGraph.h"
 #include "mitkTubeGraphProperty.h"
 
 namespace mitk
 {
   // Define events for TubeGraph interaction notifications
   itkEventMacro(SelectionChangedTubeGraphEvent, itk::AnyEvent);
 
   /**
   * \brief
   *
   * \ingroup Interaction
   */
   // Inherit from DataInteratcor, this provides functionality of a state machine and configurable inputs.
   class MITKTUBEGRAPH_EXPORT TubeGraphDataInteractor : public DataInteractor
   {
   public:
     mitkClassMacro(TubeGraphDataInteractor, DataInteractor);
     itkNewMacro(Self);
 
     /**
     * Describes, which activation modes are available based on the
     * currently picked tube:
     *
     *   \li <b>None</b> means "no tube is active"
     *   \li <b>Single</b> means "only the picked tube is active"
     *   \li <b>ToRoot</b> means "all tubes from the picked on down to the root of the tube graph are active"
     *   \li <b>ToPeriphery</b> means "all tubes included in the subgraph of the currently picked vessel are active"
     *   \li <b>Points</b> means "shortes path between two picked tubes are active"
     *   \li <b>Multiple</b> means "all picked tubes are active"
     */
     enum ActivationMode
     {
       None = 0,
       Single,
       ToRoot,
       ToPeriphery,
       Points,
       Multiple
     };
 
     enum ActionMode
     {
       AttributationMode = 0,
       AnnotationMode,
       EditMode,
       RootMode,
       InformationMode
     };
 
     void SetActivationMode(const ActivationMode &activationMode);
     ActivationMode GetActivationMode();
 
     void SetActionMode(const ActionMode &actionMode);
     ActionMode GetActionMode();
 
     void ResetPickedTubes();
 
 	mitk::Point3D GetLastPickedPosition();
 
   protected:
     TubeGraphDataInteractor();
     ~TubeGraphDataInteractor() override;
 
     /**
     * Here actions strings from the loaded state machine pattern are mapped to functions of
     * the DataInteractor. These functions are called when an action from the state machine pattern is executed.
     */
     void ConnectActionsAndFunctions() override;
 
     /**
     * This function is called when a DataNode has been set/changed.
     */
     void DataNodeChanged() override;
 
     /**
     * Initializes the movement, stores starting position.
     */
     virtual bool CheckOverTube(const InteractionEvent *);
     virtual void SelectTube(StateMachineAction *, InteractionEvent *);
     virtual void DeselectTube(StateMachineAction *, InteractionEvent *);
 
     void SelectTubesByActivationModus();
     void UpdateActivation();
 
   private:
     std::vector<TubeGraph::TubeDescriptorType> GetTubesToRoot();
     std::vector<TubeGraph::TubeDescriptorType> GetTubesBetweenPoints();
     std::vector<TubeGraph::TubeDescriptorType> GetPathToPeriphery();
     std::vector<TubeGraph::TubeDescriptorType> GetPathBetweenTubes(const TubeGraph::TubeDescriptorType &start,
                                                                    const TubeGraph::TubeDescriptorType &end);
 
     TubeGraph::Pointer m_TubeGraph;
     TubeGraphProperty::Pointer m_TubeGraphProperty;
     TubeGraph::TubeDescriptorType m_LastPickedTube;
     TubeGraph::TubeDescriptorType m_SecondLastPickedTube;
     ActivationMode m_ActivationMode;
     ActionMode m_ActionMode;
-    mitk::TubeElement *m_LastPickedElement = 0;
+    mitk::TubeElement *m_LastPickedElement = nullptr;
   };
 }
 #endif
diff --git a/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp b/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp
index bbb20fcd0e..eff419fa21 100644
--- a/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp
+++ b/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp
@@ -1,495 +1,495 @@
 /*===================================================================
 
 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 "mitkAbstractUltrasoundTrackerDevice.h"
 #include "mitkImageReadAccessor.h"
 #include "mitkNavigationDataDelayFilter.h"
 #include "mitkNavigationDataDisplacementFilter.h"
 #include "mitkNavigationDataSmoothingFilter.h"
 #include "mitkTrackingDeviceSource.h"
 
 // US Control Interfaces
 #include "mitkUSControlInterfaceBMode.h"
 #include "mitkUSControlInterfaceDoppler.h"
 #include "mitkUSControlInterfaceProbes.h"
 
 // Microservices
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usServiceProperties.h>
 
 #include <algorithm>
 
 // TempIncludes
 #include <tinyxml.h>
 
 const std::string mitk::AbstractUltrasoundTrackerDevice::DeviceClassIdentifier =
   "org.mitk.modules.us.AbstractUltrasoundTrackerDevice";
 const char *mitk::AbstractUltrasoundTrackerDevice::DefaultProbeIdentifier = "default";
 const char *mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator = "_";
 
 const std::string mitk::AbstractUltrasoundTrackerDevice::US_INTERFACE_NAME =
   "org.mitk.services.AbstractUltrasoundTrackerDevice";
 const std::string mitk::AbstractUltrasoundTrackerDevice::US_PROPKEY_DEVICENAME = US_INTERFACE_NAME + ".devicename";
 const std::string mitk::AbstractUltrasoundTrackerDevice::US_PROPKEY_CLASS = US_INTERFACE_NAME + ".class";
 const std::string mitk::AbstractUltrasoundTrackerDevice::US_PROPKEY_ID = US_INTERFACE_NAME + ".id";
 //____
 
 mitk::AbstractUltrasoundTrackerDevice::AbstractUltrasoundTrackerDevice(USDevice::Pointer usDevice,
                                                                        NavigationDataSource::Pointer trackingDevice,
                                                                        bool trackedUltrasoundActive)
   : m_UltrasoundDevice(usDevice),
     m_TrackingDeviceDataSource(trackingDevice),
     m_SmoothingFilter(mitk::NavigationDataSmoothingFilter::New()),
     m_DelayFilter(mitk::NavigationDataDelayFilter::New(0)),
     m_DisplacementFilter(mitk::NavigationDataDisplacementFilter::New()),
     m_LastFilterOfIGTPipeline(nullptr),
     m_NumberOfSmoothingValues(0),
     m_DelayCount(0),
     m_IsTrackedUltrasoundActive(trackedUltrasoundActive)
 {
   m_DisplacementFilter->SetTransform6DOF(true);
 
   this->RebuildFilterPipeline();
 
   // create a new output (for the image data)
   //___ mitk::Image::Pointer newOutput = mitk::Image::New();
   //___ this->SetNthOutput(0, newOutput);
 
   // Combined Modality should not spawn an own acquire thread, because
   // image acquiring is done by the included us device
   //___ m_UltrasoundDevice->SetSpawnAcquireThread(false);
 }
 
 mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetUSPlaneTransform()
 {
   return mitk::AffineTransform3D::New();
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::SetIsFreezed(bool freeze)
 {
   if (m_UltrasoundDevice.IsNull() || m_TrackingDeviceDataSource.IsNull())
   {
     MITK_WARN << "Combined modality not correctly initialized, aborting!";
     return;
   }
 
   if (!m_UltrasoundDevice->GetIsActive())
   {
     MITK_WARN("mitkUSDevice")
       << "Cannot freeze or unfreeze if device is not active.";
     return;
   }
 
   this->OnFreeze(freeze);
 
   if (freeze)
   {
     m_IsFreezed = true;
   }
   else
   {
     m_IsFreezed = false;
   }
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::GetIsFreezed()
 {
   return m_IsFreezed;
 }
 
 mitk::AbstractUltrasoundTrackerDevice::~AbstractUltrasoundTrackerDevice()
 {
   if (m_ServiceRegistration != nullptr)
   {
     m_ServiceRegistration.Unregister();
   }
   m_ServiceRegistration = 0;
 }
 
 mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetCalibration()
 {
   return this->GetCalibration(this->GetCurrentDepthValue(), this->GetIdentifierForCurrentProbe());
 }
 
 mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetCalibration(std::string depth)
 {
   return this->GetCalibration(depth, this->GetIdentifierForCurrentProbe());
 }
 
 mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetCalibration(std::string depth,
                                                                                        std::string probe)
 {
   // make sure that there is no '/' which would cause problems for TinyXML
   std::replace(probe.begin(), probe.end(), '/', '-');
 
   // create identifier for calibration from probe and depth
   std::string calibrationKey = probe + mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator + depth;
 
   // find calibration for combination of probe identifier and depth
   std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator calibrationIterator =
     m_Calibrations.find(calibrationKey);
 
   if (calibrationIterator == m_Calibrations.end())
   {
-    return 0;
+    return nullptr;
   }
 
   return calibrationIterator->second;
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::SetCalibration(mitk::AffineTransform3D::Pointer calibration)
 {
   if (calibration.IsNull())
   {
     MITK_WARN << "Null pointer passed to SetCalibration of mitk::USDevice. Ignoring call.";
     return;
   }
 
   std::string calibrationKey = this->GetIdentifierForCurrentCalibration();
   if (calibrationKey.empty())
   {
     MITK_WARN << "Could not get a key for the calibration -> Calibration cannot be set.";
     return;
   }
 
   m_Calibrations[calibrationKey] = calibration;
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::RemoveCalibration()
 {
   return this->RemoveCalibration(this->GetCurrentDepthValue(), this->GetIdentifierForCurrentProbe());
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::RemoveCalibration(std::string depth)
 {
   return this->RemoveCalibration(depth, this->GetIdentifierForCurrentProbe());
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::RemoveCalibration(std::string depth, std::string probe)
 {
   // make sure that there is no '/' which would cause problems for TinyXML
   std::replace(probe.begin(), probe.end(), '/', '-');
 
   // create identifier for calibration from probe and depth
   std::string calibrationKey = probe + mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator + depth;
 
   return m_Calibrations.erase(calibrationKey) > 0;
 }
 
 std::string mitk::AbstractUltrasoundTrackerDevice::GetDeviceClass()
 {
   return DeviceClassIdentifier;
 }
 
 mitk::USImageSource::Pointer mitk::AbstractUltrasoundTrackerDevice::GetUSImageSource()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("AbstractUltrasoundTrackerDevice")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetUSImageSource();
 }
 
 mitk::NavigationDataSource::Pointer mitk::AbstractUltrasoundTrackerDevice::GetNavigationDataSource()
 {
   if (m_LastFilterOfIGTPipeline.IsNull())
   {
     this->RebuildFilterPipeline();
   }
   m_LastFilterOfIGTPipeline->SetToolMetaDataCollection(this->m_TrackingDeviceDataSource->GetToolMetaDataCollection());
   return m_LastFilterOfIGTPipeline;
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::GetIsCalibratedForCurrentStatus()
 {
   return m_Calibrations.find(this->GetIdentifierForCurrentCalibration()) != m_Calibrations.end();
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::GetContainsAtLeastOneCalibration()
 {
   return !m_Calibrations.empty();
 }
 
 std::string mitk::AbstractUltrasoundTrackerDevice::SerializeCalibration()
 {
   std::stringstream result;
   result << "<calibrations>" << std::endl;
   // For each calibration in the set
   for (std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator it = m_Calibrations.begin();
        it != m_Calibrations.end();
        it++)
   {
     mitk::AffineTransform3D::MatrixType matrix = it->second->GetMatrix();
     mitk::AffineTransform3D::TranslationType translation = it->second->GetTranslation();
     TiXmlElement elem(it->first);
     // Serialize Matrix
     elem.SetDoubleAttribute("M00", matrix[0][0]);
     elem.SetDoubleAttribute("M01", matrix[0][1]);
     elem.SetDoubleAttribute("M02", matrix[0][2]);
     elem.SetDoubleAttribute("M10", matrix[1][0]);
     elem.SetDoubleAttribute("M11", matrix[1][1]);
     elem.SetDoubleAttribute("M12", matrix[1][2]);
     elem.SetDoubleAttribute("M20", matrix[2][0]);
     elem.SetDoubleAttribute("M21", matrix[2][1]);
     elem.SetDoubleAttribute("M22", matrix[2][2]);
     // Serialize Offset
     elem.SetDoubleAttribute("T0", translation[0]);
     elem.SetDoubleAttribute("T1", translation[1]);
     elem.SetDoubleAttribute("T2", translation[2]);
 
     result << elem << std::endl;
   }
   result << "</calibrations>" << std::endl;
 
   return result.str();
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::DeserializeCalibration(const std::string &xmlString,
                                                                    bool clearPreviousCalibrations)
 {
   // Sanitize Input
   if (xmlString == "")
   {
     MITK_ERROR << "Empty string passed to Deserialize() method of CombinedModality. Aborting...";
     mitkThrow() << "Empty string passed to Deserialize() method of CombinedModality. Aborting...";
     return;
   }
   // Clear previous calibrations if necessary
   if (clearPreviousCalibrations)
     m_Calibrations.clear();
 
   // Parse Input
   TiXmlDocument doc;
   if (!doc.Parse(xmlString.c_str()))
   {
     MITK_ERROR << "Unable to deserialize calibrations in CombinedModality. Error was: " << doc.ErrorDesc();
     mitkThrow() << "Unable to deserialize calibrations in CombinedModality. Error was: " << doc.ErrorDesc();
     return;
   }
   TiXmlElement *root = doc.FirstChildElement();
   if (root == nullptr)
   {
     MITK_ERROR << "Unable to deserialize calibrations in CombinedModality. String contained no root element.";
     mitkThrow() << "Unable to deserialize calibrations in CombinedModality. String contained no root element.";
     return;
   }
   // Read Calibrations
   for (TiXmlElement *elem = root->FirstChildElement(); elem != nullptr; elem = elem->NextSiblingElement())
   {
     mitk::AffineTransform3D::MatrixType matrix;
     mitk::AffineTransform3D::OffsetType translation;
 
     std::string calibName = elem->Value();
 
     // Deserialize Matrix
     elem->QueryDoubleAttribute("M00", &matrix[0][0]);
     elem->QueryDoubleAttribute("M01", &matrix[0][1]);
     elem->QueryDoubleAttribute("M02", &matrix[0][2]);
     elem->QueryDoubleAttribute("M10", &matrix[1][0]);
     elem->QueryDoubleAttribute("M11", &matrix[1][1]);
     elem->QueryDoubleAttribute("M12", &matrix[1][2]);
     elem->QueryDoubleAttribute("M20", &matrix[2][0]);
     elem->QueryDoubleAttribute("M21", &matrix[2][1]);
     elem->QueryDoubleAttribute("M22", &matrix[2][2]);
 
     // Deserialize Offset
     elem->QueryDoubleAttribute("T0", &translation[0]);
     elem->QueryDoubleAttribute("T1", &translation[1]);
     elem->QueryDoubleAttribute("T2", &translation[2]);
 
     mitk::AffineTransform3D::Pointer calibration = mitk::AffineTransform3D::New();
     calibration->SetMatrix(matrix);
     calibration->SetTranslation(translation);
     m_Calibrations[calibName] = calibration;
   }
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::SetNumberOfSmoothingValues(unsigned int numberOfSmoothingValues)
 {
   unsigned int oldNumber = m_NumberOfSmoothingValues;
   m_NumberOfSmoothingValues = numberOfSmoothingValues;
 
   // if filter should be activated or deactivated
   if ((oldNumber == 0 && numberOfSmoothingValues != 0) || (oldNumber != 0 && numberOfSmoothingValues == 0))
   {
     this->RebuildFilterPipeline();
   }
   m_SmoothingFilter->SetNumerOfValues(numberOfSmoothingValues);
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::SetDelayCount(unsigned int delayCount)
 {
   unsigned int oldCount = m_DelayCount;
   m_DelayCount = delayCount;
 
   // if filter should be activated or deactivated
   if ((oldCount == 0 && delayCount != 0) || (oldCount != 0 && delayCount == 0))
   {
     this->RebuildFilterPipeline();
   }
   m_DelayFilter->SetDelay(delayCount);
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::GenerateData() {}
 
 std::string mitk::AbstractUltrasoundTrackerDevice::GetIdentifierForCurrentCalibration()
 {
   return this->GetIdentifierForCurrentProbe() + mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator +
          this->GetCurrentDepthValue();
 }
 
 std::string mitk::AbstractUltrasoundTrackerDevice::GetIdentifierForCurrentProbe()
 {
   us::ServiceProperties usdeviceProperties = m_UltrasoundDevice->GetServiceProperties();
 
   us::ServiceProperties::const_iterator probeIt =
     usdeviceProperties.find(mitk::USDevice::GetPropertyKeys().US_PROPKEY_PROBES_SELECTED);
 
   // get probe identifier from control interface for probes
   std::string probeName = mitk::AbstractUltrasoundTrackerDevice::DefaultProbeIdentifier;
   if (probeIt != usdeviceProperties.end())
   {
     probeName = (probeIt->second).ToString();
   }
 
   // make sure that there is no '/' which would cause problems for TinyXML
   std::replace(probeName.begin(), probeName.end(), '/', '-');
 
   return probeName;
 }
 
 std::string mitk::AbstractUltrasoundTrackerDevice::GetCurrentDepthValue()
 {
   us::ServiceProperties usdeviceProperties = m_UltrasoundDevice->GetServiceProperties();
 
   // get string for depth value from the micro service properties
   std::string depth;
   us::ServiceProperties::iterator depthIterator =
     usdeviceProperties.find(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH);
 
   if (depthIterator != usdeviceProperties.end())
   {
     depth = depthIterator->second.ToString();
   }
   else
   {
     depth = "0";
   }
 
   return depth;
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::RebuildFilterPipeline()
 {
   m_LastFilterOfIGTPipeline = m_TrackingDeviceDataSource;
 
   if (m_NumberOfSmoothingValues > 0)
   {
     m_SmoothingFilter->ConnectTo(m_LastFilterOfIGTPipeline.GetPointer());
     m_LastFilterOfIGTPipeline = m_SmoothingFilter;
   }
 
   if (m_DelayCount > 0)
   {
     m_DelayFilter->ConnectTo(m_LastFilterOfIGTPipeline.GetPointer());
     m_LastFilterOfIGTPipeline = m_DelayFilter;
   }
 
   if (m_IsTrackedUltrasoundActive)
   {
     m_DisplacementFilter->ConnectTo(m_LastFilterOfIGTPipeline.GetPointer());
     m_LastFilterOfIGTPipeline = m_DisplacementFilter;
   }
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::UnregisterOnService()
 {
   if (m_UltrasoundDevice->GetDeviceState() == USDevice::State_Activated)
   {
     m_UltrasoundDevice->Deactivate();
   }
   if (m_UltrasoundDevice->GetDeviceState() == USDevice::State_Connected)
   {
     m_UltrasoundDevice->Disconnect();
   }
 
   if (m_ServiceRegistration != nullptr)
     m_ServiceRegistration.Unregister();
   m_ServiceRegistration = 0;
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::RegisterAsMicroservice()
 {
   // Get Context
   us::ModuleContext *context = us::GetModuleContext();
 
   // Define ServiceProps
   // us::ServiceProperties props;
   mitk::UIDGenerator uidGen = mitk::UIDGenerator("org.mitk.services.AbstractUltrasoundTrackerDevice", 16);
   m_ServiceProperties[US_PROPKEY_ID] = uidGen.GetUID();
   m_ServiceProperties[US_PROPKEY_DEVICENAME] = m_UltrasoundDevice->GetName();
   m_ServiceProperties[US_PROPKEY_CLASS] = mitk::AbstractUltrasoundTrackerDevice::DeviceClassIdentifier;
 
   m_ServiceRegistration = context->RegisterService(this, m_ServiceProperties);
 }
 
 mitk::USAbstractControlInterface::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceCustom()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetControlInterfaceCustom();
 }
 
 mitk::USControlInterfaceBMode::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceBMode()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetControlInterfaceBMode();
 }
 
 mitk::USControlInterfaceProbes::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceProbes()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetControlInterfaceProbes();
 }
 
 mitk::USControlInterfaceDoppler::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceDoppler()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetControlInterfaceDoppler();
 }
diff --git a/Plugins/org.mitk.gui.qt.chartExample/src/internal/ChartExample.cpp b/Plugins/org.mitk.gui.qt.chartExample/src/internal/ChartExample.cpp
index 599961e1f4..f93e2e0d44 100644
--- a/Plugins/org.mitk.gui.qt.chartExample/src/internal/ChartExample.cpp
+++ b/Plugins/org.mitk.gui.qt.chartExample/src/internal/ChartExample.cpp
@@ -1,455 +1,455 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryIQtStyleManager.h>
 #include <berryWorkbenchPlugin.h>
 
 // Qmitk
 #include "ChartExample.h"
 
 // Qt
 #include <QRandomGenerator>
 
 const std::string ChartExample::VIEW_ID = "org.mitk.views.chartexample";
 
 void ChartExample::SetFocus()
 {
   m_Controls.m_buttonCreateChart->setFocus();
 }
 
 void ChartExample::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   CreateConnectionsForGUIElements();
   connect(m_Controls.m_comboBoxChartType, &QComboBox::currentTextChanged, this, &ChartExample::AdaptDataGUI);
 
   m_Controls.m_groupBoxErrors->setVisible(false);
   m_Controls.m_groupBoxXErrors->setVisible(false);
   m_Controls.m_groupBoxYErrors->setVisible(false);
   m_Controls.m_lineEditDataXVector->setVisible(false);
   m_Controls.m_lineEditDataXVector->setText("0;1;2;3;4;5;6;7;8;9");
   ResetDataGUI();
 
   m_Controls.m_doubleSpinBox_maxZoomX->setValue(10);
   m_Controls.m_doubleSpinBox_maxZoomY->setValue(10);
 
   FillRandomDataValues();
   auto chartStyle = GetColorTheme();
   m_Controls.m_Chart->SetTheme(chartStyle);
 
   m_Controls.m_lineEditXAxisLabel->setText("xLabel");
   m_Controls.m_lineEditYAxisLabel->setText("yLabel");
 
   m_ChartNameToChartType.emplace("bar", QmitkChartWidget::ChartType::bar);
   m_ChartNameToChartType.emplace("line", QmitkChartWidget::ChartType::line);
   m_ChartNameToChartType.emplace("spline", QmitkChartWidget::ChartType::spline);
   m_ChartNameToChartType.emplace("pie", QmitkChartWidget::ChartType::pie);
   m_ChartNameToChartType.emplace("area", QmitkChartWidget::ChartType::area);
   m_ChartNameToChartType.emplace("area-spline", QmitkChartWidget::ChartType::area_spline);
   m_ChartNameToChartType.emplace("scatter", QmitkChartWidget::ChartType::scatter);
 
   m_LineNameToLineType.emplace("solid", QmitkChartWidget::LineStyle::solid);
   m_LineNameToLineType.emplace("dashed", QmitkChartWidget::LineStyle::dashed);
 
   m_AxisScaleNameToAxisScaleType.emplace("linear", QmitkChartWidget::AxisScale::linear);
   m_AxisScaleNameToAxisScaleType.emplace("logarithmic", QmitkChartWidget::AxisScale::log);
 
   m_LegendPositionNameToLegendPositionType.emplace("bottom middle", QmitkChartWidget::LegendPosition::bottomMiddle);
   m_LegendPositionNameToLegendPositionType.emplace("bottom right", QmitkChartWidget::LegendPosition::bottomRight);
   m_LegendPositionNameToLegendPositionType.emplace("top right", QmitkChartWidget::LegendPosition::topRight);
   m_LegendPositionNameToLegendPositionType.emplace("top left", QmitkChartWidget::LegendPosition::topLeft);
   m_LegendPositionNameToLegendPositionType.emplace("middle right", QmitkChartWidget::LegendPosition::middleRight);
 }
 
 void ChartExample::CreateConnectionsForGUIElements()
 {
   connect(m_Controls.m_buttonCreateChart, &QPushButton::clicked, this, &ChartExample::CreateChart);
   connect(m_Controls.m_buttonUpdateChart, &QPushButton::clicked, this, &ChartExample::UpdateChart);
   connect(m_Controls.m_buttonClearChart, &QPushButton::clicked, this, &ChartExample::ClearChart);
   connect(m_Controls.m_buttonAddData, &QPushButton::clicked, this, &ChartExample::AddData);
   connect(m_Controls.m_checkBoxEnableDataX, &QCheckBox::toggled, this, &ChartExample::ShowXData);
   connect(m_Controls.m_checkBoxEnableErrors, &QCheckBox::toggled, this, &ChartExample::ShowErrorOptions);
   connect(m_Controls.m_checkBoxEnableXErrors, &QCheckBox::toggled, this, &ChartExample::ShowXErrorOptions);
   connect(m_Controls.m_checkBoxEnableYErrors, &QCheckBox::toggled, this, &ChartExample::ShowYErrorOptions);
   connect(m_Controls.m_doubleSpinBox_minZoomX, &QSpinBox::editingFinished, this, &ChartExample::AdaptZoomX);
   connect(m_Controls.m_doubleSpinBox_maxZoomX, &QSpinBox::editingFinished, this, &ChartExample::AdaptZoomX);
   connect(m_Controls.m_doubleSpinBox_minZoomY, &QSpinBox::editingFinished, this, &ChartExample::AdaptZoomY);
   connect(m_Controls.m_doubleSpinBox_maxZoomY, &QSpinBox::editingFinished, this, &ChartExample::AdaptZoomY);
   connect(m_Controls.m_comboBoxLegendPosition, &QComboBox::currentTextChanged, this, &ChartExample::OnLegendPositionChanged);
   connect(m_Controls.m_lineEditTitle, &QLineEdit::editingFinished, this, &ChartExample::OnTitleChanged);
   connect(m_Controls.m_lineEditXAxisLabel, &QLineEdit::editingFinished, this, &ChartExample::OnXAxisLabelChanged);
   connect(m_Controls.m_lineEditYAxisLabel, &QLineEdit::editingFinished, this, &ChartExample::OnYAxisLabelChanged);
   connect(
     m_Controls.m_comboBoxYAxisScale, &QComboBox::currentTextChanged, this, &ChartExample::OnYAxisScaleChanged);
   connect(m_Controls.m_checkBoxShowLegend, &QCheckBox::stateChanged, this, &ChartExample::OnShowLegendChanged);
   connect(m_Controls.m_checkBoxStackedData, &QCheckBox::stateChanged, this, &ChartExample::OnStackedDataChanged);
   connect(m_Controls.m_checkBoxShowDataPoints, &QCheckBox::stateChanged, this, &ChartExample::OnShowDataPointsChanged);
   connect(m_Controls.m_checkBoxShowSubchart, &QCheckBox::stateChanged, this, &ChartExample::OnShowSubchartChanged);
 }
 
 void ChartExample::FillRandomDataValues()
 {
   std::vector<double> numbers = GenerateRandomNumbers(10, 10.0);
   std::string text = ConvertToText(numbers);
   m_Controls.m_lineEditDataYVector->setText(QString::fromStdString(text));
 
   m_Controls.m_lineEditDataLabel->setText("test" + QString::number(countForUID));
 
   numbers = GenerateRandomNumbers(10, 10.0);
   text = ConvertToText(numbers);
   m_Controls.m_lineEditXErrorPlus->setText(QString::fromStdString(text));
   numbers = GenerateRandomNumbers(10, 10.0);
   text = ConvertToText(numbers);
   m_Controls.m_lineEditXErrorMinus->setText(QString::fromStdString(text));
   numbers = GenerateRandomNumbers(10, 10.0);
   text = ConvertToText(numbers);
   m_Controls.m_lineEditYErrorPlus->setText(QString::fromStdString(text));
   numbers = GenerateRandomNumbers(10, 10.0);
   text = ConvertToText(numbers);
   m_Controls.m_lineEditYErrorMinus->setText(QString::fromStdString(text));
 
   countForUID++;
 }
 
 void ChartExample::CreateChart()
 {
   auto dataYAxisScaleType =
     m_AxisScaleNameToAxisScaleType.at(m_Controls.m_comboBoxYAxisScale->currentText().toStdString());
   auto xAxisLabel = m_Controls.m_lineEditXAxisLabel->text().toStdString();
   auto yAxisLabel = m_Controls.m_lineEditYAxisLabel->text().toStdString();
   auto showLegend = m_Controls.m_checkBoxShowLegend->isChecked();
   auto legendPosition =
     m_LegendPositionNameToLegendPositionType.at(m_Controls.m_comboBoxLegendPosition->currentText().toStdString());
   auto showDataPoints = m_Controls.m_checkBoxShowDataPoints->isChecked();
   auto stackedData = m_Controls.m_checkBoxStackedData->isChecked();
   auto showSubchart = m_Controls.m_checkBoxShowSubchart->isChecked();
   auto title = m_Controls.m_lineEditTitle->text().toStdString();
 
   m_Controls.m_Chart->SetTitle(title);
   m_Controls.m_Chart->SetYAxisScale(dataYAxisScaleType);
   m_Controls.m_Chart->SetXAxisLabel(xAxisLabel);
   m_Controls.m_Chart->SetYAxisLabel(yAxisLabel);
   m_Controls.m_Chart->SetShowLegend(showLegend);
   m_Controls.m_Chart->SetLegendPosition(legendPosition);
   m_Controls.m_Chart->SetShowErrorBars(true);
   m_Controls.m_Chart->SetShowDataPoints(showDataPoints);
   m_Controls.m_Chart->SetStackedData(stackedData);
   m_Controls.m_Chart->Show(showSubchart);
 }
 
 void ChartExample::UpdateChart() {
   // Test update mechanism
   m_Controls.m_Chart->SetLineStyle("test0", QmitkChartWidget::LineStyle::dashed);
   m_Controls.m_Chart->SetChartType("test0", QmitkChartWidget::ChartType::spline);
   m_Controls.m_Chart->SetColor("test0", "violet");
   m_Controls.m_Chart->UpdateData2D({{0, 1}, {0.1, 2}, {0.2, 3}, {8, -2} }, "test0");
   m_Controls.m_Chart->UpdateLabel("test0", "newLabel");
 }
 
 void ChartExample::ClearChart()
 {
   m_Controls.m_Chart->Clear();
   m_Controls.m_plainTextEditDataView->clear();
 }
 
 std::vector<double> ChartExample::ConvertToDoubleVector(const QString &data, QChar delimiter) const
 {
   std::vector<double> output;
   if (data.isEmpty())
   {
     return output;
   }
 
   for (const QString entry : data.split(delimiter))
   {
     output.push_back(entry.toDouble());
   }
   return output;
 }
 
 std::vector<std::string> ChartExample::ConvertToStringVector(const QString &data, QChar delimiter) const
 {
   std::vector<std::string> output;
   if (data.isEmpty())
   {
     return output;
   }
 
   for (const QString entry : data.split(delimiter))
   {
     output.push_back(entry.toStdString());
   }
   return output;
 }
 
 void ChartExample::AddData()
 {
   QString data = m_Controls.m_lineEditDataYVector->text();
   auto dataY = ConvertToDoubleVector(data);
 
   auto chartType = m_ChartNameToChartType.at(m_Controls.m_comboBoxChartType->currentText().toStdString());
   std::string dataLabel = m_Controls.m_lineEditDataLabel->text().toStdString();
   std::string dataColor = m_Controls.m_lineEditColor->text().toStdString();
   auto dataLineStyleType = m_LineNameToLineType.at(m_Controls.m_comboBoxLineStyle->currentText().toStdString());
 
   if (m_Controls.m_checkBoxEnableDataX->isChecked())
   {
     QString lineEditDataX = m_Controls.m_lineEditDataXVector->text();
     auto dataX = ConvertToDoubleVector(lineEditDataX);
     if (dataX.size() != dataY.size())
     {
       mitkThrow() << "data x and y size have to be equal";
     }
     auto dataXandY = CreateMap(dataX, dataY);
     data = QString::fromStdString(ConvertToText(dataXandY));
 
     m_Controls.m_Chart->AddData2D(dataXandY, dataLabel, chartType);
   }
   else
   {
     m_Controls.m_Chart->AddData1D(dataY, dataLabel, chartType);
   }
   if (!dataColor.empty())
   {
     m_Controls.m_Chart->SetColor(dataLabel, dataColor);
   }
 
   if (chartType == QmitkChartWidget::ChartType::pie)
   {
     QString pieLabelsData = m_Controls.m_lineEditPieDataLabel->text();
     if (!pieLabelsData.isEmpty())
     {
       auto pieLabels = ConvertToStringVector(pieLabelsData);
       m_Controls.m_Chart->SetPieLabels(pieLabels, dataLabel);
     }
   }
 
   if (m_Controls.m_checkBoxEnableErrors->isChecked())
   {
     if (m_Controls.m_checkBoxEnableXErrors->isChecked())
     {
       auto errorsPlus = ConvertToDoubleVector(m_Controls.m_lineEditXErrorPlus->text());
       auto errorsMinus = ConvertToDoubleVector(m_Controls.m_lineEditXErrorMinus->text());
       m_Controls.m_Chart->SetXErrorBars(m_Controls.m_lineEditDataLabel->text().toStdString(), errorsPlus, errorsMinus);
     }
     if (m_Controls.m_checkBoxEnableYErrors->isChecked())
     {
       auto errorsPlus = ConvertToDoubleVector(m_Controls.m_lineEditYErrorPlus->text());
       auto errorsMinus = ConvertToDoubleVector(m_Controls.m_lineEditYErrorMinus->text());
       m_Controls.m_Chart->SetYErrorBars(m_Controls.m_lineEditDataLabel->text().toStdString(), errorsPlus, errorsMinus);
     }
   }
 
   m_Controls.m_Chart->SetLineStyle(dataLabel, dataLineStyleType);
 
   QString dataOverview;
   dataOverview.append(m_Controls.m_lineEditDataLabel->text());
   dataOverview.append("(").append(m_Controls.m_comboBoxChartType->currentText());
   if (!dataColor.empty())
   {
     dataOverview.append(", ").append(dataColor.c_str());
   }
   dataOverview.append(", ").append(m_Controls.m_comboBoxLineStyle->currentText());
   dataOverview.append(")");
   dataOverview.append(":").append(data);
 
   m_Controls.m_plainTextEditDataView->appendPlainText(dataOverview);
 
   FillRandomDataValues();
 }
 
 void ChartExample::ShowXData(bool show)
 {
   m_Controls.m_lineEditDataXVector->setVisible(show);
 }
 
 void ChartExample::ShowErrorOptions(bool show)
 {
   m_Controls.m_groupBoxErrors->setVisible(show);
 }
 
 void ChartExample::ShowXErrorOptions(bool show)
 {
   m_Controls.m_groupBoxXErrors->setVisible(show);
 }
 
 void ChartExample::ShowYErrorOptions(bool show)
 {
   m_Controls.m_groupBoxYErrors->setVisible(show);
 }
 
 void ChartExample::AdaptZoomX()
 {
   m_Controls.m_Chart->SetMinMaxValueXView(m_Controls.m_doubleSpinBox_minZoomX->value(),
                                              m_Controls.m_doubleSpinBox_maxZoomX->value());
   m_Controls.m_Chart->Show();
 }
 
 void ChartExample::AdaptZoomY()
 {
   m_Controls.m_Chart->SetMinMaxValueYView(m_Controls.m_doubleSpinBox_minZoomY->value(),
                                              m_Controls.m_doubleSpinBox_maxZoomY->value());
   m_Controls.m_Chart->Show();
 }
 
 void ChartExample::AdaptDataGUI(const QString &chartType)
 {
   ResetDataGUI();
   auto chartTypeEnum = m_ChartNameToChartType.at(chartType.toStdString());
   if (chartTypeEnum == QmitkChartWidget::ChartType::pie)
   {
     m_Controls.m_labelPieData->setVisible(true);
     m_Controls.m_lineEditPieDataLabel->setVisible(true);
     m_Controls.m_labelColor->setVisible(false);
     m_Controls.m_lineEditColor->setVisible(false);
   }
   else if (chartTypeEnum == QmitkChartWidget::ChartType::line || chartTypeEnum == QmitkChartWidget::ChartType::area ||
            chartTypeEnum == QmitkChartWidget::ChartType::area_spline ||
            chartTypeEnum == QmitkChartWidget::ChartType::spline)
   {
     m_Controls.m_labelLineStyle->setVisible(true);
     m_Controls.m_comboBoxLineStyle->setVisible(true);
   }
 }
 
 void ChartExample::ResetDataGUI() {
   m_Controls.m_labelPieData->setVisible(false);
   m_Controls.m_lineEditPieDataLabel->setVisible(false);
   m_Controls.m_labelColor->setVisible(true);
   m_Controls.m_lineEditColor->setVisible(true);
   m_Controls.m_labelLineStyle->setVisible(false);
   m_Controls.m_comboBoxLineStyle->setVisible(false);
 }
 
 std::vector<double> ChartExample::GenerateRandomNumbers(unsigned int amount, double max) const
 {
   QRandomGenerator gen;
-  gen.seed(time(NULL));
+  gen.seed(time(nullptr));
 
   std::vector<double> data;
   for (unsigned int i = 0; i < amount; i++)
   {
     data.push_back(gen.bounded(max));
   }
 
   return data;
 }
 
 std::map<double, double> ChartExample::CreateMap(std::vector<double> keys, std::vector<double> values) const
 {
   std::map<double, double> aMap;
   std::transform(keys.begin(), keys.end(), values.begin(), std::inserter(aMap, aMap.end()), [](double a, double b) {
     return std::make_pair(a, b);
   });
   return aMap;
 }
 
 std::string ChartExample::ConvertToText(std::vector<double> numbers, std::string delimiter) const
 {
   std::ostringstream oss;
   oss.precision(3);
 
   if (!numbers.empty())
   {
     for (auto number : numbers)
     {
       oss << number << delimiter;
     }
   }
   auto aString = oss.str();
   aString.pop_back();
   return aString;
 }
 
 std::string ChartExample::ConvertToText(std::map<double, double> numbers, std::string delimiter) const
 {
   std::ostringstream oss;
   oss.precision(3);
 
   if (!numbers.empty())
   {
     for (const auto keyValue : numbers)
     {
       oss << keyValue.first << ":" << keyValue.second << delimiter;
     }
   }
   auto aString = oss.str();
   aString.pop_back();
   return aString;
 }
 
 QmitkChartWidget::ColorTheme ChartExample::GetColorTheme() const
 {
   ctkPluginContext *context = berry::WorkbenchPlugin::GetDefault()->GetPluginContext();
   ctkServiceReference styleManagerRef = context->getServiceReference<berry::IQtStyleManager>();
   if (styleManagerRef)
   {
     auto styleManager = context->getService<berry::IQtStyleManager>(styleManagerRef);
     if (styleManager->GetStyle().name == "Dark")
     {
       return QmitkChartWidget::ColorTheme::darkstyle;
     }
     else
     {
       return QmitkChartWidget::ColorTheme::lightstyle;
     }
   }
   return QmitkChartWidget::ColorTheme::darkstyle;
 }
 
 void ChartExample::OnLegendPositionChanged(const QString &newText)
 {
   auto legendPosition = m_LegendPositionNameToLegendPositionType.at(newText.toStdString());
   m_Controls.m_Chart->SetLegendPosition(legendPosition);
 }
 
 void ChartExample::OnTitleChanged() {
   auto newTitle = m_Controls.m_lineEditTitle->text();
   m_Controls.m_Chart->SetTitle(newTitle.toStdString());
 }
 
 void ChartExample::OnXAxisLabelChanged() {
   auto newXAxisLabel = m_Controls.m_lineEditXAxisLabel->text();
   m_Controls.m_Chart->SetXAxisLabel(newXAxisLabel.toStdString());
 }
 
 void ChartExample::OnYAxisLabelChanged() {
   auto newYAxisLabel = m_Controls.m_lineEditYAxisLabel->text();
   m_Controls.m_Chart->SetYAxisLabel(newYAxisLabel.toStdString());
 }
 
 void ChartExample::OnYAxisScaleChanged(const QString &newYAxisScale) {
   auto yAxisScale = m_AxisScaleNameToAxisScaleType.at(newYAxisScale.toStdString());
   m_Controls.m_Chart->SetYAxisScale(yAxisScale);
 }
 
 void ChartExample::OnShowLegendChanged(int newState) {
   m_Controls.m_Chart->SetShowLegend(newState == Qt::Checked);
 }
 
 void ChartExample::OnStackedDataChanged(int newState) {
   m_Controls.m_Chart->SetStackedData(newState == Qt::Checked);
 }
 
 void ChartExample::OnShowDataPointsChanged(int newState) {
   m_Controls.m_Chart->SetShowDataPoints(newState == Qt::Checked);
 }
 
 void ChartExample::OnShowSubchartChanged(int newState) {
   m_Controls.m_Chart->SetShowSubchart(newState == Qt::Checked);
 }
diff --git a/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationRegionGrow.cpp b/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationRegionGrow.cpp
index e4cea81ee2..adb6b34650 100644
--- a/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationRegionGrow.cpp
+++ b/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationRegionGrow.cpp
@@ -1,628 +1,628 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 // STD
 #include <stack>
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "ClassificationRegionGrow.h"
 
 // Qt
 #include <QMessageBox>
 #include <qgroupbox.h>
 #include <qsignalmapper.h>
 
 //mitk image
 #include <mitkImage.h>
 #include <QmitkDataStorageComboBox.h>
 //#include <ctkSliderWidget.h>
 //#include <mitkPointSet.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateOr.h>
 #include "mitkVigraRandomForestClassifier.h"
 #include "mitkCLUtil.h"
 #include "qboxlayout.h"
 #include <mitkIOUtil.h>
 
 #include "Eigen/Dense"
 
 #include <mitkImageAccessByItk.h>
 #include <mitkSliceNavigationController.h>
 #include <vnl/vnl_random.h>
 
 #include <itkNeighborhoodFunctorImageFilter.h>
 #include <itkFirstOrderStatisticsFeatureFunctor.h>
 #include <itkNeighborhood.h>
 #include <itkHessianMatrixEigenvalueImageFilter.h>
 #include <itkStructureTensorEigenvalueImageFilter.h>
 #include <itkLineHistogramBasedMassImageFilter.h>
 #include <mitkHistogramGenerator.h>
 
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionConstIterator.h>
 
 //#include <mitkRandomForestAccurecyWeighting.h>
 #include "mitkLabelSetImage.h"
 //#include <vigra\multi_array.hxx>
 
 #include <mitkLookupTable.h>
 #include <mitkLookupTableProperty.h>
 
 #include <QFuture>
 #include <QFutureWatcher>
 #include <QtConcurrentRun>
 //#include <mitkPointSetDataInteractor.h>
 #include <QmitkIOUtil.h>
 const std::string ClassificationRegionGrow::VIEW_ID = "org.mitk.views.ClassificationRegionGrow";
 
 void ClassificationRegionGrow::SetFocus()
 {
   //  m_Controls.buttonPerformImageProcessing->setFocus();
 }
 
 void ClassificationRegionGrow::CreateQtPartControl( QWidget *parent )
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
   m_CalculateFeatures = true;
   m_BlockManualSegmentation = false;
   m_BlockPostProcessing = false;
 
   m_Controls.groupLearningParameter->setVisible(false);
   m_Controls.groupFeatureSelection->setVisible(false);
 
   QmitkDataStorageComboBox * cb_inputimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::Image>::New());
   QmitkDataStorageComboBox * cb_maskimage= new QmitkDataStorageComboBox(this->GetDataStorage(),mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
   QmitkDataStorageComboBox * cb_baseimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
 
   m_Controls.m_InputImageLayout->addWidget(cb_inputimage);
   m_Controls.m_MaskImageLayout->addWidget(cb_maskimage);
   m_Controls.StartingPointLayout->addWidget(cb_baseimage);
   m_Controls.addInputButton->setIcon(QIcon::fromTheme("list-add"));
   m_Controls.removeInputButton->setIcon(QIcon::fromTheme("edit-delete"));
 
   connect( cb_inputimage, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnInitializeSession(const mitk::DataNode*)));
   connect( cb_maskimage, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnInitializeSession(const mitk::DataNode*)));
   connect(m_Controls.SelectAdvancedParameter, SIGNAL(toggled(bool)), m_Controls.groupLearningParameter, SLOT(setVisible(bool)));
   connect(m_Controls.SelectAdvancedParameter, SIGNAL(toggled(bool)), m_Controls.groupFeatureSelection, SLOT(setVisible(bool)));
   connect(m_Controls.SelectSimpleParameters, SIGNAL(toggled(bool)), m_Controls.parameterWidget, SLOT(setVisible(bool)));
   connect(m_Controls.m_DoAutomaticSecmentation, SIGNAL( clicked()), this, SLOT(DoAutomSegmentation()));
   connect(m_Controls.removeInputButton, SIGNAL(clicked()), this, SLOT(RemoveItemFromLabelList()));
   connect(m_Controls.addInputButton, SIGNAL(clicked()), this, SLOT(AddInputField()));
 
   connect(m_Controls.UseIntensity, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.Gauss1, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.Gauss2, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.Gauss3, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.Gauss4, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.Gauss5, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.DoG1, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.DoG2, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.DoG3, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.DoG4, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.DoG5, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LoG1, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LoG2, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LoG3, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LoG4, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LoG5, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.HoG1, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.HoG2, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.HoG3, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.HoG4, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.HoG5, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LH1, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LH2, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LH3, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LH4, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
 }
 
 void ClassificationRegionGrow::AddInputField()
 {
   QmitkDataStorageComboBox * cb_inputimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::Image>::New());
   //QPushButton * lockButton = new QPushButton();
   //lockButton->setText("");
   //lockButton->setMinimumWidth(40);
   //lockButton->setCheckable(true);
   //lockButton->setIcon(QApplication::style()->standardIcon(QStyle::SP_MediaStop));
 
   QHBoxLayout *layout = new QHBoxLayout;
   layout->addWidget(cb_inputimage,100);
   //layout->addWidget(lockButton,1);
   m_Controls.m_InputImageLayout->addLayout(layout);
   connect(cb_inputimage, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnInitializeSession(const mitk::DataNode*)));
 }
 
 void ClassificationRegionGrow::RemoveItemFromLabelList()
 {
   auto numberOfElements = m_Controls.m_InputImageLayout->count();
   auto lastItem = m_Controls.m_InputImageLayout->itemAt(numberOfElements-1);
   QHBoxLayout *layout = dynamic_cast<QHBoxLayout *>(lastItem);
   while (QLayoutItem* item = layout->takeAt(0))
   {
     if (QWidget* widget = item->widget())
         widget->deleteLater();
     delete item;
   }
   m_Controls.m_InputImageLayout->removeItem(lastItem);
   delete lastItem;
 
 }
 
 void ClassificationRegionGrow::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*source*/,
                                                      const QList<mitk::DataNode::Pointer>& nodes )
 {
   // iterate all selected objects, adjust warning visibility
   foreach( mitk::DataNode::Pointer node, nodes )
   {
     if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
       return;
     }
   }
 }
 
 void ClassificationRegionGrow::OnInitializeSession(const mitk::DataNode *)
 {
   OnFeatureSettingsChanged();
 }
 
 void ClassificationRegionGrow::ProcessFeatureImages(const mitk::Image::Pointer & raw_image)
 {
   // RAW
   if (m_Controls.UseIntensity->isChecked()) {
     m_FeatureImageVector.push_back(raw_image);
   }
 
   // GAUSS
   if (m_Controls.Gauss1->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::GaussianFilter(raw_image, smoothed, 1);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.Gauss2->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::GaussianFilter(raw_image, smoothed, 2);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.Gauss3->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::GaussianFilter(raw_image, smoothed, 3);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.Gauss4->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::GaussianFilter(raw_image, smoothed, 4);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.Gauss5->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::GaussianFilter(raw_image, smoothed, 5);
     m_FeatureImageVector.push_back(smoothed);
   }
 
   // Difference of Gaussian
   if (m_Controls.DoG1->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::DifferenceOfGaussianFilter(raw_image, smoothed, 1,0.8);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.DoG2->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::DifferenceOfGaussianFilter(raw_image, smoothed, 2, 1.8);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.DoG3->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::DifferenceOfGaussianFilter(raw_image, smoothed, 3, 2.6);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.DoG4->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::DifferenceOfGaussianFilter(raw_image, smoothed, 4, 3.4);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.DoG5->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::DifferenceOfGaussianFilter(raw_image, smoothed, 5, 4.3);
     m_FeatureImageVector.push_back(smoothed);
   }
 
   // Laplacian of Gaussian
   if (m_Controls.LoG1->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::LaplacianOfGaussianFilter(raw_image, smoothed, 1);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.LoG2->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::LaplacianOfGaussianFilter(raw_image, smoothed, 2);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.LoG3->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::LaplacianOfGaussianFilter(raw_image, smoothed, 3);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.LoG4->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::LaplacianOfGaussianFilter(raw_image, smoothed, 4);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.LoG5->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::LaplacianOfGaussianFilter(raw_image, smoothed, 5);
     m_FeatureImageVector.push_back(smoothed);
   }
 
   // Hessian of Gaussian
   if (m_Controls.HoG1->isChecked())
   {
     mitk::CLUtil::HessianOfGaussianFilter(raw_image, m_FeatureImageVector, 1);
   }
   if (m_Controls.HoG2->isChecked())
   {
     mitk::CLUtil::HessianOfGaussianFilter(raw_image, m_FeatureImageVector, 2);
   }
   if (m_Controls.HoG3->isChecked())
   {
     mitk::CLUtil::HessianOfGaussianFilter(raw_image, m_FeatureImageVector, 3);
   }
   if (m_Controls.HoG4->isChecked())
   {
     mitk::CLUtil::HessianOfGaussianFilter(raw_image, m_FeatureImageVector, 4);
   }
   if (m_Controls.HoG5->isChecked())
   {
     mitk::CLUtil::HessianOfGaussianFilter(raw_image, m_FeatureImageVector, 5);
   }
 
   // LocalHistogram
   if (m_Controls.LH1->isChecked())
   {
     mitk::CLUtil::LocalHistogram(raw_image, m_FeatureImageVector, 5,3);
   }
   if (m_Controls.LH2->isChecked())
   {
     mitk::CLUtil::LocalHistogram(raw_image, m_FeatureImageVector, 5, 5);
   }
   if (m_Controls.LH3->isChecked())
   {
     mitk::CLUtil::LocalHistogram(raw_image, m_FeatureImageVector, 10, 3);
   }
   if (m_Controls.LH4->isChecked())
   {
     mitk::CLUtil::LocalHistogram(raw_image, m_FeatureImageVector, 10, 5);
   }
 }
 
 void ClassificationRegionGrow::OnFeatureSettingsChanged()
 {
   MITK_INFO << "FeatureSettingsChanged";
   m_CalculateFeatures = true;
 }
 
 void ClassificationRegionGrow::DoAutomSegmentation()
 {
   MITK_INFO << "Start Automatic Segmentation ...";
   // Load Images from registration process
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls.m_InputImageLayout->itemAt(1)->widget());
   QmitkDataStorageComboBox * cb_maskimage = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls.m_MaskImageLayout->itemAt(1)->widget());
   mitk::Image::Pointer raw_image;
   mitk::Image::Pointer mask_image;
-  if ((cb_image != NULL) || (cb_maskimage != NULL))
+  if ((cb_image != nullptr) || (cb_maskimage != nullptr))
   {
     raw_image = dynamic_cast<mitk::Image *>(cb_image->GetSelectedNode()->GetData());
     mask_image = dynamic_cast<mitk::Image *>(cb_maskimage->GetSelectedNode()->GetData());
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the images that shlould be used.");
     msgBox.exec();
     return;
   }
 
   if (raw_image.IsNull() || mask_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
     return;
   }
 
   std::vector<mitk::Image::Pointer> imageList;
   imageList.push_back(raw_image);
   for (int i = 2; i < m_Controls.m_InputImageLayout->count(); ++i)
   {
     QLayout* layout = dynamic_cast<QLayout*>(m_Controls.m_InputImageLayout->itemAt(i));
     MITK_INFO << layout;
     QmitkDataStorageComboBox * tmp_cb_image = dynamic_cast<QmitkDataStorageComboBox *>(layout->itemAt(0)->widget());
     MITK_INFO << tmp_cb_image;
     if (tmp_cb_image)
     {
       mitk::Image::Pointer tmp_image = dynamic_cast<mitk::Image *>(tmp_cb_image);
         if (tmp_image.IsNotNull())
       {
         MITK_INFO << "Adding Image...";
         imageList.push_back(tmp_image);
       }
     }
   }
 
   MITK_INFO << "Start Feature Calculation ...";
   if(m_CalculateFeatures)
   {
     m_FeatureImageVector.clear();
     for (auto img : imageList)
     {
       ProcessFeatureImages(img);
     }
     m_CalculateFeatures = false;
     if (m_Controls.checkAddFeaturesToDataManager->isChecked())
     {
       for (std::size_t i = 0; i < m_FeatureImageVector.size(); ++i)
       {
         auto newName = "Feature_" + std::to_string(i);
         AddAsDataNode(m_FeatureImageVector[i].GetPointer(), newName);
       }
     }
   }
 
   MITK_INFO << "Start Classifier Training ...";
   TrainClassifier(raw_image, mask_image);
 
   MITK_INFO << "Predict extended Segmentation ...";
   PredictSegmentation(raw_image, mask_image);
 }
 
 
 void ClassificationRegionGrow::TrainClassifier(const mitk::Image::Pointer & raw_image, const mitk::Image::Pointer & mask_image)
 {
   typedef itk::Image<double, 3> DoubleImageType;
   typedef itk::Image<short, 3> ShortImageType;
 
   DoubleImageType::Pointer input;
   ShortImageType::Pointer mask;
   mitk::CastToItkImage(raw_image, input);
   mitk::CastToItkImage(mask_image, mask);
 
   int numberOfSegmentedVoxel = 0;
   int numberOfFeatures = m_FeatureImageVector.size();
 
   auto maskIter = itk::ImageRegionConstIteratorWithIndex<ShortImageType>(mask, mask->GetLargestPossibleRegion());
   m_SegmentedLocations.clear();
   m_SegmentedOrganLocations.clear();
 
   MITK_INFO << "Count Segmentation Size ...";
   while ( ! maskIter.IsAtEnd())
   {
     if (maskIter.Value() > 0)
     {
       m_SegmentedLocations.push_back(maskIter.GetIndex());
       numberOfSegmentedVoxel++;
       if (maskIter.Value() > 1)
       {
         m_SegmentedOrganLocations.push_back(maskIter.GetIndex());
       }
     }
     ++maskIter;
   }
   MITK_INFO << "Sizes: " << numberOfSegmentedVoxel << " " << m_SegmentedOrganLocations.size();
 
   Eigen::MatrixXi Y_train = mitk::CLUtil::Transform<int>(mask_image, mask_image);
   Eigen::MatrixXd X_train = Eigen::MatrixXd(numberOfSegmentedVoxel, numberOfFeatures);
   unsigned int index = 0;
 
   MITK_INFO << "Convert Training Data to Eigen Matrix ...";
   for (const auto & image : m_FeatureImageVector)
   {
     X_train.col(index) = mitk::CLUtil::Transform<double>(image, mask_image);
     ++index;
   }
 
   MITK_INFO << "Classifier Training ...";
   m_Classifier = mitk::VigraRandomForestClassifier::New();
   //this->m_Controls.Maximum
   m_Classifier->SetTreeCount(m_Controls.NumberOfTrees->value());
   m_Classifier->SetSamplesPerTree(m_Controls.SamplesPerTree->value());
   m_Classifier->SetMinimumSplitNodeSize(m_Controls.MinimumSamplesPerNode->value());
   m_Classifier->SetMaximumTreeDepth(m_Controls.MaximumTreeDepth->value());
   m_Classifier->Train(X_train, Y_train);
 }
 
 static void addNeighbours(std::stack<itk::Index<3> > &stack, itk::Index<3> idx)
 {
   idx[0] -= 1;
   stack.push(idx);
   idx[0] += 2;
   stack.push(idx);
   idx[0] -= 1;
   idx[1] -= 1;
   stack.push(idx);
   idx[1] += 2;
   stack.push(idx);
   idx[1] -= 1;
   idx[2] -= 1;
   stack.push(idx);
   idx[2] += 2;
   stack.push(idx);
 }
 
 void ClassificationRegionGrow::PredictSegmentation(const mitk::Image::Pointer & raw_image, const mitk::Image::Pointer & mask_image)
 {
   typedef itk::Image<double, 3> DoubleImageType;
   typedef itk::Image<unsigned short, 3> ShortImageType;
 
   DoubleImageType::Pointer input;
   ShortImageType::Pointer mask;
   mitk::CastToItkImage(raw_image, input);
   mitk::CastToItkImage(mask_image, mask);
 
   std::vector<DoubleImageType::Pointer > featureImages;
   for (auto fimage : m_FeatureImageVector)
   {
     DoubleImageType::Pointer feature;
     mitk::CastToItkImage(fimage, feature);
     featureImages.push_back(feature);
   }
 
   ShortImageType::Pointer usedLocation = ShortImageType::New();
   usedLocation->SetRegions(mask->GetLargestPossibleRegion());
   usedLocation->Allocate();
   usedLocation->FillBuffer(0);
 
   ShortImageType::Pointer resultSegmentation = ShortImageType::New();
   if (m_Controls.UpdateImage->isChecked()) {
     QmitkDataStorageComboBox * cb_maskimage = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls.StartingPointLayout->itemAt(2)->widget());
     mitk::Image::Pointer base_image = dynamic_cast<mitk::Image *>(cb_maskimage->GetSelectedNode()->GetData());
     mitk::CastToItkImage(base_image, resultSegmentation);
   }
   else {
 
     resultSegmentation->SetRegions(mask->GetLargestPossibleRegion());
     resultSegmentation->Allocate();
     if (m_Controls.SegmentBackground->isChecked())
     {
       resultSegmentation->FillBuffer(1);
     }
     else {
       resultSegmentation->FillBuffer(0);
     }
   }
 
   // Fill list of Stacks
   std::vector<std::stack<itk::Index<3> > > listOfStacks;
   while (m_SegmentedOrganLocations.size() > 0)
   {
     auto currentLocation = m_SegmentedOrganLocations.back();
     m_SegmentedOrganLocations.pop_back();
     std::size_t cValue = mask->GetPixel(currentLocation);
     resultSegmentation->SetPixel(currentLocation, cValue);
     usedLocation->SetPixel(currentLocation, 1000);
     while (listOfStacks.size() < cValue+1)
     {
       listOfStacks.push_back(std::stack<itk::Index<3> >());
     }
     addNeighbours(listOfStacks[cValue],currentLocation);
   }
 
 
   int countPredicted = 0;
   bool connectAllLabels = m_Controls.localGrowing->isChecked();
   //m_SegmentedOrganLocations.reserve(10000);
 
   Eigen::MatrixXd currentX = Eigen::MatrixXd(1, featureImages.size());
   vigra::MultiArrayView<2, double> X(vigra::Shape2(currentX.rows(), currentX.cols()), currentX.data());
   auto outLabel = Eigen::MatrixXi(currentX.rows(), 1);
   vigra::MultiArrayView<2, int> Y(vigra::Shape2(currentX.rows(), 1), outLabel.data());
   for (std::size_t i = 2; i < listOfStacks.size(); ++i)
   {
     while (listOfStacks[i].size() > 0)
     {
       auto currentLocation = listOfStacks[i].top();
       listOfStacks[i].pop();
       if (!mask->GetLargestPossibleRegion().IsInside(currentLocation))
       {
         continue;
       }
       if (usedLocation->GetPixel(currentLocation) > i)
       {
         continue;
       }
       usedLocation->SetPixel(currentLocation, i+1);
 
 
       for (std::size_t f = 0; f < featureImages.size(); ++f)
       {
         currentX(0, f) = featureImages[f]->GetPixel(currentLocation);
       }
 
       m_Classifier->GetRandomForest().predictLabels(X, Y);
       ++countPredicted;
       if ((static_cast<unsigned int>(Y(0, 0)) ==  i ) ||
         ((Y(0, 0) > 1) && (connectAllLabels)))
       {
         resultSegmentation->SetPixel(currentLocation, std::abs(Y(0, 0)));
         addNeighbours(listOfStacks[i], currentLocation);
       }
     }
   }
   MITK_INFO << "Number of Predictions: " << countPredicted;
 
   MITK_INFO << "Finished Segmentation...";
   mitk::Image::Pointer result;
   mitk::CastToMitkImage(resultSegmentation, result);
   result->SetOrigin(raw_image->GetGeometry()->GetOrigin());
   result->SetSpacing(raw_image->GetGeometry()->GetSpacing());
   mitk::LabelSetImage::Pointer labelResult = mitk::LabelSetImage::New();
   labelResult->InitializeByLabeledImage(result);
   mitk::LabelSetImage::Pointer oldLabelSet = dynamic_cast<mitk::LabelSetImage *>(mask_image.GetPointer());
   labelResult->AddLabelSetToLayer(labelResult->GetActiveLayer(),oldLabelSet->GetLabelSet());
   MITK_INFO << "Passing Back...";
   AddAsDataNode(labelResult.GetPointer(), "ResultSegmentation");
 }
 
 mitk::DataNode::Pointer ClassificationRegionGrow::AddAsDataNode(const mitk::BaseData::Pointer & data_, const std::string & name )
 {
   mitk::DataNode::Pointer node = nullptr;
   node = this->GetDataStorage()->GetNamedNode(name);
 
   if(node.IsNull())
   {
     node = mitk::DataNode::New();
     node->SetData(data_);
     node->SetName(name);
     this->GetDataStorage()->Add(node);
   }else{
 
     if(dynamic_cast<mitk::Image*>(node->GetData()) && dynamic_cast<mitk::Image*>(data_.GetPointer()))
     {
       mitk::Image::Pointer target_image = dynamic_cast<mitk::Image*>(node->GetData());
       mitk::Image::Pointer source_image = dynamic_cast<mitk::Image*>(data_.GetPointer());
       mitk::ImageReadAccessor ra(source_image);
       target_image->SetImportVolume(const_cast<void *>(ra.GetData()));
       this->RequestRenderWindowUpdate();
     }
 
     if(dynamic_cast<mitk::VigraRandomForestClassifier*>(node->GetData()) && dynamic_cast<mitk::VigraRandomForestClassifier*>(data_.GetPointer()))
     {
       node->SetData(data_);
       node->Modified();
     }
 
   }
 
   return node;
 }
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality.cpp b/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality.cpp
index 6ac4554f6a..fe77299439 100755
--- a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality.cpp
+++ b/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality.cpp
@@ -1,379 +1,379 @@
 /*===================================================================
 
 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 "QmitkFunctionality.h"
 #include "internal/QmitkFunctionalityUtil.h"
 #include "internal/QmitkCommonLegacyActivator.h"
 
 // other includes
 #include <mitkLogMacros.h>
 
 // mitk Includes
 #include <mitkIDataStorageService.h>
 #include <mitkDataStorageEditorInput.h>
 
 // berry Includes
 #include <berryIWorkbenchPage.h>
 #include <berryIBerryPreferences.h>
 #include <berryIEditorPart.h>
 #include <berryPlatform.h>
 
 // Qmitk Includes
 #include <QmitkStdMultiWidgetEditor.h>
 
 // Qt Includes
 #include <QMessageBox>
 #include <QScrollArea>
 #include <QVBoxLayout>
 #include <QApplication>
 
 QmitkFunctionality::QmitkFunctionality()
- : m_Parent(0)
+ : m_Parent(nullptr)
  , m_Active(false)
  , m_Visible(false)
- , m_SelectionProvider(0)
+ , m_SelectionProvider(nullptr)
  , m_DataStorageServiceTracker(QmitkCommonLegacyActivator::GetContext())
  , m_HandlesMultipleDataStorages(false)
  , m_InDataStorageChanged(false)
 {
   m_DataStorageServiceTracker.open();
 }
 
 void QmitkFunctionality::SetHandleMultipleDataStorages(bool multiple)
 {
   m_HandlesMultipleDataStorages = multiple;
 }
 
 bool QmitkFunctionality::HandlesMultipleDataStorages() const
 {
   return m_HandlesMultipleDataStorages;
 }
 
 mitk::DataStorage::Pointer
 QmitkFunctionality::GetDataStorage() const
 {
   mitk::IDataStorageService* service = m_DataStorageServiceTracker.getService();
 
-  if (service != 0)
+  if (service != nullptr)
   {
     if(m_HandlesMultipleDataStorages)
       return service->GetActiveDataStorage()->GetDataStorage();
     else
       return service->GetDefaultDataStorage()->GetDataStorage();
   }
 
-  return 0;
+  return nullptr;
 }
 
 mitk::DataStorage::Pointer QmitkFunctionality::GetDefaultDataStorage() const
 {
   mitk::IDataStorageService* service = m_DataStorageServiceTracker.getService();
 
-  if (service != 0)
+  if (service != nullptr)
   {
     return service->GetDefaultDataStorage()->GetDataStorage();
   }
 
-  return 0;
+  return nullptr;
 }
 
 mitk::IDataStorageReference::Pointer QmitkFunctionality::GetDataStorageReference() const
 {
   mitk::IDataStorageService* dsService = m_DataStorageServiceTracker.getService();
 
-  if (dsService != 0)
+  if (dsService != nullptr)
   {
     return dsService->GetDataStorage();
   }
 
-  return mitk::IDataStorageReference::Pointer(0);
+  return mitk::IDataStorageReference::Pointer(nullptr);
 }
 
 void QmitkFunctionality::CreatePartControl(QWidget* parent)
 {
 
   // scrollArea
   QScrollArea* scrollArea = new QScrollArea;
   //QVBoxLayout* scrollAreaLayout = new QVBoxLayout(scrollArea);
   scrollArea->setFrameShadow(QFrame::Plain);
   scrollArea->setFrameShape(QFrame::NoFrame);
   scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
   scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
 
   // m_Parent
   m_Parent = new QWidget;
   //m_Parent->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding));
   this->CreateQtPartControl(m_Parent);
 
   //scrollAreaLayout->addWidget(m_Parent);
   //scrollArea->setLayout(scrollAreaLayout);
 
   // set the widget now
   scrollArea->setWidgetResizable(true);
   scrollArea->setWidget(m_Parent);
 
   // add the scroll area to the real parent (the view tabbar)
   QWidget* parentQWidget = static_cast<QWidget*>(parent);
   QVBoxLayout* parentLayout = new QVBoxLayout(parentQWidget);
   parentLayout->setMargin(0);
   parentLayout->setSpacing(0);
   parentLayout->addWidget(scrollArea);
 
   // finally set the layout containing the scroll area to the parent widget (= show it)
   parentQWidget->setLayout(parentLayout);
 
   this->AfterCreateQtPartControl();
 }
 
 void QmitkFunctionality::AfterCreateQtPartControl()
 {
   // REGISTER DATASTORAGE LISTENER
   this->GetDefaultDataStorage()->AddNodeEvent.AddListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
     ( this, &QmitkFunctionality::NodeAddedProxy ) );
   this->GetDefaultDataStorage()->ChangedNodeEvent.AddListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
     ( this, &QmitkFunctionality::NodeChangedProxy ) );
   this->GetDefaultDataStorage()->RemoveNodeEvent.AddListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
     ( this, &QmitkFunctionality::NodeRemovedProxy ) );
 
   // REGISTER PREFERENCES LISTENER
   berry::IBerryPreferences::Pointer prefs = this->GetPreferences().Cast<berry::IBerryPreferences>();
   if(prefs.IsNotNull())
     prefs->OnChanged.AddListener(berry::MessageDelegate1<QmitkFunctionality
     , const berry::IBerryPreferences*>(this, &QmitkFunctionality::OnPreferencesChanged));
 
   // REGISTER FOR WORKBENCH SELECTION EVENTS
   m_BlueBerrySelectionListener.reset(new berry::SelectionChangedAdapter<QmitkFunctionality>(
                                        this,
                                        &QmitkFunctionality::BlueBerrySelectionChanged)
                                      );
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(
         /*"org.mitk.views.datamanager",*/ m_BlueBerrySelectionListener.data());
 
   // REGISTER A SELECTION PROVIDER
   QmitkFunctionalitySelectionProvider::Pointer _SelectionProvider(
         new QmitkFunctionalitySelectionProvider(this));
   m_SelectionProvider = _SelectionProvider.GetPointer();
   this->GetSite()->SetSelectionProvider(berry::ISelectionProvider::Pointer(m_SelectionProvider));
 
   // EMULATE INITIAL SELECTION EVENTS
 
   // by default a a multi widget is always available
   this->StdMultiWidgetAvailable(*this->GetActiveStdMultiWidget());
 
   // send datamanager selection
   this->OnSelectionChanged(this->GetDataManagerSelection());
 
   // send preferences changed event
   this->OnPreferencesChanged(this->GetPreferences().Cast<berry::IBerryPreferences>().GetPointer());
 }
 
 void QmitkFunctionality::ClosePart()
 {
 
 }
 
 void QmitkFunctionality::ClosePartProxy()
 {
   this->GetDefaultDataStorage()->AddNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
     ( this, &QmitkFunctionality::NodeAddedProxy ) );
   this->GetDefaultDataStorage()->RemoveNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
     ( this, &QmitkFunctionality::NodeRemovedProxy) );
   this->GetDefaultDataStorage()->ChangedNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
     ( this, &QmitkFunctionality::NodeChangedProxy ) );
 
   berry::IBerryPreferences::Pointer prefs = this->GetPreferences().Cast<berry::IBerryPreferences>();
   if(prefs.IsNotNull())
   {
     prefs->OnChanged.RemoveListener(berry::MessageDelegate1<QmitkFunctionality
     , const berry::IBerryPreferences*>(this, &QmitkFunctionality::OnPreferencesChanged));
     // flush the preferences here (disabled, everyone should flush them by themselves at the right moment)
     // prefs->Flush();
   }
 
   // REMOVE SELECTION PROVIDER
   this->GetSite()->SetSelectionProvider(berry::ISelectionProvider::Pointer(nullptr));
 
   berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   if(s)
   {
     s->RemovePostSelectionListener(m_BlueBerrySelectionListener.data());
   }
 
   this->ClosePart();
 }
 
 QmitkFunctionality::~QmitkFunctionality()
 {
   this->Register();
   this->ClosePartProxy();
 
   this->UnRegister(false);
 
   m_DataStorageServiceTracker.close();
 }
 
 void QmitkFunctionality::OnPreferencesChanged( const berry::IBerryPreferences* )
 {
 }
 
 void QmitkFunctionality::BlueBerrySelectionChanged(const berry::IWorkbenchPart::Pointer& sourcepart,
                                                    const berry::ISelection::ConstPointer& selection)
 {
   if(sourcepart.IsNull() || sourcepart->GetSite()->GetId() != "org.mitk.views.datamanager")
     return;
 
   mitk::DataNodeSelection::ConstPointer _DataNodeSelection
     = selection.Cast<const mitk::DataNodeSelection>();
   this->OnSelectionChanged(this->DataNodeSelectionToVector(_DataNodeSelection));
 }
 
 bool QmitkFunctionality::IsVisible() const
 {
   return m_Visible;
 }
 
 void QmitkFunctionality::SetFocus()
 {
 }
 
 void QmitkFunctionality::Activated()
 {
 }
 
 void QmitkFunctionality::Deactivated()
 {
 }
 
 void QmitkFunctionality::StdMultiWidgetAvailable( QmitkStdMultiWidget&  /*stdMultiWidget*/ )
 {
 }
 void QmitkFunctionality::StdMultiWidgetNotAvailable()
 {
 }
 
 void QmitkFunctionality::DataStorageChanged()
 {
 
 }
 
 QmitkStdMultiWidget* QmitkFunctionality::GetActiveStdMultiWidget( bool reCreateWidget )
 {
-  QmitkStdMultiWidget* activeStdMultiWidget = 0;
+  QmitkStdMultiWidget* activeStdMultiWidget = nullptr;
 
   berry::IEditorPart::Pointer editor =
     this->GetSite()->GetPage()->GetActiveEditor();
 
   if (reCreateWidget
       || editor.Cast<QmitkStdMultiWidgetEditor>().IsNull()
      )
   {
     mitk::DataStorageEditorInput::Pointer editorInput(
           new mitk::DataStorageEditorInput( this->GetDataStorageReference() ));
     // open a new multi-widget editor, but do not give it the focus
     berry::IEditorPart::Pointer editor = this->GetSite()->GetPage()->OpenEditor(editorInput, QmitkStdMultiWidgetEditor::EDITOR_ID, false, berry::IWorkbenchPage::MATCH_ID);
     activeStdMultiWidget = editor.Cast<QmitkStdMultiWidgetEditor>()->GetStdMultiWidget();
   }
   else if (editor.Cast<QmitkStdMultiWidgetEditor>().IsNotNull())
   {
     activeStdMultiWidget = editor.Cast<QmitkStdMultiWidgetEditor>()->GetStdMultiWidget();
   }
 
   return activeStdMultiWidget;
 }
 
 void QmitkFunctionality::HandleException( const char* str, QWidget* parent, bool showDialog ) const
 {
   //itkGenericOutputMacro( << "Exception caught: " << str );
   MITK_ERROR << str;
   if ( showDialog )
   {
     QMessageBox::critical ( parent, "Exception caught!", str );
   }
 }
 
 void QmitkFunctionality::HandleException( std::exception& e, QWidget* parent, bool showDialog ) const
 {
   HandleException( e.what(), parent, showDialog );
 }
 
 void QmitkFunctionality::StdMultiWidgetClosed( QmitkStdMultiWidget&  /*stdMultiWidget*/ )
 {
 
 }
 
 void QmitkFunctionality::WaitCursorOn()
 {
   QApplication::setOverrideCursor( QCursor(Qt::WaitCursor) );
 }
 
 void QmitkFunctionality::BusyCursorOn()
 {
   QApplication::setOverrideCursor( QCursor(Qt::BusyCursor) );
 }
 
 void QmitkFunctionality::WaitCursorOff()
 {
   this->RestoreOverrideCursor();
 }
 
 void QmitkFunctionality::BusyCursorOff()
 {
   this->RestoreOverrideCursor();
 }
 
 void QmitkFunctionality::RestoreOverrideCursor()
 {
   QApplication::restoreOverrideCursor();
 }
 
 berry::IPreferences::Pointer QmitkFunctionality::GetPreferences() const
 {
   berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService();
   // const_cast workaround for bad programming: const uncorrectness this->GetViewSite() should be const
   QString id = "/" + (const_cast<QmitkFunctionality*>(this))->GetViewSite()->GetId();
-  return prefService != nullptr ? prefService->GetSystemPreferences()->Node(id): berry::IPreferences::Pointer(0);
+  return prefService != nullptr ? prefService->GetSystemPreferences()->Node(id): berry::IPreferences::Pointer(nullptr);
 }
 
 void QmitkFunctionality::Visible()
 {
 
 }
 
 void QmitkFunctionality::Hidden()
 {
 
 }
 
 bool QmitkFunctionality::IsExclusiveFunctionality() const
 {
   return true;
 }
 
 void QmitkFunctionality::SetVisible( bool visible )
 {
   m_Visible = visible;
 }
 
 void QmitkFunctionality::SetActivated( bool activated )
 {
   m_Active = activated;
 }
 
 bool QmitkFunctionality::IsActivated() const
 {
   return m_Active;
 }
 
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality2.cpp b/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality2.cpp
index b1ffc8b8a2..e00d9f4900 100644
--- a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality2.cpp
+++ b/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality2.cpp
@@ -1,142 +1,142 @@
 /*===================================================================
 
 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 "QmitkFunctionality.h"
 #include "internal/QmitkFunctionalityUtil.h"
 
 #include <berryIWorkbenchWindow.h>
 #include <berryISelectionService.h>
 
 #include <mitkDataNodeObject.h>
 
 std::vector<mitk::DataNode*> QmitkFunctionality::GetCurrentSelection() const
 {
   berry::ISelection::ConstPointer selection( this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection());
   // buffer for the data manager selection
   mitk::DataNodeSelection::ConstPointer currentSelection = selection.Cast<const mitk::DataNodeSelection>();
   return this->DataNodeSelectionToVector(currentSelection);
 }
 
 std::vector<mitk::DataNode*> QmitkFunctionality::GetDataManagerSelection() const
 {
   berry::ISelection::ConstPointer selection( this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
     // buffer for the data manager selection
   mitk::DataNodeSelection::ConstPointer currentSelection = selection.Cast<const mitk::DataNodeSelection>();
   return this->DataNodeSelectionToVector(currentSelection);
 }
 
 void QmitkFunctionality::OnSelectionChanged(std::vector<mitk::DataNode*> /*nodes*/)
 {
 }
 
 std::vector<mitk::DataNode*> QmitkFunctionality::DataNodeSelectionToVector(mitk::DataNodeSelection::ConstPointer currentSelection) const
 {
 
   std::vector<mitk::DataNode*> selectedNodes;
   if(currentSelection.IsNull())
     return selectedNodes;
 
-  mitk::DataNodeObject* _DataNodeObject = 0;
-  mitk::DataNode* _DataNode = 0;
+  mitk::DataNodeObject* _DataNodeObject = nullptr;
+  mitk::DataNode* _DataNode = nullptr;
 
   for(mitk::DataNodeSelection::iterator it = currentSelection->Begin();
     it != currentSelection->End(); ++it)
   {
     _DataNodeObject = dynamic_cast<mitk::DataNodeObject*>((*it).GetPointer());
     if(_DataNodeObject)
     {
       _DataNode = _DataNodeObject->GetDataNode();
       if(_DataNode)
         selectedNodes.push_back(_DataNode);
     }
   }
 
   return selectedNodes;
 }
 
 void QmitkFunctionality::NodeAddedProxy( const mitk::DataNode* node )
 {
   // garantuee no recursions when a new node event is thrown in NodeAdded()
   if(!m_InDataStorageChanged)
   {
     m_InDataStorageChanged = true;
     this->NodeAdded(node);
     this->DataStorageChanged();
     m_InDataStorageChanged = false;
   }
 
 }
 
 void QmitkFunctionality::NodeAdded( const mitk::DataNode*  /*node*/ )
 {
 
 }
 
 void QmitkFunctionality::NodeRemovedProxy( const mitk::DataNode* node )
 {
   // garantuee no recursions when a new node event is thrown in NodeAdded()
   if(!m_InDataStorageChanged)
   {
     m_InDataStorageChanged = true;
     this->NodeRemoved(node);
     this->DataStorageChanged();
     m_InDataStorageChanged = false;
   }
 }
 
 void QmitkFunctionality::NodeRemoved( const mitk::DataNode*  /*node*/ )
 {
 
 }
 
 void QmitkFunctionality::NodeChanged( const mitk::DataNode* /*node*/ )
 {
 
 }
 
 void QmitkFunctionality::NodeChangedProxy( const mitk::DataNode* node )
 {
   // garantuee no recursions when a new node event is thrown in NodeAdded()
   if(!m_InDataStorageChanged)
   {
     m_InDataStorageChanged = true;
     this->NodeChanged(node);
     this->DataStorageChanged();
     m_InDataStorageChanged = false;
   }
 }
 
 void QmitkFunctionality::FireNodeSelected( mitk::DataNode* node )
 {
   std::vector<mitk::DataNode*> nodes;
   nodes.push_back(node);
   this->FireNodesSelected(nodes);
 }
 
 void QmitkFunctionality::FireNodesSelected( std::vector<mitk::DataNode*> nodes )
 {
   if( !m_SelectionProvider )
     return;
 
   std::vector<mitk::DataNode::Pointer> nodesSmartPointers;
   for (std::vector<mitk::DataNode*>::iterator it = nodes.begin()
     ; it != nodes.end(); it++)
   {
     nodesSmartPointers.push_back( *it );
   }
   m_SelectionProvider->FireNodesSelected(nodesSmartPointers);
 
 }
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionalityCoordinator.cpp b/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionalityCoordinator.cpp
index 0386f218c4..ff628d221b 100644
--- a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionalityCoordinator.cpp
+++ b/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionalityCoordinator.cpp
@@ -1,220 +1,220 @@
 /*===================================================================
 
 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 "QmitkFunctionalityCoordinator.h"
 #include "QmitkFunctionality.h"
 #include <QmitkStdMultiWidgetEditor.h>
 #include <berryPlatformUI.h>
 #include <berryIWorkbenchPage.h>
 
 #include <mitkIZombieViewPart.h>
 
 QmitkFunctionalityCoordinator::QmitkFunctionalityCoordinator()
-  : m_StandaloneFuntionality(0)
+  : m_StandaloneFuntionality(nullptr)
 {
 }
 
 void QmitkFunctionalityCoordinator::Start()
 {
   berry::PlatformUI::GetWorkbench()->AddWindowListener(this);
   QList<berry::IWorkbenchWindow::Pointer> wnds(berry::PlatformUI::GetWorkbench()->GetWorkbenchWindows());
   for (auto i = wnds.begin(); i != wnds.end(); ++i)
   {
     (*i)->GetPartService()->AddPartListener(this);
   }
 }
 
 void QmitkFunctionalityCoordinator::Stop()
 {
   if (!berry::PlatformUI::IsWorkbenchRunning()) return;
 
   berry::PlatformUI::GetWorkbench()->RemoveWindowListener(this);
   QList<berry::IWorkbenchWindow::Pointer> wnds(berry::PlatformUI::GetWorkbench()->GetWorkbenchWindows());
   for (auto i = wnds.begin(); i != wnds.end(); ++i)
   {
     (*i)->GetPartService()->RemovePartListener(this);
   }
 }
 
 QmitkFunctionalityCoordinator::~QmitkFunctionalityCoordinator()
 {
 }
 
 berry::IPartListener::Events::Types QmitkFunctionalityCoordinator::GetPartEventTypes() const
 {
   return berry::IPartListener::Events::ACTIVATED | berry::IPartListener::Events::DEACTIVATED
     | berry::IPartListener::Events::CLOSED | berry::IPartListener::Events::HIDDEN
     | berry::IPartListener::Events::VISIBLE | berry::IPartListener::Events::OPENED;
 }
 
 void QmitkFunctionalityCoordinator::PartActivated( const berry::IWorkbenchPartReference::Pointer& partRef )
 {
   // change the active standalone functionality
   this->ActivateStandaloneFunctionality(partRef.GetPointer());
 }
 
 void QmitkFunctionalityCoordinator::PartDeactivated( const berry::IWorkbenchPartReference::Pointer& /*partRef*/ )
 {
   // nothing to do here: see PartActivated()
 }
 
 void QmitkFunctionalityCoordinator::PartOpened( const berry::IWorkbenchPartReference::Pointer& partRef )
 {
    // check for multiwidget and inform views that it is available now
   if ( partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID )
   {
     for (std::set<QmitkFunctionality*>::iterator it = m_Functionalities.begin()
       ; it != m_Functionalities.end(); it++)
     {
       (*it)->StdMultiWidgetAvailable(*(partRef
         ->GetPart(false).Cast<QmitkStdMultiWidgetEditor>()->GetStdMultiWidget()));
     }
   }
   else
   {
     // Check for QmitkFunctionality
     QmitkFunctionality::Pointer _QmitkFunctionality = partRef->GetPart(false).Cast<QmitkFunctionality>();
     if(_QmitkFunctionality.IsNotNull())
     {
       m_Functionalities.insert(_QmitkFunctionality.GetPointer()); // save as opened functionality
     }
   }
 }
 
 void QmitkFunctionalityCoordinator::PartClosed( const berry::IWorkbenchPartReference::Pointer& partRef )
 {
   // check for multiwidget and inform views that it not available any more
   if ( partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID )
   {
 
     QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
     for (std::set<QmitkFunctionality*>::iterator it = m_Functionalities.begin()
       ; it != m_Functionalities.end(); it++)
     {
       (*it)->StdMultiWidgetClosed(*(stdMultiWidgetEditor->GetStdMultiWidget()));
       (*it)->StdMultiWidgetNotAvailable(); // deprecated call, provided for consistence
     }
   }
   else
   {
     // check for functionality
     QmitkFunctionality::Pointer _QmitkFunctionality = partRef->GetPart(false).Cast<QmitkFunctionality>();
     if(_QmitkFunctionality.IsNotNull())
     {
       // deactivate on close ( the standalone functionality may still be activated  )
-      this->DeactivateStandaloneFunctionality(partRef.GetPointer(), 0);
+      this->DeactivateStandaloneFunctionality(partRef.GetPointer(), nullptr);
 
       // and set pointer to 0
       if(m_StandaloneFuntionality == partRef.GetPointer())
-        m_StandaloneFuntionality = 0;
+        m_StandaloneFuntionality = nullptr;
 
       m_Functionalities.erase(_QmitkFunctionality.GetPointer()); // remove as opened functionality
 
       // call PartClosed on the QmitkFunctionality
       _QmitkFunctionality->ClosePartProxy();
       //m_VisibleStandaloneFunctionalities.erase(_QmitkFunctionality.GetPointer()); // remove if necessary (should be done before in PartHidden()
     }
   }
 }
 
 void QmitkFunctionalityCoordinator::PartHidden( const berry::IWorkbenchPartReference::Pointer& partRef )
 {
   // Check for QmitkFunctionality
   QmitkFunctionality::Pointer _QmitkFunctionality = partRef->GetPart(false).Cast<QmitkFunctionality>();
   if(_QmitkFunctionality != 0)
   {
     _QmitkFunctionality->SetVisible(false);
     _QmitkFunctionality->Hidden();
 
     // tracking of Visible Standalone Functionalities
     m_VisibleStandaloneFunctionalities.erase(partRef.GetPointer());
 
     // activate Functionality if just one Standalone Functionality is visible
     if( m_VisibleStandaloneFunctionalities.size() == 1 )
       this->ActivateStandaloneFunctionality( *m_VisibleStandaloneFunctionalities.begin() );
   }
 }
 
 void QmitkFunctionalityCoordinator::PartVisible( const berry::IWorkbenchPartReference::Pointer& partRef )
 {
   // Check for QmitkFunctionality
   QmitkFunctionality::Pointer _QmitkFunctionality = partRef->GetPart(false).Cast<QmitkFunctionality>();
   if(_QmitkFunctionality.IsNotNull())
   {
     _QmitkFunctionality->SetVisible(true);
     _QmitkFunctionality->Visible();
 
     // tracking of Visible Standalone Functionalities
     if( _QmitkFunctionality->IsExclusiveFunctionality() )
     {
       m_VisibleStandaloneFunctionalities.insert(partRef.GetPointer());
 
       // activate Functionality if just one Standalone Functionality is visible
       if( m_VisibleStandaloneFunctionalities.size() == 1 )
         this->ActivateStandaloneFunctionality( *m_VisibleStandaloneFunctionalities.begin() );
     }
   }
 }
 
 void QmitkFunctionalityCoordinator::ActivateStandaloneFunctionality( berry::IWorkbenchPartReference* partRef )
 {
   QmitkFunctionality* functionality = dynamic_cast<QmitkFunctionality*>(partRef->GetPart(false).GetPointer());
   if( functionality && !functionality->IsActivated() && functionality->IsExclusiveFunctionality() )
   {
     MITK_INFO << "**** Activating legacy standalone functionality";
     // deactivate old one if necessary
     this->DeactivateStandaloneFunctionality(m_StandaloneFuntionality, partRef);
     m_StandaloneFuntionality = partRef;
 
     MITK_INFO << "setting active flag";
     // call activated on this functionality
     functionality->SetActivated(true);
     functionality->Activated();
   }
   else if (dynamic_cast<mitk::IZombieViewPart*>(partRef->GetPart(false).GetPointer()) &&
            m_StandaloneFuntionality != partRef)
   {
     this->DeactivateStandaloneFunctionality(m_StandaloneFuntionality, partRef);
     m_StandaloneFuntionality = partRef;
   }
 }
 
 void QmitkFunctionalityCoordinator::DeactivateStandaloneFunctionality(berry::IWorkbenchPartReference* partRef,
                                                                       berry::IWorkbenchPartReference* newRef)
 {
-  if (partRef == 0) return;
+  if (partRef == nullptr) return;
 
   QmitkFunctionality* functionality = dynamic_cast<QmitkFunctionality*>(partRef->GetPart(false).GetPointer());
   if(functionality && functionality->IsActivated())
   {
     functionality->SetActivated(false);
     functionality->Deactivated();
   }
   else if (mitk::IZombieViewPart* zombie = dynamic_cast<mitk::IZombieViewPart*>(partRef->GetPart(false).GetPointer()))
   {
     zombie->ActivatedZombieView(berry::IWorkbenchPartReference::Pointer(newRef));
   }
 }
 
 void QmitkFunctionalityCoordinator::WindowClosed(const berry::IWorkbenchWindow::Pointer& /*window*/ )
 {
 
 }
 
 void QmitkFunctionalityCoordinator::WindowOpened(const berry::IWorkbenchWindow::Pointer& window )
 {
   window->GetPartService()->AddPartListener(this);
 }
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkFunctionalityUtil.cpp b/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkFunctionalityUtil.cpp
index 6015d8301e..3d63594e20 100644
--- a/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkFunctionalityUtil.cpp
+++ b/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkFunctionalityUtil.cpp
@@ -1,62 +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.
 
 ===================================================================*/
 
 
 #include "QmitkFunctionalityUtil.h"
 
 #include "../QmitkFunctionality.h"
 
 QmitkFunctionalitySelectionProvider::QmitkFunctionalitySelectionProvider( QmitkFunctionality* _Functionality )
 : m_Functionality(_Functionality)
 {
 
 }
 
 QmitkFunctionalitySelectionProvider::~QmitkFunctionalitySelectionProvider()
 {
-  m_Functionality = 0;
+  m_Functionality = nullptr;
 }
 
 void QmitkFunctionalitySelectionProvider::AddSelectionChangedListener( berry::ISelectionChangedListener* listener )
 {
   m_SelectionEvents.AddListener(listener);
 }
 
 
 berry::ISelection::ConstPointer QmitkFunctionalitySelectionProvider::GetSelection() const
 {
   return m_CurrentSelection;
 }
 
 void QmitkFunctionalitySelectionProvider::RemoveSelectionChangedListener( berry::ISelectionChangedListener* listener )
 {
   m_SelectionEvents.RemoveListener(listener);
 }
 
 void QmitkFunctionalitySelectionProvider::SetSelection(const berry::ISelection::ConstPointer& selection )
 {
   m_CurrentSelection = selection.Cast<const mitk::DataNodeSelection>();
 }
 
 void QmitkFunctionalitySelectionProvider::FireNodesSelected(const std::vector<mitk::DataNode::Pointer>& nodes )
 {
   mitk::DataNodeSelection::Pointer sel(new mitk::DataNodeSelection(nodes));
   m_CurrentSelection = sel;
   berry::SelectionChangedEvent::Pointer event(new berry::SelectionChangedEvent(berry::ISelectionProvider::Pointer(this)
     , m_CurrentSelection));
   m_SelectionEvents.selectionChanged(event);
 
 }
diff --git a/Plugins/org.mitk.gui.qt.common/src/internal/QmitkNodeSelectionPreferencePage.cpp b/Plugins/org.mitk.gui.qt.common/src/internal/QmitkNodeSelectionPreferencePage.cpp
index 75d0b203d0..d70886a4e7 100644
--- a/Plugins/org.mitk.gui.qt.common/src/internal/QmitkNodeSelectionPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/internal/QmitkNodeSelectionPreferencePage.cpp
@@ -1,198 +1,198 @@
 /*===================================================================
 
 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 "QmitkNodeSelectionPreferencePage.h"
 
 #include "QmitkNodeSelectionPreferenceHelper.h"
 
 //-----------------------------------------------------------------------------
 QmitkNodeSelectionPreferencePage::QmitkNodeSelectionPreferencePage()
-  : m_MainControl(0), m_Controls(0)
+  : m_MainControl(nullptr), m_Controls(nullptr)
 {
 
 }
 
 
 //-----------------------------------------------------------------------------
 QmitkNodeSelectionPreferencePage::~QmitkNodeSelectionPreferencePage()
 {
   delete m_Controls;
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkNodeSelectionPreferencePage::Init(berry::IWorkbench::Pointer )
 {
 
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkNodeSelectionPreferencePage::CreateQtControl(QWidget* parent)
 {
   m_MainControl = new QWidget(parent);
   m_Controls = new Ui::QmitkNodeSelectionPreferencePage;
   m_Controls->setupUi( m_MainControl );
 
   connect(m_Controls->comboFavorite, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateWidgets()));
   connect(m_Controls->btnUp, SIGNAL(clicked(bool)), this, SLOT(MoveUp()));
   connect(m_Controls->btnDown, SIGNAL(clicked(bool)), this, SLOT(MoveDown()));
   connect(m_Controls->listInspectors, SIGNAL(itemSelectionChanged()), this, SLOT(UpdateWidgets()));
 
   this->Update();
 }
 
 
 //-----------------------------------------------------------------------------
 QWidget* QmitkNodeSelectionPreferencePage::GetQtControl() const
 {
   return m_MainControl;
 }
 
 //-----------------------------------------------------------------------------
 bool QmitkNodeSelectionPreferencePage::PerformOk()
 {
   //store favorite
   auto id = m_Controls->comboFavorite->currentData().toString();
   mitk::PutFavoriteDataStorageInspector(id.toStdString());
 
   //store visible
   mitk::VisibleDataStorageInspectorMapType visibles;
 
   unsigned int visiblePos = 0;
 
   for (int i = 0; i < m_Controls->listInspectors->count(); ++i)
   {
     auto item = m_Controls->listInspectors->item(i);
     if (item->checkState() == Qt::Checked)
     {
       visibles.insert(std::make_pair(visiblePos++, item->data(Qt::UserRole).toString().toStdString()));
     }
   }
   mitk::PutVisibleDataStorageInspectors(visibles);
 
   return true;
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkNodeSelectionPreferencePage::PerformCancel()
 {
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkNodeSelectionPreferencePage::Update()
 {
   m_Providers = mitk::DataStorageInspectorGenerator::GetProviders();
 
   auto visibleProviders = mitk::GetVisibleDataStorageInspectors();
   auto allProviders = mitk::DataStorageInspectorGenerator::GetProviders();
   auto favorite = mitk::GetFavoriteDataStorageInspector();
 
   auto finding = m_Providers.find(favorite);
   if (finding == m_Providers.cend())
   {
     favorite = m_Providers.begin()->first;
   }
 
   //fill favorite combo
   int index = 0;
   int currentIndex = 0;
   m_Controls->comboFavorite->clear();
   for (auto iter : m_Providers)
   {
     m_Controls->comboFavorite->addItem(QString::fromStdString(iter.second->GetInspectorDisplayName()),QVariant::fromValue(QString::fromStdString(iter.first)));
     if (iter.first == favorite)
     {
       currentIndex = index;
     };
     ++index;
   }
   m_Controls->comboFavorite->setCurrentIndex(currentIndex);
 
   //fill inspector list
   m_Controls->listInspectors->clear();
   for (const auto iter : allProviders)
   {
     auto currentID = iter.first;
     QListWidgetItem* item = new QListWidgetItem;
     item->setText(QString::fromStdString(iter.second->GetInspectorDisplayName()));
     item->setData(Qt::UserRole, QVariant::fromValue(QString::fromStdString(currentID)));
     item->setToolTip(QString::fromStdString(iter.second->GetInspectorDescription()));
 
     auto finding = std::find_if(visibleProviders.cbegin(), visibleProviders.cend(), [&currentID](auto v) {return v.second == currentID; });
     if (finding == visibleProviders.cend())
     {
       item->setCheckState(Qt::Unchecked);
       m_Controls->listInspectors->addItem(item);
     }
     else
     {
       item->setCheckState(Qt::Checked);
       m_Controls->listInspectors->insertItem(finding->first, item);
     }
   }
 
   this->UpdateWidgets();
 }
 
 void QmitkNodeSelectionPreferencePage::UpdateWidgets()
 {
   int currentIndex = m_Controls->listInspectors->currentRow();
   m_Controls->btnUp->setEnabled(!m_Controls->listInspectors->selectedItems().empty() && currentIndex > 0);
   m_Controls->btnDown->setEnabled(!m_Controls->listInspectors->selectedItems().empty() && currentIndex + 1 < m_Controls->listInspectors->count());
 
   for (int i = 0; i < m_Controls->listInspectors->count(); ++i)
   {
     auto item = m_Controls->listInspectors->item(i);
     if (item->data(Qt::UserRole).toString() == m_Controls->comboFavorite->currentData().toString())
     {
       //favorites are always visible.
       item->setCheckState(Qt::Checked);
       item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled);
     }
     else
     {
       item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled | Qt::ItemIsUserCheckable);
     }
   }
 };
 
 void QmitkNodeSelectionPreferencePage::MoveDown()
 {
   int currentIndex = m_Controls->listInspectors->currentRow();
   if (currentIndex+1 < m_Controls->listInspectors->count())
   {
     QListWidgetItem *currentItem = m_Controls->listInspectors->takeItem(currentIndex);
     m_Controls->listInspectors->insertItem(currentIndex + 1, currentItem);
     m_Controls->listInspectors->setCurrentRow(currentIndex + 1);
   }
   this->UpdateWidgets();
 };
 
 void QmitkNodeSelectionPreferencePage::MoveUp()
 {
   int currentIndex = m_Controls->listInspectors->currentRow();
   if (currentIndex > 0)
   {
     QListWidgetItem *currentItem = m_Controls->listInspectors->takeItem(currentIndex);
     m_Controls->listInspectors->insertItem(currentIndex - 1, currentItem);
     m_Controls->listInspectors->setCurrentRow(currentIndex - 1);
   }
   this->UpdateWidgets();
 };
diff --git a/Plugins/org.mitk.gui.qt.datamanagerlight/src/internal/QmitkDataManagerLightView.cpp b/Plugins/org.mitk.gui.qt.datamanagerlight/src/internal/QmitkDataManagerLightView.cpp
index a72d62bc6e..508b0b96d0 100644
--- a/Plugins/org.mitk.gui.qt.datamanagerlight/src/internal/QmitkDataManagerLightView.cpp
+++ b/Plugins/org.mitk.gui.qt.datamanagerlight/src/internal/QmitkDataManagerLightView.cpp
@@ -1,257 +1,257 @@
 /*===================================================================
 
 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 "QmitkDataManagerLightView.h"
 #include "mitkNodePredicateDataType.h"
 #include <QApplication>
 #include <QFileDialog>
 #include <QGridLayout>
 #include <QIcon>
 #include <QLabel>
 #include <QListWidget>
 #include <QMessageBox>
 #include <QPushButton>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkIRenderingManager.h>
 #include <QmitkIOUtil.h>
 
 const std::string QmitkDataManagerLightView::VIEW_ID = "org.mitk.views.datamanagerlight";
 
 struct QmitkDataManagerLightViewData
 {
     // static
     mitk::NodePredicateBase::Pointer m_Predicate;
     QIcon m_ItemIcon;
 
     // data
     QList<mitk::DataNode*> m_DataNodes;
     int m_CurrentIndex;
 
     // widget
     QListWidget* m_ListWidget;
     QLabel* m_ImageInfoLabel;
     QPushButton* m_RemoveButton;
 
 };
 
 QmitkDataManagerLightView::QmitkDataManagerLightView()
     : d( new QmitkDataManagerLightViewData )
 {
     d->m_Predicate = mitk::NodePredicateDataType::New("Image");
     d->m_ItemIcon = QIcon(":/org.mitk.gui.qt.datamanagerlight/Image_24.png");
     d->m_CurrentIndex = -1;
-    d->m_ListWidget = 0;
-    d->m_ImageInfoLabel = 0;
-    d->m_RemoveButton = 0;
+    d->m_ListWidget = nullptr;
+    d->m_ImageInfoLabel = nullptr;
+    d->m_RemoveButton = nullptr;
 }
 
 QmitkDataManagerLightView::~QmitkDataManagerLightView()
 {
     delete d;
 }
 
 void QmitkDataManagerLightView::NodeAdded(const mitk::DataNode *node)
 {
     if( d->m_Predicate->CheckNode(node) )
     {
         mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
         d->m_DataNodes.append(nonConstNode);
         d->m_ListWidget->addItem( new QListWidgetItem( d->m_ItemIcon, QString::fromStdString( node->GetName() ) ) );
     }
 }
 
 void QmitkDataManagerLightView::NodeRemoved(const mitk::DataNode *node)
 {
     this->RemoveNode( const_cast<mitk::DataNode*>(node) );
 }
 
 void QmitkDataManagerLightView::NodeChanged(const mitk::DataNode *node)
 {
     MITK_DEBUG << "NodeChanged";
     if( d->m_DataNodes.contains(const_cast<mitk::DataNode*>(node)) )
         this->ToggleVisibility();
 }
 
 void QmitkDataManagerLightView::RemoveNode(mitk::DataNode *node)
 {
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
     int index = d->m_DataNodes.indexOf(nonConstNode);
     if( index >= 0 )
     {
         MITK_DEBUG << "removing node at: " << index;
         QListWidgetItem* item = d->m_ListWidget->takeItem(index);
         delete item;
 
         d->m_DataNodes.removeAt(index);
         MITK_DEBUG << "item deleted";
     }
 }
 
 void QmitkDataManagerLightView::CreateQtPartControl(QWidget* parent)
 {
 
     QPushButton* loadButton = new QPushButton(QIcon(":/org.mitk.gui.qt.datamanagerlight/Load_48.png"), "Load");
     d->m_RemoveButton = new QPushButton(QIcon(":/org.mitk.gui.qt.datamanagerlight/Remove_48.png"), "Remove");
     d->m_RemoveButton->setEnabled(false);
 
     d->m_ListWidget = new QListWidget;
 
     d->m_ImageInfoLabel = new QLabel;
 
     QGridLayout* layout = new QGridLayout;
     layout->addWidget( loadButton, 0,0 );
     layout->addWidget( d->m_RemoveButton, 0,1 );
     layout->addWidget( d->m_ImageInfoLabel, 1,0, 1, 2 );
     layout->addWidget( d->m_ListWidget, 2,0,1,2 );
 
     parent->setLayout(layout);
 
     connect(d->m_ListWidget, SIGNAL(currentRowChanged(int)), this, SLOT(on_DataItemList_currentRowChanged(int)) );
     connect(loadButton, SIGNAL(pressed()), this, SLOT(on_Load_pressed()) );
     connect(d->m_RemoveButton, SIGNAL(pressed()), this, SLOT(on_Remove_pressed()) );
 
     this->ListSelectionChanged();
 }
 
 void QmitkDataManagerLightView::SetFocus()
 {
     d->m_ListWidget->setFocus();
 }
 
 void QmitkDataManagerLightView::on_DataItemList_currentRowChanged(int currentRow)
 {
     MITK_DEBUG << "DataItemList currentRowChanged: " << currentRow;
     Q_UNUSED(currentRow)
 
     this->ListSelectionChanged();
 }
 
 void QmitkDataManagerLightView::ListSelectionChanged()
 {
     d->m_CurrentIndex = d->m_ListWidget->currentRow();
     MITK_DEBUG << "the currently selected index: " << d->m_CurrentIndex;
 
     QString newLabelText = "Current patient: ";
     if( d->m_CurrentIndex >= 0 )
     {
         // TODO WHERE IS THE PATIENT NAME?
         std::string name = d->m_DataNodes.at(d->m_CurrentIndex)->GetName();
         newLabelText.append( QString("<strong>%1</strong>" ).arg( QString::fromStdString(name) ) );
         d->m_RemoveButton->setEnabled(true);
     }
     else
     {
         newLabelText.append("<strong>Unknown</strong>");
         d->m_RemoveButton->setEnabled(false);
     }
     d->m_ImageInfoLabel->setText(newLabelText);
     this->ToggleVisibility();
 }
 
 void QmitkDataManagerLightView::on_Load_pressed()
 {
     MITK_DEBUG << "on_Load_pressed";
   QStringList fileNames = QFileDialog::getOpenFileNames(nullptr, "Load data", "", QmitkIOUtil::GetFileOpenFilterString());
   for ( QStringList::Iterator it = fileNames.begin(); it != fileNames.end(); ++it )
   {
-    FileOpen((*it).toLatin1(), 0);
+    FileOpen((*it).toLatin1(), nullptr);
   }
 }
 
 void QmitkDataManagerLightView::FileOpen( const char * fileName, mitk::DataNode* /*parentNode*/ )
 {
   try
   {
     QApplication::setOverrideCursor( QCursor(Qt::WaitCursor) );
     mitk::IOUtil::Load(fileName, *this->GetDataStorage());
     mitk::RenderingManager::GetInstance()->InitializeViews();
   }
   catch ( itk::ExceptionObject & ex )
   {
     MITK_ERROR << "Exception during file open: " << ex;
   }
 
   QApplication::restoreOverrideCursor();
 }
 
 void QmitkDataManagerLightView::on_Remove_pressed()
 {
     d->m_CurrentIndex = d->m_ListWidget->currentRow();
     MITK_DEBUG << "the currently selected index: " << d->m_CurrentIndex;
 
     mitk::DataNode* node = d->m_DataNodes.at(d->m_CurrentIndex);
     QString question = tr("Do you really want to remove ");
     // TODO patient name?
     question.append( QString::fromStdString( node->GetName() ) );
     question.append(" ?");
 
     QMessageBox::StandardButton answerButton = QMessageBox::question( nullptr
       , tr("DataManagerLight")
       , question
       , QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
     if(answerButton == QMessageBox::Yes)
     {
         this->GetDataStorage()->Remove(node);
         this->GlobalReinit();
     }
 }
 
 void QmitkDataManagerLightView::GlobalReinit()
 {
   mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
 
   // no render window available
   if (renderWindow == nullptr) return;
 
   // get all nodes that have not set "includeInBoundingBox" to false
   mitk::NodePredicateNot::Pointer pred
     = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
     , mitk::BoolProperty::New(false)));
 
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
   // calculate bounding geometry of these nodes
   auto bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
 
   // initialize the views to the bounding geometry
   renderWindow->GetRenderingManager()->InitializeViews(bounds);
 }
 
 void QmitkDataManagerLightView::ToggleVisibility()
 {
     bool changedAnything = false;
     bool isVisible = false;
     for(int i=0; i<d->m_DataNodes.size(); ++i)
     {
         isVisible = false;
-        d->m_DataNodes.at(i)->GetVisibility(isVisible, 0 );
+        d->m_DataNodes.at(i)->GetVisibility(isVisible, nullptr );
 
         if( d->m_CurrentIndex == i && isVisible == false )
         {
             d->m_DataNodes.at(i)->SetVisibility(true);
             changedAnything = true;
         }
         else if( d->m_CurrentIndex != i && isVisible == true )
         {
             d->m_DataNodes.at(i)->SetVisibility(false);
             changedAnything = true;
         }
     }
 
     if( changedAnything )
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
diff --git a/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/DoseVisualizationPreferencePage.cpp b/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/DoseVisualizationPreferencePage.cpp
index 100b81ce30..c56f622195 100644
--- a/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/DoseVisualizationPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/DoseVisualizationPreferencePage.cpp
@@ -1,391 +1,391 @@
 /*===================================================================
 
 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 "DoseVisualizationPreferencePage.h"
 #include "mitkRTUIConstants.h"
 
 #include <QWidget>
 #include <QMessageBox>
 #include <QInputDialog>
 #include <QMenu>
 
 #include <berryIPreferencesService.h>
 #include <berryPlatform.h>
 
 #include <QmitkDoseColorDelegate.h>
 #include <QmitkDoseValueDelegate.h>
 #include <QmitkDoseVisualStyleDelegate.h>
 #include <QmitkIsoDoseLevelSetModel.h>
 
 #include "mitkIsoLevelsGenerator.h"
 
 #include "org_mitk_gui_qt_dosevisualization_Activator.h"
 
 DoseVisualizationPreferencePage::DoseVisualizationPreferencePage()
-  : m_MainControl(0), m_Controls(0), m_referenceDoseChanged(false), m_presetMapChanged(false), m_globalVisChanged(false)
+  : m_MainControl(nullptr), m_Controls(nullptr), m_referenceDoseChanged(false), m_presetMapChanged(false), m_globalVisChanged(false)
 {
 
 }
 
 DoseVisualizationPreferencePage::~DoseVisualizationPreferencePage()
 {
   delete m_LevelSetModel;
   delete m_DoseColorDelegate;
   delete m_DoseValueDelegate;
   delete m_DoseVisualDelegate;
   delete m_Controls;
 }
 
 void DoseVisualizationPreferencePage::Init(berry::IWorkbench::Pointer )
 {
 
 }
 
 void DoseVisualizationPreferencePage::CreateQtControl(QWidget* parent)
 {
   berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService();
 
   m_DoseVisNode = prefService->GetSystemPreferences()->Node(mitk::RTUIConstants::ROOT_DOSE_VIS_PREFERENCE_NODE_ID.c_str());
 
   m_LevelSetModel = new QmitkIsoDoseLevelSetModel(this);
   m_DoseColorDelegate = new QmitkDoseColorDelegate(this);
   m_DoseValueDelegate = new QmitkDoseValueDelegate(this);
   m_DoseVisualDelegate = new QmitkDoseVisualStyleDelegate(this);
 
 
   m_MainControl = new QWidget(parent);
   m_Controls = new Ui::DoseVisualizationPreferencePageControls;
   m_Controls->setupUi( m_MainControl );
 
 
   this->m_Controls->isoLevelSetView->setModel(m_LevelSetModel);
   this->m_Controls->isoLevelSetView->setItemDelegateForColumn(0,m_DoseColorDelegate);
   this->m_Controls->isoLevelSetView->setItemDelegateForColumn(1,m_DoseValueDelegate);
   this->m_Controls->isoLevelSetView->setItemDelegateForColumn(2,m_DoseVisualDelegate);
   this->m_Controls->isoLevelSetView->setItemDelegateForColumn(3,m_DoseVisualDelegate);
   this->m_Controls->isoLevelSetView->setContextMenuPolicy(Qt::CustomContextMenu);
 
   connect(m_Controls->spinReferenceDose, SIGNAL(valueChanged(double)), m_LevelSetModel, SLOT(setReferenceDose(double)));
   connect(m_Controls->spinReferenceDose, SIGNAL(valueChanged(double)), this, SLOT(OnReferenceDoseChanged(double)));
   connect(m_Controls->checkGlobalSync, SIGNAL(toggled(bool)), m_Controls->spinReferenceDose, SLOT(setEnabled(bool)));
   connect(m_Controls->radioAbsDose, SIGNAL(toggled(bool)), m_LevelSetModel, SLOT(setShowAbsoluteDose(bool)));
   connect(m_Controls->isoLevelSetView, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(OnShowContextMenuIsoSet(const QPoint&)));
   connect(m_Controls->listPresets, SIGNAL(currentItemChanged ( QListWidgetItem *, QListWidgetItem *)), this, SLOT(OnCurrentItemChanged ( QListWidgetItem *, QListWidgetItem *)));
   connect(m_Controls->btnAddPreset, SIGNAL(clicked(bool)), this, SLOT(OnAddPresetClicked(bool)));
   connect(m_Controls->btnDelPreset, SIGNAL(clicked(bool)), this, SLOT(OnDelPresetClicked(bool)));
   connect(m_Controls->btnResetPreset, SIGNAL(clicked(bool)), this, SLOT(OnResetPresetClicked(bool)));
   connect(m_Controls->btnDelLevel, SIGNAL(clicked(bool)), this, SLOT(OnDelLevelClicked(bool)));
   connect(m_Controls->btnAddLevel, SIGNAL(clicked(bool)), this, SLOT(OnAddLevelClicked(bool)));
   connect(m_Controls->checkGlobalVisColorWash, SIGNAL(toggled(bool)), this, SLOT(OnGlobalVisChanged(bool)));
   connect(m_Controls->checkGlobalVisIsoLine, SIGNAL(toggled(bool)), this, SLOT(OnGlobalVisChanged(bool)));
 
   this->Update();
 }
 
 QWidget* DoseVisualizationPreferencePage::GetQtControl() const
 {
   return m_MainControl;
 }
 
 bool DoseVisualizationPreferencePage::PerformOk()
 {
   m_DoseVisNode->PutBool(mitk::RTUIConstants::DOSE_DISPLAY_ABSOLUTE_ID.c_str(),m_Controls->radioAbsDose->isChecked());
   m_DoseVisNode->PutBool(mitk::RTUIConstants::GLOBAL_VISIBILITY_COLORWASH_ID.c_str(),m_Controls->checkGlobalVisColorWash->isChecked());
   m_DoseVisNode->PutBool(mitk::RTUIConstants::GLOBAL_VISIBILITY_ISOLINES_ID.c_str(),m_Controls->checkGlobalVisIsoLine->isChecked());
   m_DoseVisNode->PutDouble(mitk::RTUIConstants::REFERENCE_DOSE_ID.c_str(),m_Controls->spinReferenceDose->value());
   m_DoseVisNode->PutBool(mitk::RTUIConstants::GLOBAL_REFERENCE_DOSE_SYNC_ID.c_str(), m_Controls->checkGlobalSync->isChecked());
 
   mitk::StorePresetsMap(this->m_Presets);
 
   if (this->m_Presets.find(this->m_selectedPresetName)==this->m_Presets.end())
   { //the preset currently selected in the application is not available any more. Change it to a valid one.
     mitk::SetSelectedPresetName(this->m_Presets.begin()->first);
   }
 
   if (this->m_LevelSetModel->isModified())
   {
     this->m_presetMapChanged = true;
   }
 
   if (m_referenceDoseChanged)
   {
     mitk::SignalReferenceDoseChange(m_Controls->checkGlobalSync->isChecked(), m_Controls->spinReferenceDose->value(), mitk::org_mitk_gui_qt_dosevisualization_Activator::GetContext());
   }
 
   if (m_presetMapChanged)
   {
     mitk::SignalPresetMapChange(mitk::org_mitk_gui_qt_dosevisualization_Activator::GetContext());
   }
 
   if(m_globalVisChanged)
   {
     mitk::SignalGlobalVisChange(m_Controls->checkGlobalSync->isChecked(), m_Controls->checkGlobalVisIsoLine->isChecked(), m_Controls->checkGlobalVisColorWash->isChecked(), mitk::org_mitk_gui_qt_dosevisualization_Activator::GetContext());
   }
 
   return true;
 }
 
 void DoseVisualizationPreferencePage::PerformCancel()
 {
 }
 
 void DoseVisualizationPreferencePage::Update()
 {
   m_Controls->checkGlobalVisColorWash->setChecked(m_DoseVisNode->GetBool(mitk::RTUIConstants::GLOBAL_VISIBILITY_COLORWASH_ID.c_str(), true));
   m_Controls->checkGlobalVisIsoLine->setChecked(m_DoseVisNode->GetBool(mitk::RTUIConstants::GLOBAL_VISIBILITY_ISOLINES_ID.c_str(), true));
   m_Controls->radioAbsDose->setChecked(m_DoseVisNode->GetBool(mitk::RTUIConstants::DOSE_DISPLAY_ABSOLUTE_ID.c_str(), true));
   m_Controls->radioRelDose->setChecked(!(m_DoseVisNode->GetBool(mitk::RTUIConstants::DOSE_DISPLAY_ABSOLUTE_ID.c_str(), false)));
   m_Controls->spinReferenceDose->setValue(m_DoseVisNode->GetDouble(mitk::RTUIConstants::REFERENCE_DOSE_ID.c_str(), mitk::RTUIConstants::DEFAULT_REFERENCE_DOSE_VALUE));
   m_Controls->checkGlobalSync->setChecked(m_DoseVisNode->GetBool(mitk::RTUIConstants::GLOBAL_REFERENCE_DOSE_SYNC_ID.c_str(), true));
 
   m_referenceDoseChanged = false;
   m_presetMapChanged = false;
   m_globalVisChanged = false;
 
 
   this->m_Presets = mitk::LoadPresetsMap();
   if(m_Presets.empty())
     return;
   this->m_selectedPresetName = mitk::GetSelectedPresetName();
   UpdatePresetsWidgets();
 }
 
 
 mitk::IsoDoseLevelSet* DoseVisualizationPreferencePage::GetSelectedIsoLevelSet()
 {
   QListWidgetItem* selectedItem = m_Controls->listPresets->currentItem();
 
   mitk::IsoDoseLevelSet::Pointer result;
 
   if (selectedItem)
   {
     result = m_Presets[selectedItem->text().toStdString()];
   }
 
   return result;
 }
 
 void DoseVisualizationPreferencePage::UpdateLevelSetWidgets()
 {
   this->m_Controls->btnAddLevel->setEnabled(this->GetSelectedIsoLevelSet()!=nullptr);
 
   QModelIndex selectedIndex = m_Controls->isoLevelSetView->currentIndex();
   this->m_Controls->btnDelLevel->setEnabled(this->GetSelectedIsoLevelSet()!=nullptr && selectedIndex.isValid());
 }
 
 void DoseVisualizationPreferencePage::UpdatePresetsWidgets()
 {
   m_Controls->listPresets->clear();
 
   QListWidgetItem* selectedItem = nullptr;
   for (PresetMapType::iterator pos = m_Presets.begin(); pos != m_Presets.end(); ++pos)
   {
     QListWidgetItem* item = new QListWidgetItem(QString::fromStdString(pos->first));
     if (!selectedItem)
     {
       selectedItem = item;
     }
 
     m_Controls->listPresets->addItem(item);
   }
 
   if (selectedItem)
   {
     m_Controls->listPresets->setCurrentItem(selectedItem);
   }
 
   if (this->m_LevelSetModel->isModified())
   {
     this->m_presetMapChanged = true;
   }
 
   this->m_LevelSetModel->setIsoDoseLevelSet(this->GetSelectedIsoLevelSet());
 
   m_Controls->btnDelPreset->setEnabled((m_Controls->listPresets->currentItem() != nullptr) && (m_Controls->listPresets->count()>1));
 }
 
 void DoseVisualizationPreferencePage::OnCurrentItemChanged (QListWidgetItem*, QListWidgetItem*)
 {
   this->m_LevelSetModel->setIsoDoseLevelSet(this->GetSelectedIsoLevelSet());
 }
 
 void DoseVisualizationPreferencePage::OnShowContextMenuIsoSet(const QPoint& pos)
 {
   QPoint globalPos = m_Controls->isoLevelSetView->viewport()->mapToGlobal(pos);
 
   QModelIndex selectedIndex = m_Controls->isoLevelSetView->currentIndex();
 
   QMenu viewMenu;
   QAction* addLevelAct = viewMenu.addAction("Add new level");
   QAction* delLevelAct = viewMenu.addAction("Delete selected level");
   delLevelAct->setEnabled(selectedIndex.isValid());
   viewMenu.addSeparator();
   QAction* invertIsoLineAct = viewMenu.addAction("Invert iso line visibility");
   QAction* activateIsoLineAct = viewMenu.addAction("Activate all iso lines");
   QAction* deactivateIsoLineAct = viewMenu.addAction("Deactivate all iso lines");
   viewMenu.addSeparator();
   QAction* invertColorWashAct = viewMenu.addAction("Invert color wash visibility");
   QAction* activateColorWashAct = viewMenu.addAction("Activate all color wash levels");
   QAction* deactivateColorWashAct = viewMenu.addAction("Deactivate all color wash levels");
   viewMenu.addSeparator();
   QAction* swapAct = viewMenu.addAction("Swap iso line/color wash visibility");
 
   QAction* selectedItem = viewMenu.exec(globalPos);
   if (selectedItem == invertIsoLineAct)
   {
     this->m_LevelSetModel->invertVisibilityIsoLines();
   }
   else if (selectedItem == activateIsoLineAct)
   {
     this->m_LevelSetModel->switchVisibilityIsoLines(true);
   }
   else if (selectedItem == deactivateIsoLineAct)
   {
     this->m_LevelSetModel->switchVisibilityIsoLines(false);
   }
   else if (selectedItem == invertColorWashAct)
   {
     this->m_LevelSetModel->invertVisibilityColorWash();
   }
   else if (selectedItem == activateColorWashAct)
   {
     this->m_LevelSetModel->switchVisibilityColorWash(true);
   }
   else if (selectedItem == deactivateColorWashAct)
   {
     this->m_LevelSetModel->switchVisibilityColorWash(false);
   }
   else if (selectedItem == swapAct)
   {
     this->m_LevelSetModel->swapVisibility();
   }
   else if (selectedItem == addLevelAct)
   {
     this->m_LevelSetModel->addLevel();
   }
   else if (selectedItem == delLevelAct)
   {
     this->m_LevelSetModel->deleteLevel(selectedIndex);
   }
 }
 
 void DoseVisualizationPreferencePage::OnAddPresetClicked(bool)
 {
   bool done = false;
   QString name = tr("new_preset");
   while (!done)
   {
     bool ok;
     name = QInputDialog::getText(m_MainControl, tr("Define name of new preset."), tr("Preset name:"), QLineEdit::Normal, name, &ok);
 
     if (!ok)
     {
       return; //cancled by user;
     }
 
     bool uniqueName = m_Presets.find(name.toStdString()) == m_Presets.end();
     if (!uniqueName)
     {
       QMessageBox box;
       box.setText(tr("New preset name is not unique. Please, choose another one."));
       box.exec();
     }
 
     bool validName = name.indexOf(tr("/")) ==-1;
     if (!validName)
     {
       QMessageBox box;
       box.setText(tr("New preset name is not valid. Please don't use \"/\"."));
       box.exec();
     }
 
     done = uniqueName && validName;
   }
 
   mitk::IsoDoseLevelSet::Pointer newSet = mitk::GenerateIsoLevels_Virtuos();
   m_Presets.insert(std::make_pair(name.toStdString(),newSet));
 
   m_presetMapChanged = true;
 
   UpdatePresetsWidgets();
 }
 
 void DoseVisualizationPreferencePage::OnDelPresetClicked(bool)
 {
   QListWidgetItem* selectedItem = m_Controls->listPresets->currentItem();
 
   if (selectedItem)
   {
     if (m_Controls->listPresets->count() > 1)
     {
       m_Presets.erase(selectedItem->text().toStdString());
 
       m_presetMapChanged = true;
       this->UpdatePresetsWidgets();
     }
   }
 }
 
 
 void DoseVisualizationPreferencePage::OnResetPresetClicked(bool)
 {
   QMessageBox box;
   box.setText("Do you want to reset the presets?");
   box.setInformativeText("If you reset the presets. All user defined presets will be removed and the default presets will be loaded.");
   box.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
   box.setDefaultButton(QMessageBox::No);
   int ret = box.exec();
 
   if (ret == QMessageBox::Yes)
   {
     mitk::IsoDoseLevelSet::Pointer newSet = mitk::GenerateIsoLevels_Virtuos();
     m_Presets.clear();
     m_Presets.insert(std::make_pair("Virtuos",newSet));
 
     m_presetMapChanged = true;
 
     UpdatePresetsWidgets();
   }
 }
 
 
 void DoseVisualizationPreferencePage::OnAddLevelClicked(bool)
 {
   this->m_LevelSetModel->addLevel();
 }
 
 void DoseVisualizationPreferencePage::OnDelLevelClicked(bool)
 {
   QModelIndex selectedIndex = m_Controls->isoLevelSetView->currentIndex();
 
   if (!selectedIndex.isValid())
   {
     selectedIndex = m_Controls->isoLevelSetView->indexAt(QPoint(1,1));
   }
 
   this->m_LevelSetModel->deleteLevel(selectedIndex);
 }
 
 void DoseVisualizationPreferencePage::OnReferenceDoseChanged(double)
 {
   this->m_referenceDoseChanged = true;
 }
 
 void DoseVisualizationPreferencePage::OnGlobalVisChanged(bool)
 {
   this->m_globalVisChanged = true;
 }
diff --git a/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/RTUIPreferencePage.cpp b/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/RTUIPreferencePage.cpp
index db949200c8..d5284131c3 100644
--- a/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/RTUIPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/RTUIPreferencePage.cpp
@@ -1,115 +1,115 @@
 /*===================================================================
 
 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 "RTUIPreferencePage.h"
 
 #include "mitkRTUIConstants.h"
 
 #include <berryIPreferencesService.h>
 #include <berryPlatform.h>
 
 //-----------------------------------------------------------------------------
 RTUIPreferencePage::RTUIPreferencePage()
-  : m_MainControl(0), m_Controls(0)
+  : m_MainControl(nullptr), m_Controls(nullptr)
 {
 
 }
 
 
 //-----------------------------------------------------------------------------
 RTUIPreferencePage::~RTUIPreferencePage()
 {
   delete m_Controls;
 }
 
 
 //-----------------------------------------------------------------------------
 void RTUIPreferencePage::Init(berry::IWorkbench::Pointer )
 {
 
 }
 
 
 //-----------------------------------------------------------------------------
 void RTUIPreferencePage::CreateQtControl(QWidget* parent)
 {
   berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService();
 
   m_PreferencesNode = prefService->GetSystemPreferences()->Node(mitk::RTUIConstants::ROOT_PREFERENCE_NODE_ID.c_str());
 
   m_MainControl = new QWidget(parent);
   m_Controls = new Ui::RTUIPreferencePageControls;
   m_Controls->setupUi( m_MainControl );
 
   connect(m_Controls->radioDefault, SIGNAL(toggled(bool)), m_Controls->spinDefault, SLOT(setEnabled(bool)));
   connect(m_Controls->radioRelativeToMax, SIGNAL(toggled(bool)), m_Controls->spinRelativeToMax, SLOT(setEnabled(bool)));
 
   this->Update();
 }
 
 
 //-----------------------------------------------------------------------------
 QWidget* RTUIPreferencePage::GetQtControl() const
 {
   return m_MainControl;
 }
 
 //-----------------------------------------------------------------------------
 bool RTUIPreferencePage::PerformOk()
 {
   bool useAsDefaultValue =  m_Controls->radioDefault->isChecked();
   m_PreferencesNode->PutBool(mitk::RTUIConstants::UNKNOWN_PRESCRIBED_DOSE_HANDLING_AS_DEFAULT_ID.c_str(),useAsDefaultValue);
 
   if (useAsDefaultValue)
   {
     m_PreferencesNode->PutDouble(mitk::RTUIConstants::UNKNOWN_PRESCRIBED_DOSE_HANDLING_VALUE_ID.c_str(), m_Controls->spinDefault->value());
   }
   else
   {
     m_PreferencesNode->PutDouble(mitk::RTUIConstants::UNKNOWN_PRESCRIBED_DOSE_HANDLING_VALUE_ID.c_str(), m_Controls->spinRelativeToMax->value()/100.0);
   }
 
   return true;
 }
 
 
 //-----------------------------------------------------------------------------
 void RTUIPreferencePage::PerformCancel()
 {
 }
 
 
 //-----------------------------------------------------------------------------
 void RTUIPreferencePage::Update()
 {
   bool useAsDefaultValue = m_PreferencesNode->GetBool(mitk::RTUIConstants::UNKNOWN_PRESCRIBED_DOSE_HANDLING_AS_DEFAULT_ID.c_str(), true);
   double doseValue = m_PreferencesNode->GetDouble(mitk::RTUIConstants::UNKNOWN_PRESCRIBED_DOSE_HANDLING_VALUE_ID.c_str(), 50.0);
 
   m_Controls->radioDefault->setChecked(useAsDefaultValue);
   m_Controls->radioRelativeToMax->setChecked(!useAsDefaultValue);
   m_Controls->spinDefault->setEnabled(useAsDefaultValue);
   m_Controls->spinRelativeToMax->setEnabled(!useAsDefaultValue);
 
   if (useAsDefaultValue)
   {
     m_Controls->spinDefault->setValue(doseValue);
   }
   else
   {
     m_Controls->spinRelativeToMax->setValue(doseValue*100.0);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/org_mitk_gui_qt_dosevisualization_Activator.cpp b/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/org_mitk_gui_qt_dosevisualization_Activator.cpp
index d24caaa62a..2a528f781d 100644
--- a/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/org_mitk_gui_qt_dosevisualization_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/org_mitk_gui_qt_dosevisualization_Activator.cpp
@@ -1,48 +1,48 @@
 /*===================================================================
 
 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 "org_mitk_gui_qt_dosevisualization_Activator.h"
 #include "RTDoseVisualizer.h"
 #include "RTUIPreferencePage.h"
 #include "DoseVisualizationPreferencePage.h"
 
 namespace mitk {
 
-  ctkPluginContext* org_mitk_gui_qt_dosevisualization_Activator::m_Context = 0;
+  ctkPluginContext* org_mitk_gui_qt_dosevisualization_Activator::m_Context = nullptr;
 
   void org_mitk_gui_qt_dosevisualization_Activator::start(ctkPluginContext* context)
   {
     BERRY_REGISTER_EXTENSION_CLASS(RTDoseVisualizer, context);
     BERRY_REGISTER_EXTENSION_CLASS(RTUIPreferencePage, context)
     BERRY_REGISTER_EXTENSION_CLASS(DoseVisualizationPreferencePage, context)
 
       m_Context = context;
   }
 
   void org_mitk_gui_qt_dosevisualization_Activator::stop(ctkPluginContext* context)
   {
     Q_UNUSED(context);
 
     m_Context = nullptr;
   }
 
   ctkPluginContext* org_mitk_gui_qt_dosevisualization_Activator::GetContext()
   {
     return m_Context;
   }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.fit.demo/src/internal/FitGeneratorDemoView.cpp b/Plugins/org.mitk.gui.qt.fit.demo/src/internal/FitGeneratorDemoView.cpp
index bb96d6f664..53ce61af0f 100644
--- a/Plugins/org.mitk.gui.qt.fit.demo/src/internal/FitGeneratorDemoView.cpp
+++ b/Plugins/org.mitk.gui.qt.fit.demo/src/internal/FitGeneratorDemoView.cpp
@@ -1,258 +1,258 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "FitGeneratorDemoView.h"
 #include <QMessageBox>
 #include <QThreadPool>
 
 #include <itkImage.h>
 #include <itkImageRegionIterator.h>
 
 #include "mitkWorkbenchUtil.h"
 
 #include <mitkImage.h>
 #include <mitkImageTimeSelector.h>
 
 #include <mitkPixelBasedParameterFitImageGenerator.h>
 #include <mitkLinearModelFactory.h>
 #include <mitkLinearModelParameterizer.h>
 #include <mitkLevenbergMarquardtModelFitFunctor.h>
 #include <mitkSumOfSquaredDifferencesFitCostFunction.h>
 #include <mitkModelFitResultHelper.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateOr.h>
 
 #include <mitkTestDynamicImageGenerator.h>
 
 #include <iostream>
 
 const std::string FitGeneratorDemoView::VIEW_ID = "org.mitk.gui.qt.fit.demo";
 
 typedef itk::Image<double, 3> FrameITKImageType;
 typedef itk::Image<double, 4> DynamicITKImageType;
 
 void FitGeneratorDemoView::SetFocus()
 {
   m_Controls.btnModelling->setFocus();
 }
 
 void FitGeneratorDemoView::CreateQtPartControl(QWidget* parent)
 {
   m_Controls.setupUi(parent);
   m_Controls.btnModelling->setEnabled(false);
 
   connect(m_Controls.btnModelling, SIGNAL(clicked()), this, SLOT(OnModellingButtonClicked()));
   connect(m_Controls.btnGenerateTestData, SIGNAL(clicked()), this,
           SLOT(OnGenerateTestDataButtonClicked()));
 
   m_Controls.leFitName->setText(tr("demo"));
 }
 
 void FitGeneratorDemoView::OnModellingButtonClicked()
 {
   Generate();
 }
 
 void FitGeneratorDemoView::OnGenerateTestDataButtonClicked()
 {
   mitk::Image::Pointer testImage = mitk::GenerateDynamicTestImageMITK();
 
   mitk::DataNode::Pointer testNode = mitk::DataNode::New();
 
   testNode->SetData(testImage);
   testNode->SetName("LinearModel_4DTestImage");
 
   this->GetDataStorage()->Add(testNode);
 }
 
 void FitGeneratorDemoView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
     const QList<mitk::DataNode::Pointer>& /*nodes*/)
 {
 
   QList<mitk::DataNode::Pointer> dataNodes = this->GetDataManagerSelection();
 
-  m_selectedNode = NULL;
-  m_selectedImage = NULL;
-  m_selectedMaskNode = NULL;
-  m_selectedMask = NULL;
+  m_selectedNode = nullptr;
+  m_selectedImage = nullptr;
+  m_selectedMaskNode = nullptr;
+  m_selectedMask = nullptr;
 
   if (!dataNodes.empty())
   {
     m_selectedNode = dataNodes[0];
     mitk::Image* selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
 
     if (selectedImage && selectedImage->GetDimension(3) > 1)
     {
       m_selectedImage = selectedImage;
     }
 
     if (dataNodes.size() > 1)
     {
       m_selectedMaskNode = dataNodes[1];
 
       mitk::NodePredicateDataType::Pointer isLabelSet = mitk::NodePredicateDataType::New("LabelSetImage");
       mitk::NodePredicateDataType::Pointer isImage = mitk::NodePredicateDataType::New("Image");
       mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
       mitk::NodePredicateAnd::Pointer isLegacyMask = mitk::NodePredicateAnd::New(isImage, isBinary);
 
       mitk::NodePredicateOr::Pointer maskPredicate = mitk::NodePredicateOr::New(isLegacyMask, isLabelSet);
 
       mitk::Image* selectedMask = dynamic_cast<mitk::Image*>(this->m_selectedMaskNode->GetData());
 
       if (selectedMask && maskPredicate->CheckNode(m_selectedMaskNode))
       {
         m_selectedMask = selectedMask;
 
         if (this->m_selectedMask->GetTimeSteps() > 1)
         {
           MITK_INFO <<
                     "Selected mask has multiple timesteps. Only use first timestep to mask model fit. Mask name: " <<
                     m_selectedMaskNode->GetName() ;
           mitk::ImageTimeSelector::Pointer maskedImageTimeSelector = mitk::ImageTimeSelector::New();
           maskedImageTimeSelector->SetInput(this->m_selectedMask);
           maskedImageTimeSelector->SetTimeNr(0);
           maskedImageTimeSelector->UpdateLargestPossibleRegion();
           this->m_selectedMask = maskedImageTimeSelector->GetOutput();
         }
       }
 
     }
   }
 
   if (m_selectedImage)
   {
     m_Controls.lTimeseries->setText((m_selectedNode->GetName()).c_str());
   }
   else
   {
     if (m_selectedNode.IsNull())
     {
       m_Controls.lTimeseries->setText("None");
     }
     else
     {
       m_Controls.lTimeseries->setText("Error. Selected node #1 is no 4D image!");
     }
   }
 
   if (m_selectedMask)
   {
     m_Controls.lMask->setText((m_selectedMaskNode->GetName()).c_str());
   }
   else
   {
     if (m_selectedMaskNode.IsNull())
     {
       m_Controls.lMask->setText("None");
     }
     else
     {
       m_Controls.lMask->setText("Error. Selected node #2 is no mask!");
     }
   }
 
   m_Controls.btnModelling->setEnabled(m_selectedImage.IsNotNull());
 }
 
 void FitGeneratorDemoView::Generate()
 {
   mitk::PixelBasedParameterFitImageGenerator::Pointer fitGenerator =
     mitk::PixelBasedParameterFitImageGenerator::New();
 
   //Model configuration (static parameters) can be done now
 
   //Specify fitting strategy and evaluation parameters
   mitk::LevenbergMarquardtModelFitFunctor::Pointer fitFunctor =
     mitk::LevenbergMarquardtModelFitFunctor::New();
   mitk::SumOfSquaredDifferencesFitCostFunction::Pointer evaluation =
     mitk::SumOfSquaredDifferencesFitCostFunction::New();
 
   fitFunctor->RegisterEvaluationParameter("sum_diff^2", evaluation);
 
   //Parametrize fit generator
   mitk::LinearModelParameterizer::Pointer parameterizer = mitk::LinearModelParameterizer::New();
   fitGenerator->SetModelParameterizer(parameterizer);
   fitGenerator->SetDynamicImage(m_selectedImage);
   fitGenerator->SetFitFunctor(fitFunctor);
 
   if (m_selectedMask.IsNotNull())
   {
     fitGenerator->SetMask(m_selectedMask);
   }
 
   mitk::modelFit::ModelFitInfo::Pointer fitSession =
     mitk::modelFit::CreateFitInfoFromModelParameterizer(parameterizer, m_selectedNode->GetData(),
         mitk::ModelFitConstants::FIT_TYPE_VALUE_PIXELBASED(), m_Controls.leFitName->text().toStdString());
 
   /////////////////////////
   //create job and put it into the thread pool
   ParameterFitBackgroundJob* pJob = new ParameterFitBackgroundJob(fitGenerator, fitSession, m_selectedNode);
   pJob->setAutoDelete(true);
 
   connect(pJob, SIGNAL(Error(QString)), this, SLOT(OnJobError(QString)));
   connect(pJob, SIGNAL(Finished()), this, SLOT(OnJobFinished()));
   connect(pJob, SIGNAL(ResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType,
                        const ParameterFitBackgroundJob*)), this,
           SLOT(OnJobResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType,
                                         const ParameterFitBackgroundJob*)), Qt::BlockingQueuedConnection);
 
   connect(pJob, SIGNAL(JobProgress(double)), this, SLOT(OnJobProgress(double)));
   connect(pJob, SIGNAL(JobStatusChanged(QString)), this, SLOT(OnJobStatusChanged(QString)));
 
   QThreadPool* threadPool = QThreadPool::globalInstance();
   threadPool->start(pJob);
 }
 
 FitGeneratorDemoView::FitGeneratorDemoView()
 {
-  m_selectedImage = NULL;
-  m_selectedNode = NULL;
+  m_selectedImage = nullptr;
+  m_selectedNode = nullptr;
 
 }
 
 void FitGeneratorDemoView::OnJobFinished()
 {
   this->m_Controls.textEdit->append(QString("Fitting finished"));
 };
 
 void FitGeneratorDemoView::OnJobError(QString err)
 {
   MITK_ERROR << err.toStdString().c_str();
 
   m_Controls.textEdit->append(QString("<font color='red'><b>") + err + QString("</b></font>"));
 
 };
 
 void FitGeneratorDemoView::OnJobResultsAreAvailable(
   mitk::modelFit::ModelFitResultNodeVectorType results, const ParameterFitBackgroundJob* pJob)
 {
   //Store the resulting parameter fit image via convenience helper function in data storage
   //(handles the correct generation of the nodes and their properties)
   mitk::modelFit::StoreResultsInDataStorage(this->GetDataStorage(), results, pJob->GetParentNode());
 };
 
 void FitGeneratorDemoView::OnJobProgress(double progress)
 {
   QString report = QString("Progress. ") + QString::number(progress);
   this->m_Controls.textEdit->append(report);
 };
 
 void FitGeneratorDemoView::OnJobStatusChanged(QString info)
 {
   this->m_Controls.textEdit->append(info);
 }
diff --git a/Plugins/org.mitk.gui.qt.fit.genericfitting/src/internal/GenericDataFittingView.cpp b/Plugins/org.mitk.gui.qt.fit.genericfitting/src/internal/GenericDataFittingView.cpp
index cb3daf252c..ed49ea9c8a 100644
--- a/Plugins/org.mitk.gui.qt.fit.genericfitting/src/internal/GenericDataFittingView.cpp
+++ b/Plugins/org.mitk.gui.qt.fit.genericfitting/src/internal/GenericDataFittingView.cpp
@@ -1,646 +1,646 @@
 /*===================================================================
 
 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 "GenericDataFittingView.h"
 
 #include "mitkWorkbenchUtil.h"
 
 #include <mitkLinearModelFactory.h>
 #include <mitkLinearModelParameterizer.h>
 #include <mitkGenericParamModelFactory.h>
 #include <mitkGenericParamModelParameterizer.h>
 #include <mitkT2DecayModelFactory.h>
 #include <mitkT2DecayModelParameterizer.h>
 
 
 #include <mitkValueBasedParameterizationDelegate.h>
 
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkPixelBasedParameterFitImageGenerator.h>
 #include <mitkROIBasedParameterFitImageGenerator.h>
 #include <mitkLevenbergMarquardtModelFitFunctor.h>
 #include <mitkSumOfSquaredDifferencesFitCostFunction.h>
 #include <mitkNormalizedSumOfSquaredDifferencesFitCostFunction.h>
 #include <mitkSimpleBarrierConstraintChecker.h>
 #include <mitkModelFitResultHelper.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkMaskedDynamicImageStatisticsGenerator.h>
 #include <mitkExtractTimeGrid.h>
 
 #include <QMessageBox>
 #include <QThreadPool>
 #include <QmitkDataStorageComboBox.h>
 
 // Includes for image casting between ITK and MITK
 #include <mitkImage.h>
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 #include <itkImage.h>
 #include <itkImageRegionIterator.h>
 #include <iostream>
 
 
 const std::string GenericDataFittingView::VIEW_ID = "org.mitk.gui.qt.fit.genericfitting";
 
 void GenericDataFittingView::SetFocus()
 {
   m_Controls.btnModelling->setFocus();
 }
 
 void GenericDataFittingView::CreateQtPartControl(QWidget* parent)
 {
   m_Controls.setupUi(parent);
 
   m_Controls.btnModelling->setEnabled(false);
 
   this->InitModelComboBox();
 
   connect(m_Controls.btnModelling, SIGNAL(clicked()), this, SLOT(OnModellingButtonClicked()));
 
   connect(m_Controls.comboModel, SIGNAL(currentIndexChanged(int)), this, SLOT(OnModellSet(int)));
   connect(m_Controls.radioPixelBased, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
 
   //Gerneric setting
   m_Controls.groupGeneric->hide();
   m_Controls.labelFormulaInfo->hide();
   connect(m_Controls.editFormula, SIGNAL(textChanged(const QString&)), this,
           SLOT(UpdateGUIControls()));
   connect(m_Controls.checkFormulaInfo, SIGNAL(toggled(bool)), m_Controls.labelFormulaInfo,
           SLOT(setVisible(bool)));
   connect(m_Controls.nrOfParams, SIGNAL(valueChanged(int)), this, SLOT(OnNrOfParamsChanged()));
 
 
   //Model fit configuration
   m_Controls.groupBox_FitConfiguration->hide();
 
   m_Controls.checkBox_Constraints->setEnabled(false);
   m_Controls.constraintManager->setEnabled(false);
   m_Controls.initialValuesManager->setEnabled(false);
 
   connect(m_Controls.radioButton_StartParameters, SIGNAL(toggled(bool)), this,
           SLOT(UpdateGUIControls()));
   connect(m_Controls.checkBox_Constraints, SIGNAL(toggled(bool)), this,
           SLOT(UpdateGUIControls()));
 
   connect(m_Controls.radioButton_StartParameters, SIGNAL(toggled(bool)),
           m_Controls.initialValuesManager,
           SLOT(setEnabled(bool)));
   connect(m_Controls.checkBox_Constraints, SIGNAL(toggled(bool)), m_Controls.constraintManager,
           SLOT(setEnabled(bool)));
   connect(m_Controls.checkBox_Constraints, SIGNAL(toggled(bool)), m_Controls.constraintManager,
           SLOT(setVisible(bool)));
 
   UpdateGUIControls();
 }
 
 void GenericDataFittingView::UpdateGUIControls()
 {
   m_Controls.lineFitName->setPlaceholderText(QString::fromStdString(this->GetDefaultFitName()));
   m_Controls.lineFitName->setEnabled(!m_FittingInProgress);
 
   m_Controls.checkBox_Constraints->setEnabled(m_modelConstraints.IsNotNull());
 
   bool isGenericFactory = dynamic_cast<mitk::GenericParamModelFactory*>
-                          (m_selectedModelFactory.GetPointer()) != NULL;
+                          (m_selectedModelFactory.GetPointer()) != nullptr;
 
   m_Controls.groupGeneric->setVisible(isGenericFactory);
 
   m_Controls.groupBox_FitConfiguration->setVisible(m_selectedModelFactory);
 
   m_Controls.groupBox->setEnabled(!m_FittingInProgress);
   m_Controls.comboModel->setEnabled(!m_FittingInProgress);
   m_Controls.groupGeneric->setEnabled(!m_FittingInProgress);
   m_Controls.groupBox_FitConfiguration->setEnabled(!m_FittingInProgress);
 
   m_Controls.radioROIbased->setEnabled(m_selectedMask.IsNotNull());
 
   m_Controls.btnModelling->setEnabled(m_selectedImage.IsNotNull()
                                       && m_selectedModelFactory.IsNotNull() && !m_FittingInProgress && CheckModelSettings());
 }
 
 std::string GenericDataFittingView::GetFitName() const
 {
   std::string fitName = m_Controls.lineFitName->text().toStdString();
   if (fitName.empty())
   {
     fitName = m_Controls.lineFitName->placeholderText().toStdString();
   }
   return fitName;
 }
 
 std::string GenericDataFittingView::GetDefaultFitName() const
 {
     std::string defaultName = "undefined model";
 
     if (this->m_selectedModelFactory.IsNotNull())
     {
         defaultName = this->m_selectedModelFactory->GetClassID();
     }
 
     if (this->m_Controls.radioPixelBased->isChecked())
     {
         defaultName += "_pixel";
     }
     else
     {
         defaultName += "_roi";
     }
 
     return defaultName;
 }
 
 
 void GenericDataFittingView::OnNrOfParamsChanged()
 {
   PrepareFitConfiguration();
   UpdateGUIControls();
 }
 
 
 void GenericDataFittingView::OnModellSet(int index)
 {
-  m_selectedModelFactory = NULL;
+  m_selectedModelFactory = nullptr;
 
   if (index > 0)
   {
     if (static_cast<ModelFactoryStackType::size_type>(index) <= m_FactoryStack.size() )
     {
         m_selectedModelFactory = m_FactoryStack[index - 1];
     }
     else
     {
         MITK_WARN << "Invalid model index. Index outside of the factory stack. Factory stack size: "<< m_FactoryStack.size() << "; invalid index: "<< index;
     }
   }
 
   UpdateGUIControls();
 }
 
 bool GenericDataFittingView::IsGenericParamFactorySelected() const
 {
   return dynamic_cast<mitk::GenericParamModelFactory*>
     (m_selectedModelFactory.GetPointer()) != nullptr;
 }
 
 void GenericDataFittingView::PrepareFitConfiguration()
 {
   if (m_selectedModelFactory)
   {
     mitk::ModelBase::ParameterNamesType paramNames = m_selectedModelFactory->GetParameterNames();
     unsigned int nrOfPools = this->m_Controls.nrOfParams->value();
 
     //init values
     if (this->IsGenericParamFactorySelected())
     {
       mitk::modelFit::ModelFitInfo::Pointer fitInfo = mitk::modelFit::ModelFitInfo::New();
       fitInfo->staticParamMap.Add(mitk::GenericParamModel::NAME_STATIC_PARAMETER_number, { static_cast<double>(nrOfPools) });
 
       auto parameterizer = m_selectedModelFactory->CreateParameterizer(fitInfo);
       paramNames = parameterizer->GetParameterNames();
 
       m_Controls.initialValuesManager->setInitialValues(paramNames, parameterizer->GetDefaultInitialParameterization());
     }
     else
     {
       m_Controls.initialValuesManager->setInitialValues(paramNames, this->m_selectedModelFactory->GetDefaultInitialParameterization());
     }
 
     //constraints
     this->m_modelConstraints = dynamic_cast<mitk::SimpleBarrierConstraintChecker*>
       (m_selectedModelFactory->CreateDefaultConstraints().GetPointer());
 
     if (this->m_modelConstraints.IsNull())
     {
       this->m_modelConstraints = mitk::SimpleBarrierConstraintChecker::New();
     }
 
     m_Controls.constraintManager->setChecker(this->m_modelConstraints, paramNames);
   }
 };
 
 void GenericDataFittingView::OnModellingButtonClicked()
 {
   //check if all static parameters set
   if (m_selectedModelFactory.IsNotNull() && CheckModelSettings())
   {
-    mitk::ParameterFitImageGeneratorBase::Pointer generator = NULL;
-    mitk::modelFit::ModelFitInfo::Pointer fitSession = NULL;
+    mitk::ParameterFitImageGeneratorBase::Pointer generator = nullptr;
+    mitk::modelFit::ModelFitInfo::Pointer fitSession = nullptr;
 
     bool isLinearFactory = dynamic_cast<mitk::LinearModelFactory*>
-                           (m_selectedModelFactory.GetPointer()) != NULL;
+                           (m_selectedModelFactory.GetPointer()) != nullptr;
     bool isGenericFactory = dynamic_cast<mitk::GenericParamModelFactory*>
-                            (m_selectedModelFactory.GetPointer()) != NULL;
+                            (m_selectedModelFactory.GetPointer()) != nullptr;
     bool isT2DecayFactory = dynamic_cast<mitk::T2DecayModelFactory*>
-      (m_selectedModelFactory.GetPointer()) != NULL;
+      (m_selectedModelFactory.GetPointer()) != nullptr;
 
     if (isLinearFactory)
     {
       if (this->m_Controls.radioPixelBased->isChecked())
       {
         GenerateModelFit_PixelBased<mitk::LinearModelParameterizer>(fitSession, generator);
       }
       else
       {
         GenerateModelFit_ROIBased<mitk::LinearModelParameterizer>(fitSession, generator);
       }
     }
     else if (isGenericFactory)
     {
       if (this->m_Controls.radioPixelBased->isChecked())
       {
         GenerateModelFit_PixelBased<mitk::GenericParamModelParameterizer>(fitSession, generator);
       }
       else
       {
         GenerateModelFit_ROIBased<mitk::GenericParamModelParameterizer>(fitSession, generator);
       }
     }
     else if (isT2DecayFactory)
     {
       if (this->m_Controls.radioPixelBased->isChecked())
       {
         GenerateModelFit_PixelBased<mitk::T2DecayModelParameterizer>(fitSession, generator);
       }
       else
       {
         GenerateModelFit_ROIBased<mitk::T2DecayModelParameterizer>(fitSession, generator);
       }
     }
     //add other models with else if
 
     if (generator.IsNotNull() && fitSession.IsNotNull())
     {
       m_FittingInProgress = true;
       UpdateGUIControls();
       DoFit(fitSession, generator);
     }
     else
     {
       QMessageBox box;
       box.setText("Fitting error!");
       box.setInformativeText("Could not establish fitting job. Error when setting ab generator, model parameterizer or session info.");
       box.setStandardButtons(QMessageBox::Ok);
       box.setDefaultButton(QMessageBox::Ok);
       box.setIcon(QMessageBox::Warning);
       box.exec();
     }
 
   }
   else
   {
     QMessageBox box;
     box.setText("Static parameters for model are not set!");
     box.setInformativeText("Some static parameters, that are needed for calculation are not set and equal to zero. Modeling not possible");
     box.setStandardButtons(QMessageBox::Ok);
     box.setDefaultButton(QMessageBox::Ok);
     box.setIcon(QMessageBox::Warning);
     box.exec();
   }
 }
 
 
 void GenericDataFittingView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
     const QList<mitk::DataNode::Pointer>& selectedNodes)
 {
-  m_selectedNode = NULL;
-  m_selectedImage = NULL;
-  m_selectedMaskNode = NULL;
-  m_selectedMask = NULL;
+  m_selectedNode = nullptr;
+  m_selectedImage = nullptr;
+  m_selectedMaskNode = nullptr;
+  m_selectedMask = nullptr;
 
   m_Controls.masklabel->setText("No (valid) mask selected.");
   m_Controls.timeserieslabel->setText("No (valid) series selected.");
 
   QList<mitk::DataNode::Pointer> nodes = selectedNodes;
 
   mitk::NodePredicateDataType::Pointer isLabelSet = mitk::NodePredicateDataType::New("LabelSetImage");
   mitk::NodePredicateDataType::Pointer isImage = mitk::NodePredicateDataType::New("Image");
   mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   mitk::NodePredicateAnd::Pointer isLegacyMask = mitk::NodePredicateAnd::New(isImage, isBinary);
 
   mitk::NodePredicateOr::Pointer maskPredicate = mitk::NodePredicateOr::New(isLegacyMask, isLabelSet);
 
   if (nodes.size() > 0 && isImage->CheckNode(nodes.front()))
   {
     this->m_selectedNode = nodes.front();
     this->m_selectedImage = dynamic_cast<mitk::Image*>(this->m_selectedNode->GetData());
     m_Controls.timeserieslabel->setText((this->m_selectedNode->GetName()).c_str());
     nodes.pop_front();
   }
 
   if (nodes.size() > 0 && maskPredicate->CheckNode(nodes.front()))
   {
       this->m_selectedMaskNode = nodes.front();
       this->m_selectedMask = dynamic_cast<mitk::Image*>(this->m_selectedMaskNode->GetData());
 
       if (this->m_selectedMask->GetTimeSteps() > 1)
       {
         MITK_INFO <<
                   "Selected mask has multiple timesteps. Only use first timestep to mask model fit. Mask name: " <<
                   m_selectedMaskNode->GetName();
         mitk::ImageTimeSelector::Pointer maskedImageTimeSelector = mitk::ImageTimeSelector::New();
         maskedImageTimeSelector->SetInput(this->m_selectedMask);
         maskedImageTimeSelector->SetTimeNr(0);
         maskedImageTimeSelector->UpdateLargestPossibleRegion();
         this->m_selectedMask = maskedImageTimeSelector->GetOutput();
       }
 
       m_Controls.masklabel->setText((this->m_selectedMaskNode->GetName()).c_str());
   }
 
   if (m_selectedMask.IsNull())
   {
     this->m_Controls.radioPixelBased->setChecked(true);
   }
 
   UpdateGUIControls();
 }
 
 bool GenericDataFittingView::CheckModelSettings() const
 {
   bool ok = true;
 
   //check wether any model is set at all. Otherwise exit with false
   if (m_selectedModelFactory.IsNotNull())
   {
-    bool isGenericFactory = dynamic_cast<mitk::GenericParamModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL; 
+    bool isGenericFactory = dynamic_cast<mitk::GenericParamModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr; 
 
     if (isGenericFactory)
     {
       ok = !m_Controls.editFormula->text().isEmpty();
     }
   }
   else
   {
     ok = false;
   }
 
   return ok;
 }
 
 void GenericDataFittingView::ConfigureInitialParametersOfParameterizer(mitk::ModelParameterizerBase*
     parameterizer) const
 {
   if (m_Controls.radioButton_StartParameters->isChecked())
   {
     //use user defined initial parameters
     mitk::ValueBasedParameterizationDelegate::Pointer paramDelegate =
       mitk::ValueBasedParameterizationDelegate::New();
     paramDelegate->SetInitialParameterization(m_Controls.initialValuesManager->getInitialValues());
 
     parameterizer->SetInitialParameterizationDelegate(paramDelegate);
   }
 
   mitk::GenericParamModelParameterizer* genericParameterizer =
     dynamic_cast<mitk::GenericParamModelParameterizer*>(parameterizer);
 
   if (genericParameterizer)
   {
     genericParameterizer->SetFunctionString(m_Controls.editFormula->text().toStdString());
   }
 }
 
 template <typename TParameterizer>
 void GenericDataFittingView::GenerateModelFit_PixelBased(mitk::modelFit::ModelFitInfo::Pointer&
     modelFitInfo, mitk::ParameterFitImageGeneratorBase::Pointer& generator)
 {
   mitk::PixelBasedParameterFitImageGenerator::Pointer fitGenerator =
     mitk::PixelBasedParameterFitImageGenerator::New();
 
   typename TParameterizer::Pointer modelParameterizer =
     TParameterizer::New();
 
   auto genericParameterizer = dynamic_cast<mitk::GenericParamModelParameterizer*>(modelParameterizer.GetPointer());
   if (genericParameterizer)
   {
     genericParameterizer->SetNumberOfParameters(this->m_Controls.nrOfParams->value());
   }
 
   this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
 
   //Specify fitting strategy and criterion parameters
   mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
 
   //Parametrize fit generator
   fitGenerator->SetModelParameterizer(modelParameterizer);
   std::string roiUID = "";
 
   if (m_selectedMask.IsNotNull())
   {
     fitGenerator->SetMask(m_selectedMask);
     roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
   }
 
   mitk::EnsureModelFitUID(this->m_selectedNode);
 
   fitGenerator->SetDynamicImage(this->m_selectedImage);
   fitGenerator->SetFitFunctor(fitFunctor);
 
   generator = fitGenerator.GetPointer();
 
   //Create model info
   modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
     m_selectedNode->GetData(), mitk::ModelFitConstants::FIT_TYPE_VALUE_PIXELBASED(), this->GetFitName(),
                  roiUID);
 }
 
 template <typename TParameterizer>
 void GenericDataFittingView::GenerateModelFit_ROIBased(
   mitk::modelFit::ModelFitInfo::Pointer& modelFitInfo,
   mitk::ParameterFitImageGeneratorBase::Pointer& generator)
 {
   mitk::ROIBasedParameterFitImageGenerator::Pointer fitGenerator =
     mitk::ROIBasedParameterFitImageGenerator::New();
 
   typename TParameterizer::Pointer modelParameterizer =
     TParameterizer::New();
 
   auto genericParameterizer = dynamic_cast<mitk::GenericParamModelParameterizer*>(modelParameterizer.GetPointer());
   if (genericParameterizer)
   {
     genericParameterizer->SetNumberOfParameters(this->m_Controls.nrOfParams->value());
   }
 
   this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
 
   //Compute ROI signal
   mitk::MaskedDynamicImageStatisticsGenerator::Pointer signalGenerator =
     mitk::MaskedDynamicImageStatisticsGenerator::New();
   signalGenerator->SetMask(m_selectedMask);
   signalGenerator->SetDynamicImage(m_selectedImage);
   signalGenerator->Generate();
 
   mitk::MaskedDynamicImageStatisticsGenerator::ResultType roiSignal = signalGenerator->GetMean();
 
   //Specify fitting strategy and criterion parameters
   mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
 
   //Parametrize fit generator
   fitGenerator->SetModelParameterizer(modelParameterizer);
   fitGenerator->SetMask(m_selectedMask);
   fitGenerator->SetFitFunctor(fitFunctor);
   fitGenerator->SetSignal(roiSignal);
   fitGenerator->SetTimeGrid(mitk::ExtractTimeGrid(m_selectedImage));
 
   generator = fitGenerator.GetPointer();
 
   mitk::EnsureModelFitUID(this->m_selectedNode);
   std::string roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
 
   //Create model info
   modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
     m_selectedNode->GetData(), mitk::ModelFitConstants::FIT_TYPE_VALUE_ROIBASED(), this->GetFitName(),
                  roiUID);
 
   mitk::ScalarListLookupTable::ValueType infoSignal;
 
   for (mitk::MaskedDynamicImageStatisticsGenerator::ResultType::const_iterator pos =
          roiSignal.begin(); pos != roiSignal.end(); ++pos)
   {
     infoSignal.push_back(*pos);
   }
 
   modelFitInfo->inputData.SetTableValue("ROI", infoSignal);
 }
 
 void GenericDataFittingView::DoFit(const mitk::modelFit::ModelFitInfo* fitSession,
                                    mitk::ParameterFitImageGeneratorBase* generator)
 {
   QString message = "<font color='green'>Fitting Data Set . . .</font>";
   m_Controls.infoBox->append(message);
 
   /////////////////////////
   //create job and put it into the thread pool
   ParameterFitBackgroundJob* pJob = new ParameterFitBackgroundJob(generator, fitSession, this->m_selectedNode);
   pJob->setAutoDelete(true);
 
   connect(pJob, SIGNAL(Error(QString)), this, SLOT(OnJobError(QString)));
   connect(pJob, SIGNAL(Finished()), this, SLOT(OnJobFinished()));
   connect(pJob, SIGNAL(ResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType,
                        const ParameterFitBackgroundJob*)), this,
           SLOT(OnJobResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType,
                                         const ParameterFitBackgroundJob*)), Qt::BlockingQueuedConnection);
 
   connect(pJob, SIGNAL(JobProgress(double)), this, SLOT(OnJobProgress(double)));
   connect(pJob, SIGNAL(JobStatusChanged(QString)), this, SLOT(OnJobStatusChanged(QString)));
 
   QThreadPool* threadPool = QThreadPool::globalInstance();
   threadPool->start(pJob);
 }
 
 GenericDataFittingView::GenericDataFittingView() : m_FittingInProgress(false)
 {
-  m_selectedImage = NULL;
-  m_selectedMask = NULL;
+  m_selectedImage = nullptr;
+  m_selectedMask = nullptr;
 
   mitk::ModelFactoryBase::Pointer factory =
     mitk::LinearModelFactory::New().GetPointer();
   m_FactoryStack.push_back(factory);
   factory = mitk::GenericParamModelFactory::New().GetPointer();
   m_FactoryStack.push_back(factory);
   factory = mitk::T2DecayModelFactory::New().GetPointer();
   m_FactoryStack.push_back(factory);
 
   this->m_IsNotABinaryImagePredicate = mitk::NodePredicateAnd::New(
                                          mitk::TNodePredicateDataType<mitk::Image>::New(),
                                          mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("binary",
                                              mitk::BoolProperty::New(true))),
                                          mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))).GetPointer();
   this->m_IsBinaryImagePredicate = mitk::NodePredicateAnd::New(
                                      mitk::TNodePredicateDataType<mitk::Image>::New(),
                                      mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true)),
                                      mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))).GetPointer();
 }
 
 void GenericDataFittingView::OnJobFinished()
 {
   this->m_Controls.infoBox->append(QString("<font color='green'>Fitting finished</font>"));
   this->m_FittingInProgress = false;
   this->UpdateGUIControls();
 };
 
 void GenericDataFittingView::OnJobError(QString err)
 {
   MITK_ERROR << err.toStdString().c_str();
 
   m_Controls.infoBox->append(QString("<font color='red'><b>") + err + QString("</b></font>"));
 
 };
 
 void GenericDataFittingView::OnJobResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType
     results,
     const ParameterFitBackgroundJob* pJob)
 {
   //Store the resulting parameter fit image via convenience helper function in data storage
   //(handles the correct generation of the nodes and their properties)
   mitk::modelFit::StoreResultsInDataStorage(this->GetDataStorage(), results, pJob->GetParentNode());
 };
 
 void GenericDataFittingView::OnJobProgress(double progress)
 {
   QString report = QString("Progress. ") + QString::number(progress);
   this->m_Controls.infoBox->append(report);
 };
 
 void GenericDataFittingView::OnJobStatusChanged(QString info)
 {
   this->m_Controls.infoBox->append(info);
 }
 
 
 void GenericDataFittingView::InitModelComboBox() const
 {
   this->m_Controls.comboModel->clear();
   this->m_Controls.comboModel->addItem(tr("No model selected"));
 
   for (ModelFactoryStackType::const_iterator pos = m_FactoryStack.begin();
        pos != m_FactoryStack.end(); ++pos)
   {
     this->m_Controls.comboModel->addItem(QString::fromStdString((*pos)->GetClassID()));
   }
 
   this->m_Controls.comboModel->setCurrentIndex(0);
 };
 
 mitk::ModelFitFunctorBase::Pointer GenericDataFittingView::CreateDefaultFitFunctor(
   const mitk::ModelParameterizerBase* parameterizer) const
 {
   mitk::LevenbergMarquardtModelFitFunctor::Pointer fitFunctor =
     mitk::LevenbergMarquardtModelFitFunctor::New();
 
   mitk::NormalizedSumOfSquaredDifferencesFitCostFunction::Pointer chi2 =
     mitk::NormalizedSumOfSquaredDifferencesFitCostFunction::New();
   fitFunctor->RegisterEvaluationParameter("Chi^2", chi2);
 
   if (m_Controls.checkBox_Constraints->isChecked())
   {
     fitFunctor->SetConstraintChecker(m_modelConstraints);
   }
 
   mitk::ModelBase::Pointer refModel = parameterizer->GenerateParameterizedModel();
 
   ::itk::LevenbergMarquardtOptimizer::ScalesType scales;
   scales.SetSize(refModel->GetNumberOfParameters());
   scales.Fill(1.0);
   fitFunctor->SetScales(scales);
 
   fitFunctor->SetDebugParameterMaps(m_Controls.checkDebug->isChecked());
 
   return fitFunctor.GetPointer();
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingDataEvaluationView.cpp b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingDataEvaluationView.cpp
index 12da728a93..ccb9b32a49 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingDataEvaluationView.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingDataEvaluationView.cpp
@@ -1,1169 +1,1169 @@
 /*=========================================================================
 
 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 <algorithm>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkIGTTrackingDataEvaluationView.h"
 #include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 #include <qfiledialog.h>
 #include <qstringlist.h>
 
 // MITK
 #include "mitkNavigationDataCSVSequentialPlayer.h"
 #include <mitkNavigationDataRecorderDeprecated.h>
 #include <mitkQuaternionAveraging.h>
 #include <mitkTransform.h>
 #include <mitkStaticIGTHelperFunctions.h>
 #include <mitkNodePredicateDataType.h>
 
 
 //ITK
 #include <itksys/SystemTools.hxx>
 
 //VNL
 #include <vnl/vnl_vector.h>
 
 //vtk headers
 #include <vtkPoints.h>
 #include <vtkSmartPointer.h>
 #include <vtkLandmarkTransform.h>
 
 const std::string QmitkIGTTrackingDataEvaluationView::VIEW_ID = "org.mitk.views.igttrackingdataevaluation";
 
 QmitkIGTTrackingDataEvaluationView::QmitkIGTTrackingDataEvaluationView()
   : QmitkFunctionality()
-  , m_Controls(0)
+  , m_Controls(nullptr)
   , m_MultiWidget(nullptr)
   , m_scalingfactor(1)
 {
   m_CSVtoXMLInputFilenameVector = std::vector<std::string>();
   m_CSVtoXMLOutputFilenameVector = std::vector<std::string>();
 }
 
 QmitkIGTTrackingDataEvaluationView::~QmitkIGTTrackingDataEvaluationView()
 {
 }
 
 void QmitkIGTTrackingDataEvaluationView::CreateQtPartControl(QWidget *parent)
 {
   // build up qt view, unless already done
   if (!m_Controls)
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkIGTTrackingDataEvaluationViewControls;
     m_Controls->setupUi(parent);
 
     connect(m_Controls->m_LoadInputFileList, SIGNAL(clicked()), this, SLOT(OnLoadFileList()));
     connect(m_Controls->m_StartEvaluation, SIGNAL(clicked()), this, SLOT(OnEvaluateData()));
     connect(m_Controls->m_AddToCurrentList, SIGNAL(clicked()), this, SLOT(OnAddToCurrentList()));
     connect(m_Controls->m_GeneratePointSetOfMeanPositions, SIGNAL(clicked()), this, SLOT(OnGeneratePointSet()));
     connect(m_Controls->m_GenerateRotationLines, SIGNAL(clicked()), this, SLOT(OnGenerateRotationLines()));
     connect(m_Controls->m_GeneratePointSet, SIGNAL(clicked()), this, SLOT(OnGenerateGroundTruthPointSet()));
     connect(m_Controls->m_Convert, SIGNAL(clicked()), this, SLOT(OnConvertCSVtoXMLFile()));
     connect(m_Controls->m_loadCSVtoXMLInputList, SIGNAL(clicked()), this, SLOT(OnCSVtoXMLLoadInputList()));
     connect(m_Controls->m_loadCSVtoXMLOutputList, SIGNAL(clicked()), this, SLOT(OnCSVtoXMLLoadOutputList()));
     connect(m_Controls->m_OrientationCalculationGenerateReference, SIGNAL(clicked()), this, SLOT(OnOrientationCalculation_CalcRef()));
     connect(m_Controls->m_OrientationCalculationWriteOrientationsToFile, SIGNAL(clicked()), this, SLOT(OnOrientationCalculation_CalcOrientandWriteToFile()));
     connect(m_Controls->m_GeneratePointSetsOfSinglePositions, SIGNAL(clicked()), this, SLOT(OnGeneratePointSetsOfSinglePositions()));
     connect(m_Controls->m_StartEvaluationAll, SIGNAL(clicked()), this, SLOT(OnEvaluateDataAll()));
     connect(m_Controls->m_GridMatching, SIGNAL(clicked()), this, SLOT(OnPerfomGridMatching()));
     connect(m_Controls->m_ComputeRotation, SIGNAL(clicked()), this, SLOT(OnComputeRotation()));
 
     //initialize data storage combo boxes
     m_Controls->m_ReferencePointSetComboBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_ReferencePointSetComboBox->SetAutoSelectNewItems(true);
     m_Controls->m_ReferencePointSetComboBox->SetPredicate(mitk::NodePredicateDataType::New("PointSet"));
     m_Controls->m_MeasurementPointSetComboBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_MeasurementPointSetComboBox->SetAutoSelectNewItems(true);
     m_Controls->m_MeasurementPointSetComboBox->SetPredicate(mitk::NodePredicateDataType::New("PointSet"));
   }
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnComputeRotation()
 {
   //Get all data from UI
   auto EvaluationDataCollection = GetAllDataFromUIList();
   //Compute mean Quaternions
   auto OrientationVector = GetMeanOrientationsOfAllData(EvaluationDataCollection);
 
   //Compute Rotations
 
   itk::Vector<double> rotationVec;
   //adapt for Aurora 5D tools: [0,0,1000]
   rotationVec[0] = m_Controls->m_rotVecX->value(); //X
   rotationVec[1] = m_Controls->m_rotVecY->value(); //Y
   rotationVec[2] = m_Controls->m_rotVecZ->value(); //Z
 
   std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> allOrientationErrors;
   for (std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError>::size_type i = 0; i < OrientationVector.size() - 1; ++i)
   {
     double AngleBetweenTwoQuaternions = mitk::StaticIGTHelperFunctions::GetAngleBetweenTwoQuaterions(OrientationVector.at(i), OrientationVector.at(i+1), rotationVec);
     double AngularError = fabs(AngleBetweenTwoQuaternions - 11.25);
     std::stringstream description;
     description << "Rotation Error ROT" << (i + 1) << " / ROT" << (i + 2);
     allOrientationErrors.push_back({ AngularError, description.str() });
     MITK_INFO << description.str() << ": " << AngularError;
   }
 
   //compute statistics
   std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> orientationErrorStatistics;
   orientationErrorStatistics = mitk::HummelProtocolEvaluation::ComputeStatistics(allOrientationErrors);
   MITK_INFO << "## Rotation error statistics: ##";
   for (auto stat : orientationErrorStatistics) { MITK_INFO << stat.description << ": " << stat.distanceError; }
 
   //write results to file
   allOrientationErrors.insert(allOrientationErrors.end(), orientationErrorStatistics.begin(), orientationErrorStatistics.end());
   allOrientationErrors.push_back({rotationVec[0],"Rot Vector [x]"});
   allOrientationErrors.push_back({rotationVec[1], "Rot Vector [y]"});
   allOrientationErrors.push_back({rotationVec[2], "Rot Vector [z]"});
   std::stringstream filenameOrientationStat;
   filenameOrientationStat << std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str() << ".orientationStatistics.csv";
   MITK_INFO << "Writing output to file " << filenameOrientationStat.str();
   writeToFile(filenameOrientationStat.str(), allOrientationErrors);
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnPerfomGridMatching()
 {
   mitk::PointSet::Pointer reference = dynamic_cast<mitk::PointSet*>(m_Controls->m_ReferencePointSetComboBox->GetSelectedNode()->GetData());
   mitk::PointSet::Pointer measurement = dynamic_cast<mitk::PointSet*>(m_Controls->m_MeasurementPointSetComboBox->GetSelectedNode()->GetData());
   //convert point sets to vtk poly data
   vtkSmartPointer<vtkPoints> sourcePoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkPoints> targetPoints = vtkSmartPointer<vtkPoints>::New();
   for (int i = 0; i<reference->GetSize(); i++)
   {
     double point[3] = { reference->GetPoint(i)[0], reference->GetPoint(i)[1], reference->GetPoint(i)[2] };
     sourcePoints->InsertNextPoint(point);
     double point_targets[3] = { measurement->GetPoint(i)[0], measurement->GetPoint(i)[1], measurement->GetPoint(i)[2] };
     targetPoints->InsertNextPoint(point_targets);
   }
   //compute transform
   vtkSmartPointer<vtkLandmarkTransform> transform = vtkSmartPointer<vtkLandmarkTransform>::New();
   transform->SetSourceLandmarks(sourcePoints);
   transform->SetTargetLandmarks(targetPoints);
   transform->SetModeToRigidBody();
   transform->Modified();
   transform->Update();
   //compute FRE of transform
   double FRE = mitk::StaticIGTHelperFunctions::ComputeFRE(reference, measurement, transform);
   MITK_INFO << "FRE after grid matching: " + QString::number(FRE) + " mm";
   //convert from vtk to itk data types
   itk::Matrix<float, 3, 3> rotationFloat = itk::Matrix<float, 3, 3>();
   itk::Vector<float, 3> translationFloat = itk::Vector<float, 3>();
   itk::Matrix<double, 3, 3> rotationDouble = itk::Matrix<double, 3, 3>();
   itk::Vector<double, 3> translationDouble = itk::Vector<double, 3>();
 
   vtkSmartPointer<vtkMatrix4x4> m = transform->GetMatrix();
   for (int k = 0; k<3; k++) for (int l = 0; l<3; l++)
   {
     rotationFloat[k][l] = m->GetElement(k, l);
     rotationDouble[k][l] = m->GetElement(k, l);
 
   }
   for (int k = 0; k<3; k++)
   {
     translationFloat[k] = m->GetElement(k, 3);
     translationDouble[k] = m->GetElement(k, 3);
   }
   //create affine transform 3D
   mitk::AffineTransform3D::Pointer mitkTransform = mitk::AffineTransform3D::New();
   mitkTransform->SetMatrix(rotationDouble);
   mitkTransform->SetOffset(translationDouble);
   mitk::NavigationData::Pointer transformNavigationData = mitk::NavigationData::New(mitkTransform);
   m_Controls->m_ReferencePointSetComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(mitkTransform);
   m_Controls->m_ReferencePointSetComboBox->GetSelectedNode()->GetData()->GetGeometry()->Modified();
 
   //write to file
 
   std::stringstream filename;
   filename << std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str() << ".GridMatchingResult.csv";
   MITK_INFO << "Writing output to file " << filename.str();
   std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> FRE_Error;
   FRE_Error.push_back({ FRE, "FRE after grid matching [mm]" });
   writeToFile(filename.str(), FRE_Error);
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnOrientationCalculation_CalcRef()
 {
   if (m_FilenameVector.size() != 3)
   {
     MessageBox("Need exactly three points as reference, aborting!");
     return;
   }
 
   //start loop and iterate through all files of list
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     //create navigation data player
     mitk::NavigationDataCSVSequentialPlayer::Pointer myPlayer = ConstructNewNavigationDataPlayer();
     myPlayer->SetFiletype(mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV);
     myPlayer->SetFileName(m_FilenameVector[i]);
 
     //check if the stream is valid and skip file if not
 
     //create evaluation filter
     mitk::NavigationDataEvaluationFilter::Pointer myEvaluationFilter = mitk::NavigationDataEvaluationFilter::New();
 
     //connect pipeline
     for (unsigned int j = 0; j < myPlayer->GetNumberOfOutputs(); ++j)
       myEvaluationFilter->SetInput(j, myPlayer->GetOutput(j));
 
     //update pipline until number of samples is reached
     for (int j = 0; j < m_Controls->m_NumberOfSamples->value(); ++j)
       myEvaluationFilter->Update();
 
     //store mean position as reference
     switch (i)
     {
     case 0:
       m_RefPoint1 = myEvaluationFilter->GetPositionMean(0);
       break;
     case 1:
       m_RefPoint2 = myEvaluationFilter->GetPositionMean(0);
       break;
     case 2:
       m_RefPoint3 = myEvaluationFilter->GetPositionMean(0);
       break;
     }
   }
   MessageBox("Created Reference!");
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnOrientationCalculation_CalcOrientandWriteToFile()
 {
   //start loop and iterate through all files of list
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     //create navigation data player
     mitk::NavigationDataCSVSequentialPlayer::Pointer myPlayer = ConstructNewNavigationDataPlayer();
     myPlayer->SetFiletype(mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV);
     myPlayer->SetFileName(m_FilenameVector.at(i));
 
     //open file header
     QString outputname = QString(m_FilenameVector.at(i).c_str()) + "_orientationFile.csv";
     m_CurrentWriteFile.open(outputname.toStdString().c_str(), std::ios::out);
     if (m_CurrentWriteFile.bad())
     {
       MessageBox("Error: Can't open output file!");
       return;
     }
 
     //write header to file
     m_CurrentWriteFile << "Nr;Calypso_Time;Valid_Reference;MeasureTool_Measurement-Tool[x];MeasureTool_Measurement-Tool[y];MeasureTool_Measurement-Tool[z];MeasureTool_Measurement-Tool[qx];MeasureTool_Measurement-Tool[qy];MeasureTool_Measurement-Tool[qz];MeasureTool_Measurement-Tool[qr]\n";
 
     //update pipeline until number of samples is reached
     int step = 0;
     mitk::Point3D point1, point2, point3;
     mitk::Quaternion current_orientation;
 
     for (int j = 0; !myPlayer->IsAtEnd(); j++)
     {
       myPlayer->Update();
       mitk::NavigationData::Pointer currentNavData = myPlayer->GetOutput(0);
       switch (step)
       {
       case 0:
         step++;
         point1 = currentNavData->GetPosition();
         break;
       case 1:
         step++;
         point2 = currentNavData->GetPosition();
         break;
       case 2:
         step = 0;
         point3 = currentNavData->GetPosition();
 
         //compute transform from reference to current points
         if (point1[0] == 0 &&
           point1[1] == 0 &&
           point1[2] == 0 &&
           point2[0] == 0 &&
           point2[1] == 0 &&
           point2[2] == 0 &&
           point3[0] == 0 &&
           point3[1] == 0 &&
           point3[2] == 0
           ) current_orientation.fill(0);
         else
         {
           vtkSmartPointer<vtkLandmarkTransform> transform = vtkSmartPointer<vtkLandmarkTransform>::New();
           vtkSmartPointer<vtkPoints> sourcePoints = vtkSmartPointer<vtkPoints>::New();
           double sourcepoint1[3] = { point1[0], point1[1], point1[2] };
           double sourcepoint2[3] = { point2[0], point2[1], point2[2] };
           double sourcepoint3[3] = { point3[0], point3[1], point3[2] };
           sourcePoints->InsertNextPoint(sourcepoint1);
           sourcePoints->InsertNextPoint(sourcepoint2);
           sourcePoints->InsertNextPoint(sourcepoint3);
           vtkSmartPointer<vtkPoints> targetPoints = vtkSmartPointer<vtkPoints>::New();
           double targetpoint1[3] = { m_RefPoint1[0], m_RefPoint1[1], m_RefPoint1[2] };
           double targetpoint2[3] = { m_RefPoint2[0], m_RefPoint2[1], m_RefPoint2[2] };
           double targetpoint3[3] = { m_RefPoint3[0], m_RefPoint3[1], m_RefPoint3[2] };
           targetPoints->InsertNextPoint(targetpoint1);
           targetPoints->InsertNextPoint(targetpoint2);
           targetPoints->InsertNextPoint(targetpoint3);
 
           transform->SetSourceLandmarks(sourcePoints);
           transform->SetTargetLandmarks(targetPoints);
           transform->Modified();
           transform->Update();
 
           mitk::Transform::Pointer newTransform = mitk::Transform::New();
           newTransform->SetMatrix(transform->GetMatrix());
           current_orientation = newTransform->GetOrientation();
 
           //add pointset with the three positions
           if ((j > 15) && (j < 18))
           {
             mitk::DataNode::Pointer newNode = mitk::DataNode::New();
             mitk::PointSet::Pointer newPointSet = mitk::PointSet::New();
             newPointSet->InsertPoint(0, point1);
             newPointSet->InsertPoint(1, point2);
             newPointSet->InsertPoint(2, point3);
             QString name = QString(m_FilenameVector.at(i).c_str());
             newNode->SetName(name.toStdString().c_str());
             newNode->SetData(newPointSet);
             newNode->SetFloatProperty("pointsize", 0.1);
             this->GetDataStorage()->Add(newNode);
           }
         }
 
         break;
       }
       m_CurrentWriteFile << i << ";";
       m_CurrentWriteFile << currentNavData->GetTimeStamp() << ";"; //IMPORTANT: change to GetIGTTimeStamp in new version!
       m_CurrentWriteFile << "true;";
       m_CurrentWriteFile << currentNavData->GetPosition()[0] << ";";
       m_CurrentWriteFile << currentNavData->GetPosition()[1] << ";";
       m_CurrentWriteFile << currentNavData->GetPosition()[2] << ";";
       m_CurrentWriteFile << current_orientation.x() << ";";
       m_CurrentWriteFile << current_orientation.y() << ";";
       m_CurrentWriteFile << current_orientation.z() << ";";
       m_CurrentWriteFile << current_orientation.r() << ";";
       m_CurrentWriteFile << "\n";
     }
     //close output file
     m_CurrentWriteFile.close();
   }
   MessageBox("Finished!");
 }
 
 void QmitkIGTTrackingDataEvaluationView::StdMultiWidgetAvailable(QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkIGTTrackingDataEvaluationView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = nullptr;
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnAddToCurrentList()
 {
   //read in files
   QStringList files = QFileDialog::getOpenFileNames(nullptr, "Select one or more files to open", "/", "CSV (*.csv)");
   if (files.isEmpty()) return;
 
   for (int i = 0; i < files.size(); i++)
   {
     std::string tmp = files.at(i).toStdString().c_str();
     m_FilenameVector.push_back(tmp);
   }
 
   //fill list at GUI
   m_Controls->m_FileList->clear();
   for (unsigned int i = 0; i < m_FilenameVector.size(); i++) { new QListWidgetItem(tr(m_FilenameVector.at(i).c_str()), m_Controls->m_FileList); }
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnLoadFileList()
 {
   m_FilenameVector = std::vector<std::string>();
   m_FilenameVector.clear();
   OnAddToCurrentList();
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnEvaluateDataAll()
 {
   std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> results5cm, results15cm, results30cm, resultsAccum;
   mitk::HummelProtocolEvaluation::HummelProtocolMeasurementVolume volume;
   if (m_Controls->m_standardVolume->isChecked())
   {
     volume = mitk::HummelProtocolEvaluation::standard;
     mitk::HummelProtocolEvaluation::Evaluate5cmDistances(m_PointSetMeanPositions, volume, results5cm);
     mitk::HummelProtocolEvaluation::Evaluate15cmDistances(m_PointSetMeanPositions, volume, results15cm);
     mitk::HummelProtocolEvaluation::Evaluate30cmDistances(m_PointSetMeanPositions, volume, results30cm);
     mitk::HummelProtocolEvaluation::EvaluateAccumulatedDistances(m_PointSetMeanPositions, volume, resultsAccum);
   }
   else if (m_Controls->m_smallVolume->isChecked())
   {
     volume = mitk::HummelProtocolEvaluation::small;
     mitk::HummelProtocolEvaluation::Evaluate5cmDistances(m_PointSetMeanPositions, volume, results5cm);
   }
   else if (m_Controls->m_mediumVolume->isChecked())
   {
     volume = mitk::HummelProtocolEvaluation::medium;
     mitk::HummelProtocolEvaluation::Evaluate5cmDistances(m_PointSetMeanPositions, volume, results5cm);
   }
 
 
   //write results to file
   std::stringstream filename5cm;
   filename5cm << std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str() << ".results5cm.csv";
   MITK_INFO << "Writing output to file " << filename5cm.str();
   writeToFile(filename5cm.str(), results5cm);
 
   std::stringstream filename15cm;
   filename15cm << std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str() << ".results15cm.csv";
   MITK_INFO << "Writing output to file " << filename15cm.str();
   writeToFile(filename15cm.str(), results15cm);
 
   std::stringstream filename30cm;
   filename30cm << std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str() << ".results30cm.csv";
   MITK_INFO << "Writing output to file " << filename30cm.str();
   writeToFile(filename30cm.str(), results30cm);
 
   std::stringstream filenameAccum;
   filenameAccum << std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str() << ".resultsAccumDist.csv";
   MITK_INFO << "Writing output to file " << filenameAccum.str();
   writeToFile(filenameAccum.str(), resultsAccum);
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnEvaluateData()
 {
   //open output file
   m_CurrentWriteFile.open(std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str(), std::ios::out);
   if (m_CurrentWriteFile.bad())
   {
     MessageBox("Error: Can't open output file!");
     return;
   }
 
   std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> jitterValues;
 
   //write output file header
   WriteHeader();
 
   //start loop and iterate through all files of list
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     //create navigation data player
     mitk::NavigationDataCSVSequentialPlayer::Pointer myPlayer = ConstructNewNavigationDataPlayer();
     myPlayer->SetFiletype(mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV);
     myPlayer->SetFileName(m_FilenameVector.at(i));
 
     //create evaluation filter
     mitk::NavigationDataEvaluationFilter::Pointer myEvaluationFilter = mitk::NavigationDataEvaluationFilter::New();
 
     //connect pipeline
     for (unsigned int j = 0; j < myPlayer->GetNumberOfOutputs(); ++i) { myEvaluationFilter->SetInput(j, myPlayer->GetOutput(j)); }
 
     if (myPlayer->GetNumberOfSnapshots() < m_Controls->m_NumberOfSamples->value())
     {
       MITK_WARN << "Number of snapshots (" << myPlayer->GetNumberOfSnapshots() << ") smaller than number of samples to evaluate (" << m_Controls->m_NumberOfSamples->value() << ") ! Cannot proceed!";
       return;
     }
 
     //update pipline until number of samples is reached
     for (int j = 0; j < m_Controls->m_NumberOfSamples->value(); j++)
       myEvaluationFilter->Update();
 
     //store all jitter values in separate vector for statistics
     jitterValues.push_back({ myEvaluationFilter->GetPositionErrorRMS(0), "RMS" });
 
     //write result to output file
     WriteDataSet(myEvaluationFilter, m_FilenameVector.at(i));
   }
 
   //close output file for single data
   m_CurrentWriteFile.close();
 
   //compute statistics
   std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> jitterStatistics = mitk::HummelProtocolEvaluation::ComputeStatistics(jitterValues);
   MITK_INFO << "## Jitter (RMS) statistics: ##";
   for (auto jitterStat : jitterStatistics) {MITK_INFO << jitterStat.description << ": " << jitterStat.distanceError;}
 
   //write statistic results to separate file
   std::stringstream filenameJitterStat;
   filenameJitterStat << std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str() << ".resultsJitterStatistics.csv";
   MITK_INFO << "Writing output to file " << filenameJitterStat.str();
   writeToFile(filenameJitterStat.str(), jitterStatistics);
 
   //calculate angles if option is on
   if (m_Controls->m_settingDifferenceAngles->isChecked() || m_Controls->m_DifferencesSLERP->isChecked()) CalculateDifferenceAngles();
 
   MessageBox("Finished!");
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnGeneratePointSetsOfSinglePositions()
 {
   m_scalingfactor = m_Controls->m_ScalingFactor->value();
 
   //start loop and iterate through all files of list
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     //create point set for this file
     mitk::PointSet::Pointer thisPointSet = mitk::PointSet::New();
 
     //create navigation data player
     mitk::NavigationDataCSVSequentialPlayer::Pointer myPlayer = ConstructNewNavigationDataPlayer();
     myPlayer->SetFiletype(mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV);
     myPlayer->SetFileName(m_FilenameVector.at(i));
 
     //update pipline until number of samlples is reached and store every single point
     for (int j = 0; j < m_Controls->m_NumberOfSamples->value(); j++)
     {
       myPlayer->Update();
       mitk::Point3D thisPoint = myPlayer->GetOutput()->GetPosition();
       thisPoint[0] *= m_scalingfactor;
       thisPoint[1] *= m_scalingfactor;
       thisPoint[2] *= m_scalingfactor;
       thisPointSet->InsertPoint(j, thisPoint);
     }
 
     //add point set to data storage
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     QString name = this->m_Controls->m_prefix->text() + QString("PointSet_of_All_Positions_") + QString::number(i);
     newNode->SetName(name.toStdString());
     newNode->SetData(thisPointSet);
     this->GetDataStorage()->Add(newNode);
   }
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnGeneratePointSet()
 {
   m_scalingfactor = m_Controls->m_ScalingFactor->value();
 
   mitk::PointSet::Pointer generatedPointSet = mitk::PointSet::New();
 
   //start loop and iterate through all files of list
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     //create navigation data player
     mitk::NavigationDataCSVSequentialPlayer::Pointer myPlayer = ConstructNewNavigationDataPlayer();
     myPlayer->SetFiletype(mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV);
     myPlayer->SetFileName(m_FilenameVector.at(i));
 
     //create evaluation filter
     mitk::NavigationDataEvaluationFilter::Pointer myEvaluationFilter = mitk::NavigationDataEvaluationFilter::New();
 
     //connect pipeline
     for (unsigned int j = 0; j < myPlayer->GetNumberOfOutputs(); ++j) { myEvaluationFilter->SetInput(j, myPlayer->GetOutput(j)); }
 
     //update pipline until number of samlples is reached
     for (int j = 0; j < m_Controls->m_NumberOfSamples->value(); ++j) { myEvaluationFilter->Update(); }
 
     //add mean position to point set
     mitk::Point3D meanPos = myEvaluationFilter->GetPositionMean(0);
     if (m_scalingfactor != 1)
     {
       meanPos[0] *= m_scalingfactor;
       meanPos[1] *= m_scalingfactor;
       meanPos[2] *= m_scalingfactor;
     }
     generatedPointSet->InsertPoint(i, meanPos);
   }
 
   //add point set to data storage
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   QString name = this->m_Controls->m_prefix->text() + "PointSet_of_Mean_Positions";
   newNode->SetName(name.toStdString());
   newNode->SetData(generatedPointSet);
   newNode->SetFloatProperty("pointsize", 5);
   this->GetDataStorage()->Add(newNode);
   m_PointSetMeanPositions = generatedPointSet;
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnGenerateRotationLines()
 {
   m_scalingfactor = m_Controls->m_ScalingFactor->value();
 
   //start loop and iterate through all files of list
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     //create navigation data player
     mitk::NavigationDataCSVSequentialPlayer::Pointer myPlayer = ConstructNewNavigationDataPlayer();
     myPlayer->SetFiletype(mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV);
     myPlayer->SetFileName(m_FilenameVector.at(i));
 
     //create evaluation filter
     mitk::NavigationDataEvaluationFilter::Pointer myEvaluationFilter = mitk::NavigationDataEvaluationFilter::New();
 
     //connect pipeline
     for (unsigned int j = 0; j < myPlayer->GetNumberOfOutputs(); ++j) { myEvaluationFilter->SetInput(j, myPlayer->GetOutput(j)); }
 
     //update pipline until number of samlples is reached
     for (int j = 0; j < m_Controls->m_NumberOfSamples->value(); ++j)
       myEvaluationFilter->Update();
 
     //create line from mean pos to a second point which lies along the sensor (1,0,0 in tool coordinates for aurora)
     mitk::Point3D meanPos = myEvaluationFilter->GetPositionMean(0);
     if (m_scalingfactor != 1)
     {
       meanPos[0] *= m_scalingfactor;
       meanPos[1] *= m_scalingfactor;
       meanPos[2] *= m_scalingfactor;
     }
     mitk::Point3D secondPoint;
     mitk::Point3D thirdPoint;
     mitk::Point3D fourthPoint;
 
     mitk::FillVector3D(secondPoint, 2, 0, 0); //X
     vnl_vector<mitk::ScalarType> secondPointTransformed = myEvaluationFilter->GetQuaternionMean(0).rotation_matrix_transpose().transpose() * secondPoint.GetVnlVector() + meanPos.GetVnlVector();
     mitk::Point3D secondPointTransformedMITK;
     mitk::FillVector3D(secondPointTransformedMITK, secondPointTransformed[0], secondPointTransformed[1], secondPointTransformed[2]);
 
     mitk::FillVector3D(thirdPoint, 0, 4, 0); //Y
     vnl_vector<mitk::ScalarType> thirdPointTransformed = myEvaluationFilter->GetQuaternionMean(0).rotation_matrix_transpose().transpose() * thirdPoint.GetVnlVector() + meanPos.GetVnlVector();
     mitk::Point3D thirdPointTransformedMITK;
     mitk::FillVector3D(thirdPointTransformedMITK, thirdPointTransformed[0], thirdPointTransformed[1], thirdPointTransformed[2]);
 
     mitk::FillVector3D(fourthPoint, 0, 0, 6); //Z
     vnl_vector<mitk::ScalarType> fourthPointTransformed = myEvaluationFilter->GetQuaternionMean(0).rotation_matrix_transpose().transpose() * fourthPoint.GetVnlVector() + meanPos.GetVnlVector();
     mitk::Point3D fourthPointTransformedMITK;
     mitk::FillVector3D(fourthPointTransformedMITK, fourthPointTransformed[0], fourthPointTransformed[1], fourthPointTransformed[2]);
 
     mitk::PointSet::Pointer rotationLine = mitk::PointSet::New();
     rotationLine->InsertPoint(0, secondPointTransformedMITK);
     rotationLine->InsertPoint(1, meanPos);
     rotationLine->InsertPoint(2, thirdPointTransformedMITK);
     rotationLine->InsertPoint(3, meanPos);
     rotationLine->InsertPoint(4, fourthPointTransformedMITK);
 
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     QString nodeName = this->m_Controls->m_prefix->text() + "RotationLineNumber" + QString::number(i);
     newNode->SetName(nodeName.toStdString());
     newNode->SetData(rotationLine);
     newNode->SetBoolProperty("show contour", true);
     newNode->SetFloatProperty("pointsize", 0.5);
     this->GetDataStorage()->Add(newNode);
   }
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnGenerateGroundTruthPointSet()
 {
   mitk::PointSet::Pointer generatedPointSet = mitk::PointSet::New();
   int currentPointID = 0;
   mitk::Point3D currentPoint;
   mitk::FillVector3D(currentPoint, 0, 0, 0);
   for (int i = 0; i < m_Controls->m_PointNumber2->value(); i++)
   {
     for (int j = 0; j < m_Controls->m_PointNumber1->value(); j++)
     {
       generatedPointSet->InsertPoint(currentPointID, currentPoint);
       currentPointID++;
       currentPoint[1] += m_Controls->m_PointDistance->value();
     }
     currentPoint[1] = 0;
     currentPoint[2] += m_Controls->m_PointDistance->value();
   }
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   QString nodeName = "GroundTruthPointSet_" + QString::number(m_Controls->m_PointNumber1->value()) + "x" + QString::number(m_Controls->m_PointNumber2->value()) + "_(" + QString::number(m_Controls->m_PointDistance->value()) + "mm)";
   newNode->SetName(nodeName.toStdString());
   newNode->SetData(generatedPointSet);
   newNode->SetFloatProperty("pointsize", 5);
   this->GetDataStorage()->Add(newNode);
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnConvertCSVtoXMLFile()
 {
   if (m_Controls->m_ConvertSingleFile->isChecked())
   { //convert one file
     int lines = ConvertOneFile(this->m_Controls->m_InputCSV->text().toStdString(), this->m_Controls->m_OutputXML->text().toStdString());
 
     QString result = "Converted one file with" + QString::number(lines) + " data sets";
     MessageBox(result.toStdString());
   }
   else //converte file list
   {
     if (m_CSVtoXMLInputFilenameVector.empty() || m_CSVtoXMLOutputFilenameVector.empty())
     {
       MessageBox("Error: one list is not loaded!");
       return;
     }
     else if (m_CSVtoXMLInputFilenameVector.size() != m_CSVtoXMLOutputFilenameVector.size())
     {
       MessageBox("Error: lists do not have the same number of files!");
       return;
     }
     for (std::size_t i = 0; i < m_CSVtoXMLInputFilenameVector.size(); ++i)
     {
       ConvertOneFile(m_CSVtoXMLInputFilenameVector.at(i), m_CSVtoXMLOutputFilenameVector.at(i));
     }
     QString result = "Converted " + QString::number(m_CSVtoXMLInputFilenameVector.size()) + " files from file list!";
     MessageBox(result.toStdString());
   }
 }
 
 int QmitkIGTTrackingDataEvaluationView::ConvertOneFile(std::string inputFilename, std::string outputFilename)
 {
   std::vector<mitk::NavigationData::Pointer> myNavigationDatas = GetNavigationDatasFromFile(inputFilename);
   mitk::NavigationDataRecorderDeprecated::Pointer myRecorder = mitk::NavigationDataRecorderDeprecated::New();
   myRecorder->SetFileName(outputFilename.c_str());
   mitk::NavigationData::Pointer input = mitk::NavigationData::New();
   if (m_Controls->m_ConvertCSV->isChecked()) myRecorder->SetOutputFormat(mitk::NavigationDataRecorderDeprecated::csv);
   myRecorder->AddNavigationData(input);
   myRecorder->StartRecording();
   for (std::size_t i = 0; i < myNavigationDatas.size(); ++i)
   {
     input->Graft(myNavigationDatas.at(i));
     myRecorder->Update();
   }
   myRecorder->StopRecording();
   return myNavigationDatas.size();
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnCSVtoXMLLoadInputList()
 {
   //read in filename
   QString filename = QFileDialog::getOpenFileName(nullptr, tr("Open Measurement Filename List"), "/", tr("All Files (*.*)"));
   if (filename.isNull()) return;
 
   m_CSVtoXMLInputFilenameVector = this->GetFileContentLineByLine(filename.toStdString());
 
   m_Controls->m_labelCSVtoXMLInputList->setText("READY");
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnCSVtoXMLLoadOutputList()
 {
   //read in filename
   QString filename = QFileDialog::getOpenFileName(nullptr, tr("Open Measurement Filename List"), "/", tr("All Files (*.*)"));
   if (filename.isNull()) return;
 
   m_CSVtoXMLOutputFilenameVector = this->GetFileContentLineByLine(filename.toStdString());
 
   m_Controls->m_labelCSVtoXMLOutputList->setText("READY");
 }
 
 void QmitkIGTTrackingDataEvaluationView::MessageBox(std::string s)
 {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
 }
 
 void QmitkIGTTrackingDataEvaluationView::WriteHeader()
 {
   m_CurrentWriteFile << "Filename;";
   m_CurrentWriteFile << "N;";
   m_CurrentWriteFile << "N_invalid;";
   m_CurrentWriteFile << "Percentage_invalid;";
 
   if (m_Controls->m_settingPosMean->isChecked())
   {
     m_CurrentWriteFile << "Position_Mean[x];";
     m_CurrentWriteFile << "Position_Mean[y];";
     m_CurrentWriteFile << "Position_Mean[z];";
   }
 
   if (m_Controls->m_settingPosStabw->isChecked())
   {
     m_CurrentWriteFile << "Position_StandDev[x];";
     m_CurrentWriteFile << "Position_StandDev[y];";
     m_CurrentWriteFile << "Position_StandDev[z];";
   }
 
   if (m_Controls->m_settingPosSampleStabw->isChecked())
   {
     m_CurrentWriteFile << "Position_SampleStandDev[x];";
     m_CurrentWriteFile << "Position_SampleStandDev[y];";
     m_CurrentWriteFile << "Position_SampleStandDev[z];";
   }
 
   if (m_Controls->m_settingQuaternionMean->isChecked())
   {
     m_CurrentWriteFile << "Quaternion_Mean[qx];";
     m_CurrentWriteFile << "Quaternion_Mean[qy];";
     m_CurrentWriteFile << "Quaternion_Mean[qz];";
     m_CurrentWriteFile << "Quaternion_Mean[qr];";
   }
 
   if (m_Controls->m_settionQuaternionStabw->isChecked())
   {
     m_CurrentWriteFile << "Quaternion_StandDev[qx];";
     m_CurrentWriteFile << "Quaternion_StandDev[qy];";
     m_CurrentWriteFile << "Quaternion_StandDev[qz];";
     m_CurrentWriteFile << "Quaternion_StandDev[qr];";
   }
 
   if (m_Controls->m_settingPosErrorMean->isChecked()) m_CurrentWriteFile << "PositionError_Mean;";
 
   if (m_Controls->m_settingPosErrorStabw->isChecked()) m_CurrentWriteFile << "PositionError_StandDev;";
 
   if (m_Controls->m_settingPosErrorSampleStabw->isChecked()) m_CurrentWriteFile << "PositionError_SampleStandDev;";
 
   if (m_Controls->m_settingPosErrorRMS->isChecked()) m_CurrentWriteFile << "PositionError_RMS;";
 
   if (m_Controls->m_settingPosErrorMedian->isChecked()) m_CurrentWriteFile << "PositionError_Median;";
 
   if (m_Controls->m_settingPosErrorMinMax->isChecked())
   {
     m_CurrentWriteFile << "PositionError_Max;";
     m_CurrentWriteFile << "PositionError_Min;";
   }
 
   if (m_Controls->m_settingEulerMean->isChecked())
   {
     m_CurrentWriteFile << "Euler_tx;";
     m_CurrentWriteFile << "Euler_ty;";
     m_CurrentWriteFile << "Euler_tz;";
   }
 
   if (m_Controls->m_settingEulerRMS->isChecked())
   {
     m_CurrentWriteFile << "EulerErrorRMS (rad);";
     m_CurrentWriteFile << "EulerErrorRMS (grad);";
   }
 
   m_CurrentWriteFile << "\n";
 }
 
 void QmitkIGTTrackingDataEvaluationView::WriteDataSet(mitk::NavigationDataEvaluationFilter::Pointer myEvaluationFilter, std::string dataSetName)
 {
   if (myEvaluationFilter->GetNumberOfOutputs() == 0) m_CurrentWriteFile << "Error: no input \n";
   else
   {
     m_CurrentWriteFile << dataSetName << ";";
     m_CurrentWriteFile << myEvaluationFilter->GetNumberOfAnalysedNavigationData(0) << ";";
     m_CurrentWriteFile << myEvaluationFilter->GetNumberOfInvalidSamples(0) << ";";
     m_CurrentWriteFile << myEvaluationFilter->GetPercentageOfInvalidSamples(0) << ";";
 
     if (m_Controls->m_settingPosMean->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetPositionMean(0)[0] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetPositionMean(0)[1] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetPositionMean(0)[2] << ";";
     }
 
     if (m_Controls->m_settingPosStabw->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetPositionStandardDeviation(0)[0] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetPositionStandardDeviation(0)[1] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetPositionStandardDeviation(0)[2] << ";";
     }
 
     if (m_Controls->m_settingPosSampleStabw->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetPositionSampleStandardDeviation(0)[0] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetPositionSampleStandardDeviation(0)[1] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetPositionSampleStandardDeviation(0)[2] << ";";
     }
 
     if (m_Controls->m_settingQuaternionMean->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionMean(0).x() << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionMean(0).y() << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionMean(0).z() << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionMean(0).r() << ";";
     }
 
     if (m_Controls->m_settionQuaternionStabw->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionStandardDeviation(0).x() << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionStandardDeviation(0).y() << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionStandardDeviation(0).z() << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionStandardDeviation(0).r() << ";";
     }
 
     if (m_Controls->m_settingPosErrorMean->isChecked()) m_CurrentWriteFile << myEvaluationFilter->GetPositionErrorMean(0) << ";";
     if (m_Controls->m_settingPosErrorStabw->isChecked()) m_CurrentWriteFile << myEvaluationFilter->GetPositionErrorStandardDeviation(0) << ";";
     if (m_Controls->m_settingPosErrorSampleStabw->isChecked()) m_CurrentWriteFile << myEvaluationFilter->GetPositionErrorSampleStandardDeviation(0) << ";";
     if (m_Controls->m_settingPosErrorRMS->isChecked()) m_CurrentWriteFile << myEvaluationFilter->GetPositionErrorRMS(0) << ";";
     if (m_Controls->m_settingPosErrorMedian->isChecked()) m_CurrentWriteFile << myEvaluationFilter->GetPositionErrorMedian(0) << ";";
     if (m_Controls->m_settingPosErrorMinMax->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetPositionErrorMax(0) << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetPositionErrorMin(0) << ";";
     }
 
     if (m_Controls->m_settingEulerMean->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetEulerAnglesMean(0)[0] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetEulerAnglesMean(0)[1] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetEulerAnglesMean(0)[2] << ";";
     }
 
     if (m_Controls->m_settingEulerRMS->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetEulerAnglesRMS(0) << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetEulerAnglesRMSDegree(0) << ";";
     }
 
     m_CurrentWriteFile << "\n";
   }
 }
 
 
 std::vector<mitk::Quaternion> QmitkIGTTrackingDataEvaluationView::GetMeanOrientationsOfAllData(std::vector<mitk::NavigationDataEvaluationFilter::Pointer> allData, bool useSLERP)
 {
   std::vector<mitk::Quaternion> returnValue;
 
   for (auto dataSet : allData)
   {
     if (useSLERP) returnValue.push_back(GetSLERPAverage(dataSet));
     else returnValue.push_back(dataSet->GetQuaternionMean(0));
   }
 
   return returnValue;
 }
 
 
 std::vector<mitk::NavigationDataEvaluationFilter::Pointer> QmitkIGTTrackingDataEvaluationView::GetAllDataFromUIList()
 {
   std::vector<mitk::NavigationDataEvaluationFilter::Pointer> EvaluationDataCollection;
 
   //start loop and iterate through all files of list: store the evaluation data
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     //create navigation data player
     mitk::NavigationDataCSVSequentialPlayer::Pointer myPlayer = ConstructNewNavigationDataPlayer();
     myPlayer->SetFiletype(mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV);
     myPlayer->SetFileName(m_FilenameVector.at(i));
 
     //create evaluation filter
     mitk::NavigationDataEvaluationFilter::Pointer myEvaluationFilter = mitk::NavigationDataEvaluationFilter::New();
 
     //connect pipeline
     for (unsigned int j = 0; j < myPlayer->GetNumberOfOutputs(); ++j)
       myEvaluationFilter->SetInput(j, myPlayer->GetOutput(j));
 
     //update pipline until number of samlples is reached
     for (int j = 0; j < m_Controls->m_NumberOfSamples->value(); ++j)
       myEvaluationFilter->Update();
 
     myEvaluationFilter->SetInput(nullptr);
     myPlayer = nullptr;
     EvaluationDataCollection.push_back(myEvaluationFilter);
   }
 
   return EvaluationDataCollection;
 }
 
 void QmitkIGTTrackingDataEvaluationView::CalculateDifferenceAngles()
 {
   //Get all data from UI
   std::vector<mitk::NavigationDataEvaluationFilter::Pointer> EvaluationDataCollection = GetAllDataFromUIList();
 
   //calculation and writing of output data
   //open output file
   m_CurrentAngleDifferencesWriteFile.open(std::string((m_Controls->m_OutputFilename->text() + ".angledifferences.csv").toUtf8()).c_str(), std::ios::out);
   if (m_CurrentAngleDifferencesWriteFile.bad())
   {
     MessageBox("Error: Can't open output file for angle differences calculation!");
     return;
   }
   //write header
   WriteDifferenceAnglesHeader();
   //compute angle differences
   QString pos1 = "invalid";
   QString pos2 = "invalid";
   //now iterate through all evaluation data and calculate the angles
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     pos1 = QString::fromStdString(itksys::SystemTools::GetFilenameWithoutLastExtension(m_FilenameVector.at(i)));
     for (std::size_t j = 0; j < m_FilenameVector.size(); ++j)
     {
       pos2 = QString::fromStdString(itksys::SystemTools::GetFilenameWithoutLastExtension(m_FilenameVector.at(j)));
 
       mitk::Quaternion q1;
       mitk::Quaternion q2;
 
       if (m_Controls->m_DifferencesSLERP->isChecked())
       {
         //compute slerp average
         q1 = GetSLERPAverage(EvaluationDataCollection.at(i));
         q2 = GetSLERPAverage(EvaluationDataCollection.at(j));
       }
       else
       {
         //compute arithmetic average
         q1 = EvaluationDataCollection.at(i)->GetQuaternionMean(0);
         q2 = EvaluationDataCollection.at(j)->GetQuaternionMean(0);
       }
 
       itk::Vector<double> rotationVec;
       //adapt for Aurora 5D tools: [0,0,1000]
       rotationVec[0] = 10000; //X
       rotationVec[1] = 0; //Y
       rotationVec[2] = 0; //Z
       double AngleBetweenTwoQuaternions = mitk::StaticIGTHelperFunctions::GetAngleBetweenTwoQuaterions(q1, q2, rotationVec);
 
       //write data set
       WriteDifferenceAnglesDataSet(pos1.toStdString(), pos2.toStdString(), i, j, AngleBetweenTwoQuaternions);
     }
   }
 
   //close output file
   m_CurrentAngleDifferencesWriteFile.close();
 }
 
 void QmitkIGTTrackingDataEvaluationView::WriteDifferenceAnglesHeader()
 {
   m_CurrentAngleDifferencesWriteFile << "Name;Idx1;Idx2;Angle [Degree]\n";
 }
 
 void QmitkIGTTrackingDataEvaluationView::WriteDifferenceAnglesDataSet(std::string pos1, std::string pos2, int idx1, int idx2, double angle)
 {
   m_CurrentAngleDifferencesWriteFile << "Angle between " << pos1 << " and " << pos2 << ";" << idx1 << ";" << idx2 << ";" << angle << "\n";
   MITK_INFO << "Angle: " << angle;
 }
 
 std::vector<mitk::NavigationData::Pointer> QmitkIGTTrackingDataEvaluationView::GetNavigationDatasFromFile(std::string filename)
 {
   std::vector<mitk::NavigationData::Pointer> returnValue = std::vector<mitk::NavigationData::Pointer>();
   std::vector<std::string> fileContentLineByLine = GetFileContentLineByLine(filename);
   for (std::size_t i = 1; i < fileContentLineByLine.size(); ++i) //skip header so start at 1
   {
     returnValue.push_back(GetNavigationDataOutOfOneLine(fileContentLineByLine.at(i)));
   }
 
   return returnValue;
 }
 
 std::vector<std::string> QmitkIGTTrackingDataEvaluationView::GetFileContentLineByLine(std::string filename)
 {
   std::vector<std::string> readData = std::vector<std::string>();
 
   //save old locale
   char * oldLocale;
-  oldLocale = setlocale(LC_ALL, 0);
+  oldLocale = setlocale(LC_ALL, nullptr);
 
   //define own locale
   std::locale C("C");
   setlocale(LC_ALL, "C");
 
   //read file
   std::ifstream file;
   file.open(filename.c_str(), std::ios::in);
   if (file.good())
   {
     //read out file
     file.seekg(0L, std::ios::beg);  // move to begin of file
     while (!file.eof())
     {
       std::string buffer;
       std::getline(file, buffer);    // read out file line by line
       if (buffer.size() > 0) readData.push_back(buffer);
     }
   }
 
   file.close();
 
   //switch back to old locale
   setlocale(LC_ALL, oldLocale);
 
   return readData;
 }
 
 mitk::NavigationData::Pointer QmitkIGTTrackingDataEvaluationView::GetNavigationDataOutOfOneLine(std::string line)
 {
   mitk::NavigationData::Pointer returnValue = mitk::NavigationData::New();
 
   QString myLine = QString(line.c_str());
 
   QStringList myLineList = myLine.split(';');
 
   mitk::Point3D position;
   mitk::Quaternion orientation;
 
   bool valid = false;
   if (myLineList.at(2).toStdString() == "1") valid = true;
 
   position[0] = myLineList.at(3).toDouble();
   position[1] = myLineList.at(4).toDouble();
   position[2] = myLineList.at(5).toDouble();
 
   orientation[0] = myLineList.at(6).toDouble();
   orientation[1] = myLineList.at(7).toDouble();
   orientation[2] = myLineList.at(8).toDouble();
   orientation[3] = myLineList.at(9).toDouble();
 
   returnValue->SetDataValid(valid);
   returnValue->SetPosition(position);
   returnValue->SetOrientation(orientation);
 
   return returnValue;
 }
 
 mitk::Quaternion QmitkIGTTrackingDataEvaluationView::GetSLERPAverage(mitk::NavigationDataEvaluationFilter::Pointer evaluationFilter)
 {
   mitk::Quaternion average;
 
   //build a vector of quaternions from the evaulation filter (caution always takes the first (0) input of the filter
   std::vector<mitk::Quaternion> quaternions = std::vector<mitk::Quaternion>();
   for (int i = 0; i < evaluationFilter->GetNumberOfAnalysedNavigationData(0); i++)
   {
     mitk::Quaternion currentq = evaluationFilter->GetLoggedOrientation(i, 0);
 
     quaternions.push_back(currentq);
   }
 
   //compute the slerp average using the quaternion averaging class
   mitk::QuaternionAveraging::Pointer myAverager = mitk::QuaternionAveraging::New();
   average = myAverager->CalcAverage(quaternions);
 
   return average;
 }
 
 void QmitkIGTTrackingDataEvaluationView::writeToFile(std::string filename, std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> values)
 {
   std::fstream currentFile;
   currentFile.open(filename.c_str(), std::ios::out);
   if (currentFile.bad()) { MITK_WARN << "Cannot open file, aborting!"; return; }
   currentFile << "Description" << ";" << "Error[mm]" << "\n";
   for (auto currentError : values)
   {
     currentFile << currentError.description << ";" << currentError.distanceError << "\n";
   }
   currentFile.close();
 }
 
 mitk::NavigationDataCSVSequentialPlayer::Pointer QmitkIGTTrackingDataEvaluationView::ConstructNewNavigationDataPlayer()
 {
     bool rightHanded = m_Controls->m_RigthHanded->isChecked();
     QString separator =  m_Controls->m_SeparatorSign->text();
     QChar sepaSign = separator.at(0);
     //char separatorSign;
     char separatorSign = sepaSign.toLatin1();
     //std::string separatorSign = m_Controls->m_SeparatorSign->text().toStdString();
     int sampleCount = m_Controls->m_SampleCount->value();
     bool headerRow = m_Controls->m_HeaderRow->isChecked();
     int xPos = m_Controls->m_XPos->value();
     int yPos = m_Controls->m_YPos->value();
     int zPos = m_Controls->m_ZPos->value();
     bool useQuats = m_Controls->m_UseQuats->isChecked();
     int qx = m_Controls->m_Qx->value();
     int qy = m_Controls->m_Qy->value();
     int qz = m_Controls->m_Qz->value();
     int qr = m_Controls->m_Qr->value();
     int azimuth = m_Controls->m_Azimuth->value();
     int elevation = m_Controls->m_Elevation->value();
     int roll = m_Controls->m_Roll->value();
     bool eulersInRad = m_Controls->m_Radiants->isChecked();
     //need to find the biggest column number to determine the  minimal number of columns the .csv file has to have
     int allInts[] = {xPos, yPos, zPos, qx, qy, qr, azimuth, elevation, roll};
     int minNumberOfColumns = (*std::max_element(allInts, allInts+9)+1); //size needs to be +1 because columns start at 0 but size at 1
 
     mitk::NavigationDataCSVSequentialPlayer::Pointer navDataPlayer = mitk::NavigationDataCSVSequentialPlayer::New();
     navDataPlayer->SetOptions(rightHanded, separatorSign, sampleCount, headerRow, xPos, yPos, zPos, useQuats,
                               qx, qy, qz, qr, azimuth, elevation, roll, eulersInRad, minNumberOfColumns);
     return navDataPlayer;
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingSemiAutomaticMeasurementView.cpp b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingSemiAutomaticMeasurementView.cpp
index d63b994090..fa2bb0f619 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingSemiAutomaticMeasurementView.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingSemiAutomaticMeasurementView.cpp
@@ -1,623 +1,623 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkIGTTrackingSemiAutomaticMeasurementView.h"
 #include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 #include <qfiledialog.h>
 #include <qevent.h>
 #include <QCheckBox>
 
 // MITK
 #include <mitkNavigationToolStorageDeserializer.h>
 #include <mitkTrackingDeviceSourceConfigurator.h>
 #include <mitkLog.h>
 #include "mitkHummelProtocolEvaluation.h"
 
 // POCO
 #include <Poco/File.h>
 #include <Poco/Path.h>
 
 const std::string QmitkIGTTrackingSemiAutomaticMeasurementView::VIEW_ID = "org.mitk.views.igttrackingsemiautomaticmeasurement";
 
 QmitkIGTTrackingSemiAutomaticMeasurementView::QmitkIGTTrackingSemiAutomaticMeasurementView()
   : QmitkFunctionality()
-  , m_Controls(0)
+  , m_Controls(nullptr)
   , m_MultiWidget(nullptr)
 {
   m_NextFile = 0;
   m_FilenameVector = std::vector<std::string>();
   m_Timer = new QTimer(this);
   m_logging = false;
   m_referenceValid = true;
   m_tracking = false;
   m_EvaluationFilter = mitk::NavigationDataEvaluationFilter::New();
 }
 
 QmitkIGTTrackingSemiAutomaticMeasurementView::~QmitkIGTTrackingSemiAutomaticMeasurementView()
 {
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::CreateResults()
 {
   QString LogFileName = m_Controls->m_OutputPath->text() + "_results.log";
   mitk::LoggingBackend::Unregister();
   mitk::LoggingBackend::SetLogFile(LogFileName.toStdString().c_str());
   mitk::LoggingBackend::Register();
 
   double RMSmean = 0;
   for (std::size_t i = 0; i < m_RMSValues.size(); ++i)
   {
     MITK_INFO << "RMS at " << this->m_FilenameVector.at(i) << ": " << m_RMSValues.at(i);
     RMSmean += m_RMSValues.at(i);
   }
   RMSmean /= m_RMSValues.size();
   MITK_INFO << "RMS mean over " << m_RMSValues.size() << " values: " << RMSmean;
 
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   newNode->SetName("Tracking Results");
   newNode->SetData(this->m_MeanPoints);
   this->GetDataStorage()->Add(newNode);
 
   std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> results5cmDistances;
   if (m_Controls->m_mediumVolume->isChecked())
     mitk::HummelProtocolEvaluation::Evaluate5cmDistances(m_MeanPoints, mitk::HummelProtocolEvaluation::medium, results5cmDistances);
   else if (m_Controls->m_smallVolume->isChecked())
     mitk::HummelProtocolEvaluation::Evaluate5cmDistances(m_MeanPoints, mitk::HummelProtocolEvaluation::small, results5cmDistances);
   else if (m_Controls->m_standardVolume->isChecked())
     mitk::HummelProtocolEvaluation::Evaluate5cmDistances(m_MeanPoints, mitk::HummelProtocolEvaluation::standard, results5cmDistances);
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::CreateQtPartControl(QWidget *parent)
 {
   // build up qt view, unless already done
   if (!m_Controls)
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkIGTTrackingSemiAutomaticMeasurementViewControls;
     m_Controls->setupUi(parent);
 
     //buttons
     connect(m_Controls->m_LoadMeasurementToolStorage, SIGNAL(clicked()), this, SLOT(OnLoadMeasurementStorage()));
     connect(m_Controls->m_LoadReferenceToolStorage, SIGNAL(clicked()), this, SLOT(OnLoadReferenceStorage()));
     connect(m_Controls->m_StartTracking, SIGNAL(clicked()), this, SLOT(OnStartTracking()));
     connect(m_Controls->m_LoadList, SIGNAL(clicked()), this, SLOT(OnMeasurementLoadFile()));
     connect(m_Controls->m_StartNextMeasurement, SIGNAL(clicked()), this, SLOT(StartNextMeasurement()));
     connect(m_Controls->m_ReapeatLastMeasurement, SIGNAL(clicked()), this, SLOT(RepeatLastMeasurement()));
     connect(m_Controls->m_SetReference, SIGNAL(clicked()), this, SLOT(OnSetReference()));
     connect(m_Controls->m_UseReferenceTrackingSystem, SIGNAL(toggled(bool)), this, SLOT(OnUseReferenceToggled(bool)));
     connect(m_Controls->m_CreateResults, SIGNAL(clicked()), this, SLOT(CreateResults()));
 
     //event filter
     qApp->installEventFilter(this);
 
     //timers
     connect(m_Timer, SIGNAL(timeout()), this, SLOT(UpdateTimer()));
   }
 
   //initialize some view
   m_Controls->m_StopTracking->setEnabled(false);
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::StdMultiWidgetAvailable(QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::OnUseReferenceToggled(bool state)
 {
   if (state)
   {
     m_Controls->m_ReferenceBox->setEnabled(true);
     m_Controls->m_SetReference->setEnabled(true);
   }
 
   else
   {
     m_Controls->m_ReferenceBox->setEnabled(false);
     m_Controls->m_SetReference->setEnabled(false);
   }
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = nullptr;
 }
 
 mitk::NavigationToolStorage::Pointer QmitkIGTTrackingSemiAutomaticMeasurementView::ReadStorage(std::string file)
 {
   mitk::NavigationToolStorage::Pointer returnValue;
 
   //initialize tool storage
   returnValue = mitk::NavigationToolStorage::New();
 
   //read tool storage from disk
   mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
   returnValue = myDeserializer->Deserialize(file);
   if (returnValue.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText(myDeserializer->GetErrorMessage().c_str());
     msgBox.exec();
 
     returnValue = nullptr;
   }
 
   return returnValue;
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::OnSetReference()
 {
   //initialize reference
   m_ReferenceStartPositions = std::vector<mitk::Point3D>();
   m_ReferenceTrackingDeviceSource->Update();
   QString Label = "Positions At Start: ";
   for (unsigned int i = 0; i < m_ReferenceTrackingDeviceSource->GetNumberOfOutputs(); ++i)
   {
     mitk::Point3D position = m_ReferenceTrackingDeviceSource->GetOutput(i)->GetPosition();
     Label = Label + "Tool" + QString::number(i) + ":[" + QString::number(position[0]) + ":" + QString::number(position[1]) + ":" + QString::number(position[1]) + "] ";
     m_ReferenceStartPositions.push_back(position);
   }
   m_Controls->m_ReferencePosAtStart->setText(Label);
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::OnLoadMeasurementStorage()
 {
   //read in filename
   QString filename = QFileDialog::getOpenFileName(nullptr, tr("Open Toolfile"), "/", tr("All Files (*.*)"));
   if (filename.isNull()) return;
 
   m_MeasurementStorage = ReadStorage(filename.toStdString());
 
   //update label
   Poco::Path myPath = Poco::Path(filename.toStdString()); //use this to seperate filename from path
   QString toolLabel = QString("Tool Storage: ") + QString::number(m_MeasurementStorage->GetToolCount()) + " Tools from " + myPath.getFileName().c_str();
   m_Controls->m_MeasurementToolStorageLabel->setText(toolLabel);
 
   //update status widget
   m_Controls->m_ToolStatusWidget->RemoveStatusLabels();
   m_Controls->m_ToolStatusWidget->PreShowTools(m_MeasurementStorage);
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::OnLoadReferenceStorage()
 {
   //read in filename
   static QString oldFile;
   if (oldFile.isNull()) oldFile = "/";
   QString filename = QFileDialog::getOpenFileName(nullptr, tr("Open Toolfile"), oldFile, tr("All Files (*.*)"));
   if (filename.isNull()) return;
   oldFile = filename;
 
   m_ReferenceStorage = ReadStorage(filename.toStdString());
 
   //update label
   Poco::Path myPath = Poco::Path(filename.toStdString()); //use this to seperate filename from path
   QString toolLabel = QString("Tool Storage: ") + QString::number(m_ReferenceStorage->GetToolCount()) + " Tools from " + myPath.getFileName().c_str();
   m_Controls->m_ReferenceToolStorageLabel->setText(toolLabel);
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::OnStartTracking()
 {
   //check if everything is ready to start tracking
   if (m_MeasurementStorage.IsNull())
   {
     MessageBox("Error: No measurement tools loaded yet!");
     return;
   }
   else if (m_ReferenceStorage.IsNull() && m_Controls->m_UseReferenceTrackingSystem->isChecked())
   {
     MessageBox("Error: No refernce tools loaded yet!");
     return;
   }
   else if (m_MeasurementStorage->GetToolCount() == 0)
   {
     MessageBox("Error: No way to track without tools!");
     return;
   }
   else if (m_Controls->m_UseReferenceTrackingSystem->isChecked() && (m_ReferenceStorage->GetToolCount() == 0))
   {
     MessageBox("Error: No way to track without tools!");
     return;
   }
 
   //build the first IGT pipeline (MEASUREMENT)
   mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory1 = mitk::TrackingDeviceSourceConfigurator::New(this->m_MeasurementStorage, this->m_Controls->m_MeasurementTrackingDeviceConfigurationWidget->GetTrackingDevice());
   m_MeasurementTrackingDeviceSource = myTrackingDeviceSourceFactory1->CreateTrackingDeviceSource(this->m_MeasurementToolVisualizationFilter);
   if (m_MeasurementTrackingDeviceSource.IsNull())
   {
     MessageBox(myTrackingDeviceSourceFactory1->GetErrorMessage());
     return;
   }
   //connect the tool visualization widget
   for (unsigned int i = 0; i < m_MeasurementTrackingDeviceSource->GetNumberOfOutputs(); ++i)
   {
     m_Controls->m_ToolStatusWidget->AddNavigationData(m_MeasurementTrackingDeviceSource->GetOutput(i));
     m_EvaluationFilter->SetInput(i, m_MeasurementTrackingDeviceSource->GetOutput(i));
   }
   m_Controls->m_ToolStatusWidget->ShowStatusLabels();
   m_Controls->m_ToolStatusWidget->SetShowPositions(true);
   m_Controls->m_ToolStatusWidget->SetShowQuaternions(true);
 
   //build the second IGT pipeline (REFERENCE)
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked())
   {
     mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory2 = mitk::TrackingDeviceSourceConfigurator::New(this->m_ReferenceStorage, this->m_Controls->m_ReferenceDeviceConfigurationWidget->GetTrackingDevice());
     m_ReferenceTrackingDeviceSource = myTrackingDeviceSourceFactory2->CreateTrackingDeviceSource();
     if (m_ReferenceTrackingDeviceSource.IsNull())
     {
       MessageBox(myTrackingDeviceSourceFactory2->GetErrorMessage());
       return;
     }
   }
 
   //initialize tracking
   try
   {
     m_MeasurementTrackingDeviceSource->Connect();
     m_MeasurementTrackingDeviceSource->StartTracking();
     if (m_Controls->m_UseReferenceTrackingSystem->isChecked())
     {
       m_ReferenceTrackingDeviceSource->Connect();
       m_ReferenceTrackingDeviceSource->StartTracking();
     }
   }
   catch (...)
   {
     MessageBox("Error while starting the tracking device!");
     return;
   }
 
   //set reference
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked()) OnSetReference();
 
   //start timer
   m_Timer->start(1000 / (m_Controls->m_SamplingRate->value()));
 
   m_Controls->m_StartTracking->setEnabled(false);
   m_Controls->m_StartTracking->setEnabled(true);
 
   m_tracking = true;
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::OnStopTracking()
 {
   if (this->m_logging) FinishMeasurement();
   m_MeasurementTrackingDeviceSource->Disconnect();
   m_MeasurementTrackingDeviceSource->StopTracking();
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked())
   {
     m_ReferenceTrackingDeviceSource->Disconnect();
     m_ReferenceTrackingDeviceSource->StopTracking();
   }
   m_Timer->stop();
   m_Controls->m_StartTracking->setEnabled(true);
   m_Controls->m_StartTracking->setEnabled(false);
   m_tracking = false;
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::OnMeasurementLoadFile()
 {
   m_FilenameVector = std::vector<std::string>();
   m_FilenameVector.clear();
   m_NextFile = 0;
 
   //read in filename
   QString filename = QFileDialog::getOpenFileName(nullptr, tr("Open Measurement Filename List"), "/", tr("All Files (*.*)"));
   if (filename.isNull()) return;
 
   //define own locale
   std::locale C("C");
   setlocale(LC_ALL, "C");
 
   //read file
   std::ifstream file;
   file.open(filename.toStdString().c_str(), std::ios::in);
   if (file.good())
   {
     //read out file
     file.seekg(0L, std::ios::beg);  // move to begin of file
     while (!file.eof())
     {
       std::string buffer;
       std::getline(file, buffer);    // read out file line by line
       if (buffer.size() > 0) m_FilenameVector.push_back(buffer);
     }
   }
 
   //fill list at GUI
   m_Controls->m_MeasurementList->clear();
   for (unsigned int i = 0; i < m_FilenameVector.size(); i++) { new QListWidgetItem(tr(m_FilenameVector.at(i).c_str()), m_Controls->m_MeasurementList); }
 
   //update label next measurement
   std::stringstream label;
   label << "Next Measurement: " << m_FilenameVector.at(0);
   m_Controls->m_NextMeasurement->setText(label.str().c_str());
 
   //reset results files
   m_MeanPoints = mitk::PointSet::New();
   m_RMSValues = std::vector<double>();
   m_EvaluationFilter = mitk::NavigationDataEvaluationFilter::New();
   if (m_MeasurementToolVisualizationFilter.IsNotNull()) m_EvaluationFilter->SetInput(0, m_MeasurementToolVisualizationFilter->GetOutput(0));
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::UpdateTimer()
 {
   if (m_EvaluationFilter.IsNotNull() && m_logging) m_EvaluationFilter->Update();
   else m_MeasurementToolVisualizationFilter->Update();
 
   m_Controls->m_ToolStatusWidget->Refresh();
 
   //update reference
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked())
   {
     m_ReferenceTrackingDeviceSource->Update();
     QString Label = "Current Positions: ";
     bool distanceThresholdExceeded = false;
     for (unsigned int i = 0; i < m_ReferenceTrackingDeviceSource->GetNumberOfOutputs(); ++i)
     {
       mitk::Point3D position = m_ReferenceTrackingDeviceSource->GetOutput(i)->GetPosition();
       Label = Label + "Tool" + QString::number(i) + ":[" + QString::number(position[0]) + ":" + QString::number(position[1]) + ":" + QString::number(position[1]) + "] ";
       if (position.EuclideanDistanceTo(m_ReferenceStartPositions.at(i)) > m_Controls->m_ReferenceThreshold->value()) distanceThresholdExceeded = true;
     }
     m_Controls->m_ReferenceCurrentPos->setText(Label);
     if (distanceThresholdExceeded)
     {
       m_Controls->m_ReferenceOK->setText("<html><body style=\" font-family:\'MS Shell Dlg 2\'; font-size:28pt; font-weight:400; font-style:normal;\">NOT OK!</body></html>");
       m_referenceValid = false;
     }
     else
     {
       m_Controls->m_ReferenceOK->setText("<html><body style=\" font-family:\'MS Shell Dlg 2\'; font-size:28pt; font-weight:400; font-style:normal;\">OK</body></html>");
       m_referenceValid = true;
     }
   }
 
   //update logging
   if (m_logging)
   {
     //check for missing objects
     if (m_MeasurementLoggingFilterXML.IsNull() ||
       m_MeasurementLoggingFilterCSV.IsNull()
       )
     {
       return;
     }
 
     //log/measure
     m_MeasurementLoggingFilterXML->Update();
     m_MeasurementLoggingFilterCSV->Update();
 
     if (m_Controls->m_UseReferenceTrackingSystem->isChecked() &&
       m_ReferenceLoggingFilterXML.IsNotNull() &&
       m_ReferenceLoggingFilterCSV.IsNotNull())
     {
       m_ReferenceLoggingFilterXML->Update();
       m_ReferenceLoggingFilterCSV->Update();
     }
     m_loggedFrames++;
     LogAdditionalCSVFile();
 
     //check if all frames are logged ... if yes finish the measurement
     if (m_loggedFrames > m_Controls->m_SamplesPerMeasurement->value()) { FinishMeasurement(); }
 
     //update logging label
     QString loggingLabel = "Collected Samples: " + QString::number(m_loggedFrames);
     m_Controls->m_CollectedSamples->setText(loggingLabel);
   }
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::StartNextMeasurement()
 {
   if (this->m_NextFile >= static_cast<int>(m_FilenameVector.size()))
   {
     MessageBox("Last Measurement reached!");
     return;
   }
 
   m_loggedFrames = 0;
   m_logging = true;
 
   //check if directory exists, if not create one
   Poco::File myPath(std::string(m_Controls->m_OutputPath->text().toUtf8()).c_str());
   if (!myPath.exists()) myPath.createDirectory();
 
   QString LogFileName = m_Controls->m_OutputPath->text() + QString(m_FilenameVector.at(m_NextFile).c_str()) + ".log";
   mitk::LoggingBackend::Unregister();
   mitk::LoggingBackend::SetLogFile(LogFileName.toStdString().c_str());
   mitk::LoggingBackend::Register();
 
   //initialize logging filters
   m_MeasurementLoggingFilterXML = mitk::NavigationDataRecorderDeprecated::New();
   m_MeasurementLoggingFilterXML->SetRecordingMode(mitk::NavigationDataRecorderDeprecated::NormalFile);
   m_MeasurementLoggingFilterCSV = mitk::NavigationDataRecorderDeprecated::New();
   m_MeasurementLoggingFilterCSV->SetRecordingMode(mitk::NavigationDataRecorderDeprecated::NormalFile);
   m_MeasurementLoggingFilterXML->SetOutputFormat(mitk::NavigationDataRecorderDeprecated::xml);
   m_MeasurementLoggingFilterCSV->SetOutputFormat(mitk::NavigationDataRecorderDeprecated::csv);
   QString MeasurementFilenameXML = m_Controls->m_OutputPath->text() + QString(m_FilenameVector.at(m_NextFile).c_str()) + ".xml";
   QString MeasurementFilenameCSV = m_Controls->m_OutputPath->text() + QString(m_FilenameVector.at(m_NextFile).c_str()) + ".csv";
   m_MeasurementLoggingFilterXML->SetFileName(MeasurementFilenameXML.toStdString());
   m_MeasurementLoggingFilterCSV->SetFileName(MeasurementFilenameCSV.toStdString());
   m_MeasurementLoggingFilterXML->SetRecordCountLimit(m_Controls->m_SamplesPerMeasurement->value());
   m_MeasurementLoggingFilterCSV->SetRecordCountLimit(m_Controls->m_SamplesPerMeasurement->value());
 
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked())
   {
     m_ReferenceLoggingFilterXML = mitk::NavigationDataRecorderDeprecated::New();
     m_ReferenceLoggingFilterXML->SetRecordingMode(mitk::NavigationDataRecorderDeprecated::NormalFile);
     m_ReferenceLoggingFilterCSV = mitk::NavigationDataRecorderDeprecated::New();
     m_ReferenceLoggingFilterCSV->SetRecordingMode(mitk::NavigationDataRecorderDeprecated::NormalFile);
     m_ReferenceLoggingFilterXML->SetOutputFormat(mitk::NavigationDataRecorderDeprecated::xml);
     m_ReferenceLoggingFilterCSV->SetOutputFormat(mitk::NavigationDataRecorderDeprecated::csv);
     QString ReferenceFilenameXML = m_Controls->m_OutputPath->text() + "Reference_" + QString(m_FilenameVector.at(m_NextFile).c_str()) + ".xml";
     QString ReferenceFilenameCSV = m_Controls->m_OutputPath->text() + "Reference_" + QString(m_FilenameVector.at(m_NextFile).c_str()) + ".csv";
     m_ReferenceLoggingFilterXML->SetFileName(ReferenceFilenameXML.toStdString());
     m_ReferenceLoggingFilterCSV->SetFileName(ReferenceFilenameCSV.toStdString());
     m_ReferenceLoggingFilterXML->SetRecordCountLimit(m_Controls->m_SamplesPerMeasurement->value());
     m_ReferenceLoggingFilterCSV->SetRecordCountLimit(m_Controls->m_SamplesPerMeasurement->value());
   }
 
   //start additional csv logging
   StartLoggingAdditionalCSVFile(m_FilenameVector.at(m_NextFile));
 
   //connect filter
   for (unsigned int i = 0; i < m_MeasurementToolVisualizationFilter->GetNumberOfOutputs(); ++i)
   {
     m_MeasurementLoggingFilterXML->AddNavigationData(m_MeasurementToolVisualizationFilter->GetOutput(i));
     m_MeasurementLoggingFilterCSV->AddNavigationData(m_MeasurementToolVisualizationFilter->GetOutput(i));
   }
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked()) for (unsigned int i = 0; i < m_ReferenceTrackingDeviceSource->GetNumberOfOutputs(); ++i)
   {
     m_ReferenceLoggingFilterXML->AddNavigationData(m_ReferenceTrackingDeviceSource->GetOutput(i));
     m_ReferenceLoggingFilterCSV->AddNavigationData(m_ReferenceTrackingDeviceSource->GetOutput(i));
   }
 
   //start filter
   m_MeasurementLoggingFilterXML->StartRecording();
   m_MeasurementLoggingFilterCSV->StartRecording();
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked())
   {
     m_ReferenceLoggingFilterXML->StartRecording();
     m_ReferenceLoggingFilterCSV->StartRecording();
   }
 
   //disable all buttons
   DisableAllButtons();
 
   //update label next measurement
   std::stringstream label;
   if ((m_NextFile + 1) >= static_cast<int>(m_FilenameVector.size())) label << "Next Measurement: <none>";
   else label << "Next Measurement: " << m_FilenameVector.at(m_NextFile + 1);
   m_Controls->m_NextMeasurement->setText(label.str().c_str());
 
   //update label last measurement
   std::stringstream label2;
   label2 << "Last Measurement: " << m_FilenameVector.at(m_NextFile);
   m_Controls->m_LastMeasurement->setText(label2.str().c_str());
 
   m_NextFile++;
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::RepeatLastMeasurement()
 {
   m_NextFile--;
   StartNextMeasurement();
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::MessageBox(std::string s)
 {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::DisableAllButtons()
 {
   m_Controls->m_LoadList->setEnabled(false);
   m_Controls->m_StartNextMeasurement->setEnabled(false);
   m_Controls->m_ReapeatLastMeasurement->setEnabled(false);
   m_Controls->m_SamplingRate->setEnabled(false);
   m_Controls->m_SamplesPerMeasurement->setEnabled(false);
   m_Controls->m_ReferenceThreshold->setEnabled(false);
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::EnableAllButtons()
 {
   m_Controls->m_LoadList->setEnabled(true);
   m_Controls->m_StartNextMeasurement->setEnabled(true);
   m_Controls->m_ReapeatLastMeasurement->setEnabled(true);
   m_Controls->m_SamplingRate->setEnabled(true);
   m_Controls->m_SamplesPerMeasurement->setEnabled(true);
   m_Controls->m_ReferenceThreshold->setEnabled(true);
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::FinishMeasurement()
 {
   m_logging = false;
 
   m_MeasurementLoggingFilterXML->StopRecording();
   m_MeasurementLoggingFilterCSV->StopRecording();
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked())
   {
     m_ReferenceLoggingFilterXML->StopRecording();
     m_ReferenceLoggingFilterCSV->StopRecording();
   }
   StopLoggingAdditionalCSVFile();
 
   int id = m_NextFile - 1;
   mitk::Point3D positionMean = m_EvaluationFilter->GetPositionMean(0);
   MITK_INFO << "Evaluated " << m_EvaluationFilter->GetNumberOfAnalysedNavigationData(0) << " samples.";
   double rms = m_EvaluationFilter->GetPositionErrorRMS(0);
   MITK_INFO << "RMS: " << rms;
   MITK_INFO << "Position Mean: " << positionMean;
   m_MeanPoints->SetPoint(id, positionMean);
   if (static_cast<int>(m_RMSValues.size()) <= id) m_RMSValues.push_back(rms);
   else m_RMSValues[id] = rms;
 
   m_EvaluationFilter->ResetStatistic();
 
   EnableAllButtons();
 }
 
 void  QmitkIGTTrackingSemiAutomaticMeasurementView::StartLoggingAdditionalCSVFile(std::string filePostfix)
 {
   //write logfile header
   QString header = "Nr;MITK_Time;Valid_Reference;";
   QString tool = QString("MeasureTool_") + QString(m_MeasurementTrackingDeviceSource->GetOutput(0)->GetName());
   header = header + tool + "[x];" + tool + "[y];" + tool + "[z];" + tool + "[qx];" + tool + "[qy];" + tool + "[qz];" + tool + "[qr]\n";
 
   //open logfile and write header
   m_logFileCSV.open(std::string(m_Controls->m_OutputPath->text().toUtf8()).append("/LogFileCombined").append(filePostfix.c_str()).append(".csv").c_str(), std::ios::out);
   m_logFileCSV << header.toStdString().c_str();
 }
 
 void  QmitkIGTTrackingSemiAutomaticMeasurementView::LogAdditionalCSVFile()
 {
   mitk::Point3D pos = m_MeasurementTrackingDeviceSource->GetOutput(0)->GetPosition();
   mitk::Quaternion rot = m_MeasurementTrackingDeviceSource->GetOutput(0)->GetOrientation();
   std::string valid = "";
   if (m_referenceValid) valid = "true";
   else valid = "false";
   std::stringstream timestamp;
   timestamp << m_MeasurementTrackingDeviceSource->GetOutput(0)->GetTimeStamp();
   QString dataSet = QString::number(m_loggedFrames) + ";" + QString(timestamp.str().c_str()) + ";" + QString(valid.c_str()) + ";" + QString::number(pos[0]) + ";" + QString::number(pos[1]) + ";" + QString::number(pos[2]) + ";" + QString::number(rot.x()) + ";" + QString::number(rot.y()) + ";" + QString::number(rot.z()) + ";" + QString::number(rot.r()) + "\n";
   m_logFileCSV << dataSet.toStdString();
 }
 
 void  QmitkIGTTrackingSemiAutomaticMeasurementView::StopLoggingAdditionalCSVFile()
 {
   m_logFileCSV.close();
 }
 
 bool QmitkIGTTrackingSemiAutomaticMeasurementView::eventFilter(QObject *, QEvent *ev)
 {
   if (ev->type() == QEvent::KeyPress)
   {
     QKeyEvent *k = (QKeyEvent *)ev;
     bool down = k->key() == 16777239;
 
     if (down && m_tracking && !m_logging)
       StartNextMeasurement();
   }
 
   return false;
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/mitkNavigationDataCSVSequentialPlayer.cpp b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/mitkNavigationDataCSVSequentialPlayer.cpp
index 563a0d7966..2a28b4fb54 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/mitkNavigationDataCSVSequentialPlayer.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/mitkNavigationDataCSVSequentialPlayer.cpp
@@ -1,314 +1,314 @@
 /*===================================================================
 
 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 "mitkNavigationDataCSVSequentialPlayer.h"
 #include <QString>
 #include <QStringList>
 #include <iostream>
 #include <fstream>
 
 mitk::NavigationDataCSVSequentialPlayer::NavigationDataCSVSequentialPlayer()
   : mitk::NavigationDataPlayerBase()
 {
   m_NavigationDatas = std::vector<mitk::NavigationData::Pointer>();
   m_CurrentPos = 0;
   m_Filetype = mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV;
 
 }
 
 mitk::NavigationDataCSVSequentialPlayer::~NavigationDataCSVSequentialPlayer()
 {
 }
 
 bool mitk::NavigationDataCSVSequentialPlayer::IsAtEnd()
 {
   return m_CurrentPos >= static_cast<int>(m_NavigationDatas.size());
 }
 
 void mitk::NavigationDataCSVSequentialPlayer::
 SetFileName(const std::string& fileName)
 {
   this->SetNumberOfIndexedOutputs(1);
   FillOutputEmpty(0);
 
   MITK_INFO << "Reading file: " << fileName;
   m_NavigationDatas = GetNavigationDatasFromFile(fileName);
 
   this->Modified();
 }
 
 void mitk::NavigationDataCSVSequentialPlayer::FillOutputEmpty(int number)
 {
   this->SetNthOutput(number, GetEmptyNavigationData());
 }
 
 mitk::NavigationData::Pointer mitk::NavigationDataCSVSequentialPlayer::GetEmptyNavigationData()
 {
   mitk::NavigationData::Pointer emptyNd = mitk::NavigationData::New();
   mitk::NavigationData::PositionType position;
   mitk::NavigationData::OrientationType orientation(0.0, 0.0, 0.0, 0.0);
   position.Fill(0.0);
 
   emptyNd->SetPosition(position);
   emptyNd->SetOrientation(orientation);
   emptyNd->SetDataValid(false);
   return emptyNd;
 }
 int mitk::NavigationDataCSVSequentialPlayer::GetNumberOfSnapshots()
 {
   return m_NavigationDatas.size();
 }
 void mitk::NavigationDataCSVSequentialPlayer::GenerateData()
 {
   for (unsigned int index = 0; index < this->GetNumberOfOutputs(); index++)
   {
     mitk::NavigationData* output = this->GetOutput(index);
 
     if (m_CurrentPos > static_cast<int>(m_NavigationDatas.size()))
     {
       FillOutputEmpty(index);
       return;
     }
 
     output->Graft(this->m_NavigationDatas.at(m_CurrentPos));
     m_CurrentPos++;
   }
 }
 
 void mitk::NavigationDataCSVSequentialPlayer::UpdateOutputInformation()
 {
   this->Modified();  // make sure that we need to be updated
   Superclass::UpdateOutputInformation();
 }
 
 std::vector<mitk::NavigationData::Pointer> mitk::NavigationDataCSVSequentialPlayer::GetNavigationDatasFromFile(std::string filename)
 {
   std::vector<mitk::NavigationData::Pointer> returnValue = std::vector<mitk::NavigationData::Pointer>();
   std::vector<std::string> fileContentLineByLine = GetFileContentLineByLine(filename);
   std::size_t i = m_HeaderRow
     ? 1  //file has a header row, so it has to be skipped when reading the NavigationDatas
     : 0; //file has no header row, so no need to skip the first row
 
   for ( ; i < fileContentLineByLine.size(); ++i)
   {
     returnValue.push_back(GetNavigationDataOutOfOneLine(fileContentLineByLine.at(i)));
   }
 
   return returnValue;
 }
 
 std::vector<std::string> mitk::NavigationDataCSVSequentialPlayer::GetFileContentLineByLine(std::string filename)
 {
   std::vector<std::string> readData = std::vector<std::string>();
 
   //save old locale
   char * oldLocale;
-  oldLocale = setlocale(LC_ALL, 0);
+  oldLocale = setlocale(LC_ALL, nullptr);
 
   //define own locale
   std::locale C("C");
   setlocale(LC_ALL, "C");
 
   //read file
   std::ifstream file;
   file.open(filename.c_str(), std::ios::in);
   if (file.good())
   {
     //read out file
     file.seekg(0L, std::ios::beg);  // move to begin of file
 
     int count = 0;
     while (!file.eof())
     {
       std::string buffer;
       std::getline(file, buffer);    // read out file line by line
 
       readData.push_back(buffer);
 
       ++count; if (count == m_SampleCount) count = 0;
     }
   }
 
   file.close();
 
   //switch back to old locale
   setlocale(LC_ALL, oldLocale);
 
   return readData;
 }
 
 mitk::NavigationData::Pointer mitk::NavigationDataCSVSequentialPlayer::GetNavigationDataOutOfOneLine(std::string line)
 {
   mitk::NavigationData::Pointer returnValue = mitk::NavigationData::New();
 
   QString myLine = QString(line.c_str());
 
   QStringList myLineList = myLine.split(m_SeparatorSign);
 
   mitk::Point3D position;
   mitk::Quaternion orientation;
   bool valid = false;
 
   //this is for custom csv files. You have adapt the column numbers to correctly
   //interpret your csv file.
   if (m_Filetype == mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV)
   {
     if (myLineList.size() < m_MinNumberOfColumns)
     {
       MITK_ERROR << "Error: cannot read line: only found " << myLineList.size() << " fields. Last field: " << myLineList.at(myLineList.size() - 1).toStdString();
       returnValue = GetEmptyNavigationData();
       return returnValue;
     }
 
     valid = true; //if no valid flag is given: simply set to true
 
 
     //############# Variant for the Aurora measurements ###############
     //#############   (CUSTOM .csv files from MITK)     ###############
 
     position[0] = myLineList.at(3).toDouble();
     position[1] = myLineList.at(4).toDouble();
     position[2] = myLineList.at(5).toDouble();
 
     orientation[0] = myLineList.at(6).toDouble(); //qx
     orientation[1] = myLineList.at(7).toDouble(); //qy
     orientation[2] = myLineList.at(8).toDouble(); //qz
     orientation[3] = myLineList.at(9).toDouble(); //qr
 
     if(!m_RightHanded) //MITK uses a right handed coordinate system, so the position needs to be converted
     {
         position[0] = position[0]*(-1);
     }
 
     if (m_UseQuats) //Use Quaternions to construct the orientation of the NavigationData
     {
         orientation[0] = myLineList.at(m_Qx).toDouble(); //qx
         orientation[1] = myLineList.at(m_Qy).toDouble(); //qy
         orientation[2] = myLineList.at(m_Qz).toDouble(); //qz
         orientation[3] = myLineList.at(m_Qr).toDouble(); //qr
     }
     else //Use the Euler Angles to construct the orientation of the NavigationData
     {
         double azimuthAngle;
         double elevationAngle;
         double rollAngle;
         if(m_Azimuth < 0) //azimuth is not defined so set him to zero
         {
             azimuthAngle = 0;
         }
         else
         {
             azimuthAngle = myLineList.at(m_Azimuth).toDouble();
         }
         if(m_Elevation < 0)// elevation is not defined so set him to zero
         {
             elevationAngle = 0;
         }
         else
         {
             elevationAngle = myLineList.at(m_Elevation).toDouble();
         }
         if(m_Roll < 0) //roll is not defined so set him to zero
         {
             rollAngle = 0;
         }
         else
         {
             rollAngle = myLineList.at(m_Roll).toDouble();
         }
 
 
         if (!m_EulersInRadiants) //the Euler Angles are in Degrees but MITK uses radiants so they need to be converted
         {
             azimuthAngle = azimuthAngle / 180 * itk::Math::pi;
             elevationAngle = elevationAngle / 180 * itk::Math::pi;
             rollAngle = rollAngle / 180 * itk::Math::pi;
         }
         vnl_quaternion<double> eulerQuat(rollAngle, elevationAngle, azimuthAngle);
         orientation = eulerQuat;
     }
 
     if(!m_RightHanded) //MITK uses a right handed coordinate system, so the orientation needs to be converted
     {
       //code block for conversion from left-handed to right-handed
       mitk::Quaternion linksZuRechtsdrehend;
       double rotationAngle = -itk::Math::pi;
       double rotationAxis[3];
       rotationAxis[0] = 0;
       rotationAxis[1] = 0;
       rotationAxis[2] = 1;
 
       linksZuRechtsdrehend[3] = cos(rotationAngle / 2);
       linksZuRechtsdrehend[0] = rotationAxis[0] * sin(rotationAngle / 2);
       linksZuRechtsdrehend[1] = rotationAxis[1] * sin(rotationAngle / 2);
       linksZuRechtsdrehend[2] = rotationAxis[2] * sin(rotationAngle / 2);
 
       orientation = orientation * linksZuRechtsdrehend;
     }
 
   }
   //this is for MITK csv files that have been recorded with the MITK
   //navigation data recorder. You can also use the navigation data player
   //class from the MITK-IGT module instead.
   else if (m_Filetype == mitk::NavigationDataCSVSequentialPlayer::NavigationDataCSV)
   {
     if (myLineList.size() < 8)
     {
       MITK_ERROR << "Error: cannot read line: only found " << myLineList.size() << " fields. Last field: " << myLineList.at(myLineList.size() - 1).toStdString();
       returnValue = GetEmptyNavigationData();
       return returnValue;
     }
 
     if (myLineList.at(3).toStdString() == "1") valid = true;
 
     position[0] = myLineList.at(2).toDouble();
     position[1] = myLineList.at(3).toDouble();
     position[2] = myLineList.at(4).toDouble();
 
     orientation[0] = myLineList.at(5).toDouble(); //qx
     orientation[1] = myLineList.at(6).toDouble(); //qy
     orientation[2] = myLineList.at(7).toDouble(); //qz
     orientation[3] = myLineList.at(8).toDouble(); //qr
   }
 
   returnValue->SetDataValid(valid);
   returnValue->SetPosition(position);
   returnValue->SetOrientation(orientation);
 
   return returnValue;
 }
 void mitk::NavigationDataCSVSequentialPlayer::SetOptions(bool rightHanded, char separatorSign, int sampleCount, bool headerRow, int xPos, int yPos,
                                                          int zPos, bool useQuats, int qx, int qy, int qz, int qr, int azimuth, int elevation, int roll,
                                                          bool eulerInRadiants, int minNumberOfColumns)
 {
     m_RightHanded = rightHanded;
     m_SeparatorSign = separatorSign;
     m_SampleCount = sampleCount;
     m_HeaderRow = headerRow;
     m_XPos = xPos;
     m_YPos = yPos;
     m_ZPos = zPos;
     m_UseQuats = useQuats;
     m_Qx = qx;
     m_Qy = qy;
     m_Qz = qz;
     m_Qr = qr;
     m_Azimuth = azimuth;
     m_Elevation = elevation;
     m_Roll = roll;
     m_EulersInRadiants = eulerInRadiants;
     m_MinNumberOfColumns = minNumberOfColumns;
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Filter/mitkUSNavigationTargetOcclusionFilter.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Filter/mitkUSNavigationTargetOcclusionFilter.cpp
index 2df2e6c052..3e13f28e3b 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Filter/mitkUSNavigationTargetOcclusionFilter.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Filter/mitkUSNavigationTargetOcclusionFilter.cpp
@@ -1,193 +1,193 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // MITK
 #include "mitkUSNavigationTargetOcclusionFilter.h"
 #include "mitkDataNode.h"
 #include "mitkSurface.h"
 
 // VTK
 #include "vtkSmartPointer.h"
 #include "vtkPointData.h"
 #include "vtkPolyData.h"
 #include "vtkOBBTree.h"
 #include "vtkFloatArray.h"
 #include "vtkTransform.h"
 #include "vtkTransformPolyDataFilter.h"
 
 
 mitk::USNavigationTargetOcclusionFilter::USNavigationTargetOcclusionFilter()
   : m_StartPositionInput(0)
 {
 }
 
 mitk::USNavigationTargetOcclusionFilter::~USNavigationTargetOcclusionFilter()
 {
 }
 
 void mitk::USNavigationTargetOcclusionFilter::SetTargetStructure(itk::SmartPointer<DataNode> targetStructure)
 {
   m_TargetStructure = targetStructure;
 }
 
 void mitk::USNavigationTargetOcclusionFilter::SetObstacleStructures(DataStorage::SetOfObjects::ConstPointer obstacleStructures)
 {
   m_ObstacleStructures = obstacleStructures;
 }
 
 void mitk::USNavigationTargetOcclusionFilter::SelectStartPositionInput(unsigned int n)
 {
   m_StartPositionInput = n;
 }
 
 void mitk::USNavigationTargetOcclusionFilter::GenerateData()
 {
   mitk::NavigationDataPassThroughFilter::GenerateData();
 
   // get vtk surface an the points
   vtkSmartPointer<vtkPolyData> targetSurfaceVtk = this->GetVtkPolyDataOfTarget();
   if ( ! targetSurfaceVtk ) { return; } // cannot do anything without a target surface
 
   vtkIdType numberOfPoints = targetSurfaceVtk->GetNumberOfPoints();
 
   // create array for scalar values
   vtkSmartPointer<vtkFloatArray> colors =
       vtkSmartPointer<vtkFloatArray>::New();
   colors->SetNumberOfComponents(1);
   colors->SetName("USNavigation::Occlusion");
 
   const mitk::NavigationData* nd = this->GetInput(m_StartPositionInput);
 
   // set every value to -1 if there is no (valid) navigation data
-  if ( nd == 0 || ! nd->IsDataValid() )
+  if ( nd == nullptr || ! nd->IsDataValid() )
   {
     float intersection = -1;
     for ( vtkIdType n = 0; n < numberOfPoints; n++ )
     {
       colors->InsertNextTuple1(intersection);
     }
 
     if ( numberOfPoints > 0 )
     {
       targetSurfaceVtk->GetPointData()->AddArray(colors);
       targetSurfaceVtk->GetPointData()->Update();
     }
 
     return;
   }
 
   // initialize values with 0 (no intersection) if there is valid navigation
   // data and there are some obstacle structures defined
   else if ( m_ObstacleStructures.IsNull() )
   {
     float intersection = 0;
     for ( vtkIdType n = 0; n < numberOfPoints; n++ )
     {
       colors->InsertNextTuple1(intersection);
     }
 
     if ( numberOfPoints > 0 )
     {
       targetSurfaceVtk->GetPointData()->AddArray(colors);
       targetSurfaceVtk->GetPointData()->Update();
     }
 
     return;
   }
 
   // get the current position from the navigation data
   mitk::Point3D position = nd->GetPosition();
   double point1[3];
   point1[0] = position[0]; point1[1] = position[1]; point1[2] = position[2];
 
   // transform vtk polydata according to mitk geometry
   vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter =
     vtkSmartPointer<vtkTransformPolyDataFilter>::New();
   transformFilter->SetInputData(0, targetSurfaceVtk);
   transformFilter->SetTransform(m_TargetStructure->GetData()->GetGeometry()->GetVtkTransform());
   transformFilter->Update();
   vtkSmartPointer<vtkPolyData> targetSurfaceVtkTransformed = transformFilter->GetOutput();
 
   std::vector<bool> occlusion(numberOfPoints, false);
 
   // calculate occlusion for every obstacle structure
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = m_ObstacleStructures->Begin();
     it != m_ObstacleStructures->End(); ++it)
   {
     vtkSmartPointer<vtkPolyData> polyData = dynamic_cast<mitk::Surface*>(it->Value()->GetData())->GetVtkPolyData();
 
     // transform the obstacle strucutre according to the mitk geometry
     vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter =
       vtkSmartPointer<vtkTransformPolyDataFilter>::New();
     transformFilter->SetInputData(0, polyData);
     transformFilter->SetTransform(it->Value()->GetData()->GetGeometry()->GetVtkTransform());
     transformFilter->Update();
     polyData = transformFilter->GetOutput();
 
     // build an obb tree locator
     vtkSmartPointer<vtkOBBTree> cellLocator = vtkSmartPointer<vtkOBBTree>::New();
     cellLocator->SetDataSet(polyData);
     cellLocator->BuildLocator();
 
     // test for intersection with every point on the surface
     for ( vtkIdType n = 0; n < numberOfPoints; n++ )
     {
       vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
       if ( cellLocator->IntersectWithLine(point1, targetSurfaceVtkTransformed->GetPoint(n), points, nullptr) != 0 )
       {
         occlusion.at(n) = true;
       }
     }
   }
 
   if ( numberOfPoints > 0 )
   {
     // set the occlusion values as scalar array to the vtkPolyData
     float one = 1.0f; float zero = 0.0f;
     for ( std::vector<bool>::iterator it = occlusion.begin(); it != occlusion.end(); ++it )
     {
       colors->InsertNextTuple1(*it ? one : zero);
     }
 
     targetSurfaceVtk->GetPointData()->AddArray(colors);
     targetSurfaceVtk->GetPointData()->Update();
   }
 }
 
 vtkSmartPointer<vtkPolyData> mitk::USNavigationTargetOcclusionFilter::GetVtkPolyDataOfTarget()
 {
   if ( m_TargetStructure.IsNull() )
   {
     MITK_WARN("USNavigationTargetOcclusionFilter") << "Target structure must not be null.";
     return nullptr;
   }
 
   mitk::Surface::Pointer targetSurface = dynamic_cast<mitk::Surface*>(m_TargetStructure->GetData());
   if ( targetSurface.IsNull() )
   {
     MITK_WARN("USNavigationTargetOcclusionFilter") << "A mitk::Surface has to be set to the data node.";
     return nullptr;
   }
 
   vtkSmartPointer<vtkPolyData> targetSurfaceVtk = targetSurface->GetVtkPolyData();
-  if( targetSurfaceVtk == 0 )
+  if( targetSurfaceVtk == nullptr )
   {
     MITK_WARN("USNavigationTargetOcclusionFilter") << "VtkPolyData of the mitk::Surface of the data node must not be null.";
     return nullptr;
   }
 
   return targetSurfaceVtk;
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Filter/mitkUSNavigationTargetUpdateFilter.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Filter/mitkUSNavigationTargetUpdateFilter.cpp
index 014bfefab2..645993242c 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Filter/mitkUSNavigationTargetUpdateFilter.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Filter/mitkUSNavigationTargetUpdateFilter.cpp
@@ -1,270 +1,270 @@
 /*===================================================================
 
 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 "mitkUSNavigationTargetUpdateFilter.h"
 
 #include <mitkBaseGeometry.h>
 #include "mitkDataNode.h"
 #include "mitkSurface.h"
 
 #include "vtkSmartPointer.h"
 #include "vtkUnsignedCharArray.h"
 #include "vtkPolyData.h"
 #include "vtkPointData.h"
 #include "vtkLookupTable.h"
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 #include "vtkFloatArray.h"
 #include "vtkTransformPolyDataFilter.h"
 #include "vtkLinearTransform.h"
 
 mitk::USNavigationTargetUpdateFilter::USNavigationTargetUpdateFilter()
   : m_NumberOfTargets(0), m_OptimalAngle(0),
     m_ScalarArrayIdentifier("USNavigation::NoIdentifierSet"),
     m_UseMaximumScore(false)
 {
 }
 
 mitk::USNavigationTargetUpdateFilter::~USNavigationTargetUpdateFilter()
 {
 }
 
 void mitk::USNavigationTargetUpdateFilter::SetTargetStructure(DataNode::Pointer targetStructure)
 {
   m_TargetStructure = targetStructure;
 
   // get vtk surface and the points
   vtkSmartPointer<vtkPolyData> targetSurfaceVtk = this->GetVtkPolyDataOfTarget();
   int numberOfPoints = targetSurfaceVtk->GetNumberOfPoints();
 
   if ( numberOfPoints > 0 )
   {
     // create vtk scalar array for score values
     vtkSmartPointer<vtkFloatArray> colors = vtkSmartPointer<vtkFloatArray>::New();
     colors->SetNumberOfComponents(1);
     colors->SetName(m_ScalarArrayIdentifier.c_str());
 
     // initialize with green color
     float color = 1;
     for (int n = 0; n < numberOfPoints ; ++n)
     {
       colors->InsertNextTuple1(color);
     }
 
     // add the scores array to the target surface
     targetSurfaceVtk->GetPointData()->AddArray(colors);
     targetSurfaceVtk->GetPointData()->Update();
   }
 }
 
 bool mitk::USNavigationTargetUpdateFilter::SetNumberOfTargets(unsigned int numberOfTargets)
 {
   if ( numberOfTargets < 1 || numberOfTargets > 4 )
   {
     MITK_WARN << "Number of targets can only be between 1 and 4.";
     return false;
   }
 
   if ( numberOfTargets == 1 )
   {
     m_OptimalAngle = 0;
   }
   else if ( numberOfTargets < 5 )
   {
     // for every number of targets between 2 and 4 the optimal angle can be
     // calculated using the arcus cosinus
     m_OptimalAngle = acos(-1.0/(numberOfTargets-1));
   }
 
   m_NumberOfTargets = numberOfTargets;
   return true;
 }
 
 void mitk::USNavigationTargetUpdateFilter::SetOptimalAngle(double optimalAngle)
 {
   m_OptimalAngle = optimalAngle;
 }
 
 double mitk::USNavigationTargetUpdateFilter::GetOptimalAngle()
 {
   return m_OptimalAngle;
 }
 
 void mitk::USNavigationTargetUpdateFilter::SetScalarArrayIdentifier(std::string scalarArrayIdentifier)
 {
   m_ScalarArrayIdentifier = scalarArrayIdentifier;
 }
 
 void mitk::USNavigationTargetUpdateFilter::SetUseMaximumScore(bool useMaximumScore)
 {
   m_UseMaximumScore = useMaximumScore;
 }
 
 void mitk::USNavigationTargetUpdateFilter::SetControlNode(unsigned int id, itk::SmartPointer<DataNode> controlNode)
 {
   // make sure that the node fit into the vector and insert it then
   if ( m_ControlNodesVector.size() <= id ) { m_ControlNodesVector.resize(id+1); }
   m_ControlNodesVector[id] = controlNode;
 
   this->UpdateTargetScores();
 }
 
 void mitk::USNavigationTargetUpdateFilter::RemovePositionOfTarget(unsigned int id)
 {
   if ( id >= m_ControlNodesVector.size() )
   {
     mitkThrow() << "Given id is larger than the vector size.";
   }
 
   m_ControlNodesVector.erase(m_ControlNodesVector.begin()+id);
 
   this->UpdateTargetScores();
 }
 
 void mitk::USNavigationTargetUpdateFilter::Reset()
 {
   m_ControlNodesVector.clear();
 
   if ( m_TargetStructure.IsNotNull() ) { this->UpdateTargetScores(); }
 }
 
 void mitk::USNavigationTargetUpdateFilter::UpdateTargetScores()
 {
   mitk::BaseGeometry::Pointer targetStructureGeometry = this->GetGeometryOfTarget();
   mitk::Point3D targetStructureOrigin = targetStructureGeometry->GetOrigin();
 
   // get vtk surface and the points
   vtkSmartPointer<vtkPolyData> targetSurfaceVtk = this->GetVtkPolyDataOfTarget();
   int numberOfPoints = targetSurfaceVtk->GetNumberOfPoints();
 
   // transform vtk polydata according to mitk geometry
   vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter =
     vtkSmartPointer<vtkTransformPolyDataFilter>::New();
   transformFilter->SetInputData(0, targetSurfaceVtk);
   transformFilter->SetTransform(targetStructureGeometry->GetVtkTransform());
   transformFilter->Update();
   vtkSmartPointer<vtkPolyData> targetSurfaceVtkTransformed = transformFilter->GetOutput();
 
   if ( numberOfPoints > 0 )
   {
     vtkSmartPointer<vtkFloatArray> colors =
       vtkSmartPointer<vtkFloatArray>::New();
     colors->SetNumberOfComponents(1);
     colors->SetName(m_ScalarArrayIdentifier.c_str());
 
     for (int n = 0; n < numberOfPoints ; ++n)
     {
       float score = m_UseMaximumScore ? 0.0 : 1.0;
 
       if ( m_ControlNodesVector.empty() )
       {
         // first target can be placed everywhere
         score = 1;
       }
       else if ( m_ControlNodesVector.size() == m_NumberOfTargets )
       {
         // if all targets are placed, there is no
         // good position for another target
         score = 0;
       }
       else
       {
         double coordinates[3];
         mitk::Point3D coordinatesMitk;
         targetSurfaceVtkTransformed->GetPoint(n, coordinates);
         coordinatesMitk[0] = coordinates[0];
         coordinatesMitk[1] = coordinates[1];
         coordinatesMitk[2] = coordinates[2];
 
         // vector pointing from the current surface coordinates to the origin
         // of the target structure
         itk::Vector<float, 3u> vector = targetStructureOrigin - coordinatesMitk;
         vector.Normalize();
 
         for (std::vector<mitk::DataNode::Pointer>::iterator it = m_ControlNodesVector.begin();
           it != m_ControlNodesVector.end(); ++it)
         {
-          if ( (*it)->GetData() == 0 || (*it)->GetData()->GetGeometry() == 0 )
+          if ( (*it)->GetData() == nullptr || (*it)->GetData()->GetGeometry() == nullptr )
           {
             mitkThrow() << "Control data node and geometry of the node must not be null.";
           }
 
           itk::Vector<float, 3u> controlPointToOriginVector = targetStructureOrigin - (*it)->GetData()->GetGeometry()->GetOrigin();
           controlPointToOriginVector.Normalize();
 
           float angle = acos( vector * controlPointToOriginVector );
           float angleDifference = angle - m_OptimalAngle;
           float tmpScore = 1 - (angleDifference >= 0 ? angleDifference : -angleDifference);
 
           // update the score if the current score is larger (or lower) than
           // this score
           if ( (m_UseMaximumScore && tmpScore > score) || (!m_UseMaximumScore && tmpScore < score) )
           {
             score = tmpScore;
           }
         }
       }
       colors->InsertNextTuple1(score);
     }
 
     targetSurfaceVtk->GetPointData()->AddArray(colors);
     targetSurfaceVtk->GetPointData()->Update();
   }
 }
 
 vtkSmartPointer<vtkPolyData> mitk::USNavigationTargetUpdateFilter::GetVtkPolyDataOfTarget()
 {
   if ( m_TargetStructure.IsNull() )
   {
     mitkThrow() << "Target structure must not be null.";
   }
 
   mitk::Surface::Pointer targetSurface = dynamic_cast<mitk::Surface*>(m_TargetStructure->GetData());
   if ( targetSurface.IsNull() )
   {
     mitkThrow() << "A mitk::Surface has to be set to the data node.";
   }
 
   vtkSmartPointer<vtkPolyData> targetSurfaceVtk = targetSurface->GetVtkPolyData();
-  if( targetSurfaceVtk == 0 )
+  if( targetSurfaceVtk == nullptr )
   {
     mitkThrow() << "VtkPolyData of the mitk::Surface of the data node must not be null.";
   }
 
   return targetSurfaceVtk;
 }
 
 mitk::BaseGeometry::Pointer mitk::USNavigationTargetUpdateFilter::GetGeometryOfTarget()
 {
   if ( m_TargetStructure.IsNull() )
   {
     mitkThrow() << "Target structure must be set before position of target is set.";
   }
 
   mitk::BaseData* targetStructureData = m_TargetStructure->GetData();
   if ( ! targetStructureData )
   {
     mitkThrow() << "Data of target structure must not be null.";
   }
 
   mitk::BaseGeometry::Pointer targetStructureGeometry = targetStructureData->GetGeometry();
   if ( targetStructureGeometry.IsNull() )
   {
     mitkThrow() << "Geometry of target structure must not be null.";
   }
 
   return targetStructureGeometry;
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/IO/mitkUSNavigationCombinedModalityPersistence.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/IO/mitkUSNavigationCombinedModalityPersistence.cpp
index 44f8bad907..50dfe9e446 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/IO/mitkUSNavigationCombinedModalityPersistence.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/IO/mitkUSNavigationCombinedModalityPersistence.cpp
@@ -1,213 +1,213 @@
 /*===================================================================
 
 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 "mitkUSNavigationCombinedModalityPersistence.h"
 #include "mitkUSCombinedModality.h"
 
 // Microservices
 #include <usServiceReference.h>
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 
 // Qt
 #include <QSettings>
 #include <QVector>
 #include <QHash>
 #include <QStringList>
 
 #include "internal/org_mbi_gui_qt_usnavigation_Activator.h"
 
 mitk::USNavigationCombinedModalityPersistence::USNavigationCombinedModalityPersistence()
 {
   us::ModuleContext* context = us::GetModuleContext();
 
   this->LoadStoredDevices();
 
   // to be notified about every register and unregister of an USDevice
   std::string filterExcludeCombinedModalities = "(&(" + us::ServiceConstants::OBJECTCLASS() + "="
       + "org.mitk.services.UltrasoundDevice)(!(" + mitk::USDevice::GetPropertyKeys().US_PROPKEY_CLASS + "="
       + mitk::USCombinedModality::DeviceClassIdentifier + ")))";
   context->AddServiceListener(this, &mitk::USNavigationCombinedModalityPersistence::OnServiceEvent,
     filterExcludeCombinedModalities);
 
   // to be notified about every register and unregister of an NavigationDataSource
   context->AddServiceListener(this, &mitk::USNavigationCombinedModalityPersistence::OnServiceEvent,
     "(" + us::ServiceConstants::OBJECTCLASS() + "=" + us_service_interface_iid<mitk::NavigationDataSource>() + ")");
 }
 
 mitk::USNavigationCombinedModalityPersistence::~USNavigationCombinedModalityPersistence()
 {
   //this->StoreCurrentDevices(); //disabled because persistence is buggy
 }
 
 void mitk::USNavigationCombinedModalityPersistence::OnServiceEvent(const us::ServiceEvent event)
 {
   if ( event.GetType() == event.REGISTERED )
   {
     //this->LoadStoredDevices(); //disabled because persistence is buggy
   }
 }
 
 void mitk::USNavigationCombinedModalityPersistence::StoreCurrentDevices()
 {
   QList<QVariant> devices;
 
   us::ModuleContext* context = us::GetModuleContext();
 
   // get all combined modality from the service registry
   std::string filterOnlyCombinedModalities = "(&(" + us::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.UltrasoundDevice)(" + mitk::USDevice::GetPropertyKeys().US_PROPKEY_CLASS + "=" + mitk::USCombinedModality::DeviceClassIdentifier + "))";
   std::vector<us::ServiceReference<USDevice> > services = context->GetServiceReferences<USDevice>(filterOnlyCombinedModalities);
 
   for ( std::vector<us::ServiceReference<USDevice> >::iterator it = services.begin();
         it != services.end(); ++it )
   {
     QStringList deviceStrings;
     mitk::USCombinedModality::Pointer currentDevice = dynamic_cast<mitk::USCombinedModality*>(context->GetService(*it));
     if ( currentDevice.IsNotNull() )
     {
       // save manufacturer and model strig of the combined modality
       deviceStrings.push_back(QString::fromStdString(currentDevice->GetUltrasoundDevice()->GetManufacturer()));
       deviceStrings.push_back(QString::fromStdString(currentDevice->GetUltrasoundDevice()->GetName()));
 
       // save name of the navigation data source
       mitk::NavigationDataSource::Pointer navigationDataSource = currentDevice->GetNavigationDataSource();
       if ( currentDevice.IsNull() ) { continue; }
       deviceStrings.push_back(QString::fromStdString(navigationDataSource->GetName()));
 
       // save manufacturer, model and comment of the ultrasound device
       mitk::USDevice::Pointer ultrasoundDevice = currentDevice->GetUltrasoundDevice();
       if ( ultrasoundDevice.IsNull() ) { continue; }
       deviceStrings.push_back(QString::fromStdString(ultrasoundDevice->GetManufacturer()));
       deviceStrings.push_back(QString::fromStdString(ultrasoundDevice->GetName()));
       deviceStrings.push_back(QString::fromStdString(ultrasoundDevice->GetComment()));
 
       // save calibration of the combined modality
       deviceStrings.push_back(QString::fromStdString(currentDevice->SerializeCalibration()));
     }
 
     devices.push_back(deviceStrings);
   }
 
   // store everything in QSettings
   QSettings settings;
   settings.setValue("combined-modalities", devices);
 }
 
 void mitk::USNavigationCombinedModalityPersistence::LoadStoredDevices()
 {
   // load everything from QSettings
   QSettings settings;
   QList<QVariant> devices = settings.value("combined-modalities").value< QList<QVariant> >();
 
   for ( QList<QVariant>::iterator it = devices.begin();
         it != devices.end(); ++it )
   {
     // get the saved strings for the combined modality (there must be at least
     // the seven strings, which where saved before)
     QStringList stringList = it->toStringList();
 
     // test if the combined modality wasn't restored before
     if (stringList.size() >= 7 && this->GetCombinedModality(stringList.at(0).toStdString(), stringList.at(1).toStdString()).IsNull())
     {
       // try to get matching navigation data source and ultrasound device
       mitk::NavigationDataSource::Pointer navigationDataSource = this->GetNavigationDataSource(stringList.at(2).toStdString());
       mitk::USDevice::Pointer usDevice = this->GetUSDevice(stringList.at(3).toStdString(), stringList.at(4).toStdString(), stringList.at(5).toStdString());
 
       // create the combined modality if matching navigation data source and
       // ultrasound device werde found
       if ( navigationDataSource.IsNotNull() && usDevice.IsNotNull() )
       {
         mitk::USCombinedModality::Pointer combinedModality = mitk::USCombinedModality::New(usDevice, navigationDataSource, false);
         combinedModality->DeserializeCalibration(stringList.at(6).toStdString());
         combinedModality->GetUltrasoundDevice()->Initialize();
       }
     }
   }
 }
 
 mitk::USCombinedModality::Pointer mitk::USNavigationCombinedModalityPersistence::GetCombinedModality(std::string manufacturer, std::string model)
 {
   us::ModuleContext* context = us::GetModuleContext();
 
   std::string filterOnlyCombinedModalities = "(&(" + us::ServiceConstants::OBJECTCLASS() + "="
       + "org.mitk.services.UltrasoundDevice)(" + mitk::USDevice::GetPropertyKeys().US_PROPKEY_CLASS + "="
       + mitk::USCombinedModality::DeviceClassIdentifier + "))";
   std::vector<us::ServiceReference<USDevice> > services = context->GetServiceReferences<USDevice>(filterOnlyCombinedModalities);
 
   for ( std::vector<us::ServiceReference<USDevice> >::iterator it = services.begin();
         it != services.end(); ++it )
   {
     mitk::USCombinedModality::Pointer currentDevice = dynamic_cast<mitk::USCombinedModality*>(context->GetService(*it));
     if ( currentDevice.IsNotNull() )
     {
       if ( currentDevice->GetUltrasoundDevice()->GetManufacturer() == manufacturer && currentDevice->GetUltrasoundDevice()->GetName() == model )
       {
         return currentDevice;
       }
     }
   }
 
-  return 0;
+  return nullptr;
 }
 
 mitk::USDevice::Pointer mitk::USNavigationCombinedModalityPersistence::GetUSDevice(std::string manufacturer, std::string model, std::string comment)
 {
   us::ModuleContext* context = us::GetModuleContext();
 
   std::string filterExcludeCombinedModalities = "(&(" + us::ServiceConstants::OBJECTCLASS() + "="
       + "org.mitk.services.UltrasoundDevice)(!(" + mitk::USDevice::GetPropertyKeys().US_PROPKEY_CLASS + "="
       + mitk::USCombinedModality::DeviceClassIdentifier + ")))";
   std::vector<us::ServiceReference<USDevice> > services = context->GetServiceReferences<USDevice>(filterExcludeCombinedModalities);
 
   for ( std::vector<us::ServiceReference<USDevice> >::iterator it = services.begin();
         it != services.end(); ++it )
   {
     mitk::USDevice::Pointer currentDevice = dynamic_cast<mitk::USDevice*>(context->GetService(*it));
     if ( currentDevice.IsNotNull() )
     {
       if ( currentDevice->GetManufacturer() == manufacturer && currentDevice->GetName() == model
            && currentDevice->GetComment() == comment )
       {
         return currentDevice;
       }
     }
   }
 
-  return 0;
+  return nullptr;
 }
 
 mitk::NavigationDataSource::Pointer mitk::USNavigationCombinedModalityPersistence::GetNavigationDataSource(std::string name)
 {
   us::ModuleContext* context = us::GetModuleContext();
 
   std::vector<us::ServiceReference<mitk::NavigationDataSource> > services = context->GetServiceReferences<mitk::NavigationDataSource>();
 
   for ( std::vector<us::ServiceReference<mitk::NavigationDataSource> >::iterator it = services.begin();
         it != services.end(); ++it )
   {
     mitk::NavigationDataSource::Pointer currentDevice = dynamic_cast<mitk::NavigationDataSource*>(context->GetService(*it));
     if ( currentDevice.IsNotNull() )
     {
       if ( currentDevice->GetName() == name )
       {
         return currentDevice;
       }
     }
   }
 
-  return 0;
+  return nullptr;
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Interactors/mitkUSPointMarkInteractor.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Interactors/mitkUSPointMarkInteractor.cpp
index 4648e18f78..4d4b2df3d9 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Interactors/mitkUSPointMarkInteractor.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Interactors/mitkUSPointMarkInteractor.cpp
@@ -1,58 +1,58 @@
 /*===================================================================
 
 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 "mitkUSPointMarkInteractor.h"
 #include "mitkDataNode.h"
 #include "mitkInteractionPositionEvent.h"
 
 //#include "mitkPlanarCircle.h"
 #include "mitkSurface.h"
 //#include "vtkSphere.h"
 //#include "vtkSphereSource.h"
 
 mitk::USPointMarkInteractor::USPointMarkInteractor()
 {
 }
 
 mitk::USPointMarkInteractor::~USPointMarkInteractor()
 {
 }
 
 void mitk::USPointMarkInteractor::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION("addPoint", AddPoint);
 }
 
 void mitk::USPointMarkInteractor::DataNodeChanged()
 {
   mitk::DataNode::Pointer dataNode = this->GetDataNode();
-  if (dataNode.IsNotNull() && dataNode->GetData() == 0)
+  if (dataNode.IsNotNull() && dataNode->GetData() == nullptr)
   {
     dataNode->SetData(mitk::Surface::New());
   }
 }
 
 void mitk::USPointMarkInteractor::AddPoint(mitk::StateMachineAction*, mitk::InteractionEvent* interactionEvent)
 {
   // cast InteractionEvent to a position event in order to read out the mouse position
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
   // set origin of the data node to the mouse click position
   this->GetDataNode()->GetData()->GetGeometry()->SetOrigin(positionEvent->GetPositionInWorld());
 
   CoordinatesChangedEvent.Send(this->GetDataNode());
 
   //return true;
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Interactors/mitkUSZonesInteractor.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Interactors/mitkUSZonesInteractor.cpp
index ea8fdaac69..76cd7b419b 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Interactors/mitkUSZonesInteractor.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Interactors/mitkUSZonesInteractor.cpp
@@ -1,146 +1,146 @@
 /*===================================================================
 
 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 "mitkUSZonesInteractor.h"
 #include "mitkDataStorage.h"
 #include "mitkDataNode.h"
 #include "mitkSurface.h"
 #include "mitkInteractionPositionEvent.h"
 
 #include <vtkSphereSource.h>
 
 const char* mitk::USZonesInteractor::DATANODE_PROPERTY_SIZE = "zone.size";
 const char* mitk::USZonesInteractor::DATANODE_PROPERTY_CREATED = "zone.created";
 
 void mitk::USZonesInteractor::UpdateSurface(mitk::DataNode::Pointer dataNode)
 {
   if (!dataNode->GetData())
   {
     MITK_WARN("USZonesInteractor")("DataInteractor")
       << "Cannot update surface for node as no data is set to the node.";
     return;
   }
 
   mitk::Point3D origin = dataNode->GetData()->GetGeometry()->GetOrigin();
 
   float radius;
   if (!dataNode->GetFloatProperty(DATANODE_PROPERTY_SIZE, radius))
   {
     MITK_WARN("USZonesInteractor")("DataInteractor")
       << "Cannut update surface for node as no radius is specified in the node properties.";
     return;
   }
 
   mitk::Surface::Pointer zone = mitk::Surface::New();
 
   // create a vtk sphere with given radius
   vtkSmartPointer<vtkSphereSource> vtkSphere = vtkSmartPointer<vtkSphereSource>::New();
   vtkSphere->SetRadius(radius);
   vtkSphere->SetCenter(0, 0, 0);
   vtkSphere->SetPhiResolution(20);
   vtkSphere->SetThetaResolution(20);
   vtkSphere->Update();
   zone->SetVtkPolyData(vtkSphere->GetOutput());
 
   // set vtk sphere and origin to data node (origin must be set
   // again, because of the new sphere set as data)
   dataNode->SetData(zone);
   dataNode->GetData()->GetGeometry()->SetOrigin(origin);
 
   // update the RenderWindow to show the changed surface
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 mitk::USZonesInteractor::USZonesInteractor()
 {
 }
 
 mitk::USZonesInteractor::~USZonesInteractor()
 {
 }
 
 void mitk::USZonesInteractor::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION("addCenter", AddCenter);
   CONNECT_FUNCTION("changeRadius", ChangeRadius);
   CONNECT_FUNCTION("endCreation", EndCreation);
   CONNECT_FUNCTION("abortCreation", AbortCreation);
 }
 
 void mitk::USZonesInteractor::DataNodeChanged()
 {
   mitk::DataNode::Pointer dataNode = this->GetDataNode();
-  if (dataNode.IsNotNull() && dataNode->GetData() == 0)
+  if (dataNode.IsNotNull() && dataNode->GetData() == nullptr)
   {
     dataNode->SetData(mitk::Surface::New());
   }
 }
 
 void mitk::USZonesInteractor::AddCenter(mitk::StateMachineAction*, mitk::InteractionEvent* interactionEvent)
 {
   // cast InteractionEvent to a position event in order to read out the mouse position
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
   mitk::DataNode::Pointer dataNode = this->GetDataNode();
   dataNode->SetBoolProperty(DATANODE_PROPERTY_CREATED, false);
 
   // make sure that data node contains data
   mitk::BaseData::Pointer dataNodeData = this->GetDataNode()->GetData();
   if (dataNodeData.IsNull())
   {
     dataNodeData = mitk::Surface::New();
     this->GetDataNode()->SetData(dataNodeData);
   }
 
   // set origin of the data node to the mouse click position
   dataNodeData->GetGeometry()->SetOrigin(positionEvent->GetPositionInWorld());
   MITK_INFO("USNavigationLogging") << "Critical Structure added on position " << positionEvent->GetPointerPositionOnScreen() << " (Image Coordinates); "
     << positionEvent->GetPositionInWorld() << " (World Coordinates)";
 
   dataNode->SetFloatProperty("opacity", 0.60f);
 
   //return true;
 }
 
 void mitk::USZonesInteractor::ChangeRadius(mitk::StateMachineAction*, mitk::InteractionEvent* interactionEvent)
 {
   // cast InteractionEvent to a position event in order to read out the mouse position
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
   mitk::DataNode::Pointer curNode = this->GetDataNode();
   mitk::Point3D mousePosition = positionEvent->GetPositionInWorld();
 
   mitk::ScalarType radius = mousePosition.EuclideanDistanceTo(curNode->GetData()->GetGeometry()->GetOrigin());
   curNode->SetFloatProperty(DATANODE_PROPERTY_SIZE, radius);
 
   mitk::USZonesInteractor::UpdateSurface(curNode);
 
   //return true;
 }
 
 void mitk::USZonesInteractor::EndCreation(mitk::StateMachineAction*, mitk::InteractionEvent* /*interactionEvent*/)
 {
   this->GetDataNode()->SetBoolProperty(DATANODE_PROPERTY_CREATED, true);
   //return true;
 }
 
 void mitk::USZonesInteractor::AbortCreation(mitk::StateMachineAction*, mitk::InteractionEvent*)
 {
   this->GetDataNode()->SetData(mitk::Surface::New());
 
   // update the RenderWindow to remove the surface
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   //return true;
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSAbstractNavigationStep.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSAbstractNavigationStep.h
index 1704cea49d..86ef1d882f 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSAbstractNavigationStep.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSAbstractNavigationStep.h
@@ -1,311 +1,311 @@
 /*===================================================================
 
 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 QMITKUSABSTRACTNAVIGATIONSTEP_H
 #define QMITKUSABSTRACTNAVIGATIONSTEP_H
 
 #include <QWidget>
 
 #include "mitkDataStorage.h"
 #include "mitkAbstractUltrasoundTrackerDevice.h"
 
 namespace itk {
 template<class T> class SmartPointer;
 }
 
 namespace mitk {
 class NavigationDataToNavigationDataFilter;
 }
 
 /**
  * \brief Abstract base class for navigation step widgets.
  *
  * This class defines a life cycle for navigation steps. Steps can be activated
  * and deactivated. The first time a step is activated, it is started before
  * the activation. Steps can be stopped, finished and restarted, too.
  *
  * On every state change, the corresponding virtual On... method is called
  * (OnStartStep(), OnActivateStep(), OnFinishStep(), ...). These methods are
  * to implement by concrete navigation step widgets. While a step is in the
  * "active" state, its OnUpdate() method is called periodically.
  */
 class QmitkUSAbstractNavigationStep : public QWidget
 {
   Q_OBJECT
 
 signals:
   /**
    * \brief Signals that all necessary actions where done.
    * The user can proceed with the next stept after this was signaled.
    */
   void SignalReadyForNextStep();
 
   /**
    * \brief Signals that it is no longer possible to proceed with following steps.
    * This signal is emmited when the result data of the step was removed or
    * changed, so that the old results are invalid for following steps.
    */
   void SignalNoLongerReadyForNextStep();
 
   /**
    * \brief Signals that the combined modality was changed by this step.
    * This signal is mainly for steps which creates the combined modality. The
    * new combined modality is given as a parameter.
    */
   void SignalCombinedModalityChanged(itk::SmartPointer<mitk::AbstractUltrasoundTrackerDevice>);
 
   /**
    * \brief Signals that an intermediate result was produced.
    * The properties of the given data node must contain the results. This signal
    * can be used to log the intermediate results of an experiment, for example
    * by using the mitk::USNavigationExperimentLogging.
    */
   void SignalIntermediateResult(const itk::SmartPointer<mitk::DataNode>);
 
   /**
    * \brief Signals that the settings node was changed.
    * This signal must not be emited in an OnSettingsChanged() method.
    */
   void SignalSettingsNodeChanged(itk::SmartPointer<mitk::DataNode>);
 
 public:
   typedef std::vector< itk::SmartPointer<mitk::NavigationDataToNavigationDataFilter> > FilterVector;
 
   enum NavigationStepState { State_Stopped, State_Started, State_Active };
 
   static const char* DATANAME_SETTINGS;
   static const char* DATANAME_IMAGESTREAM;
   static const char* DATANAME_BASENODE;
 
-  explicit QmitkUSAbstractNavigationStep(QWidget *parent = 0);
+  explicit QmitkUSAbstractNavigationStep(QWidget *parent = nullptr);
   ~QmitkUSAbstractNavigationStep() override;
 
   /**
    * \brief Getter for the title of the navigation step.
    * This title should be human readable and can be used to display the
    * available steps and the currently active step to the user.
    * The method has to be implemented by a concrete subclass.
    */
   virtual QString GetTitle() = 0;
 
   /**
    * \brief Indicates if it makes sense to be able to restart the step.
    * This method must be implemented by concrete subclasses if it should not be
    * possible to restart them.
    *
    * \return true for the default implementation
    */
   virtual bool GetIsRestartable();
 
   /**
    * \brief Called every time the settings for the navigation process where changed.
    * This method may be implemented by a concrete subclass. The default
    * implementation does nothing.
    */
   virtual void OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> /*settingsNode*/) { }
 
   /**
    * \brief Getter for navigation data filters of the navigation step.
    * This method may be implemented by a concrete subclass. The default
    * implementation returns an empty vector.
    *
    * \return all navigation data filters that should be updated during the navigation process
    */
   virtual FilterVector GetFilter();
 
   /**
    * \brief Sets the data storage for the exchange of results between navigation steps.
    */
   void SetDataStorage(itk::SmartPointer<mitk::DataStorage> dataStorage);
 
   /**
    * \brief Sets the combined modality for the navigation step.
    * OnSetCombinedModality() is called internal.
    */
   void SetCombinedModality(itk::SmartPointer<mitk::AbstractUltrasoundTrackerDevice> combinedModality);
 
   /**
    * \brief Should be called to start the navigation step.
    * \return true if the state was 'stopped' before and OnStartStep() returns true
    */
   bool StartStep();
 
   /**
    * \brief Should be called to stop the navigation step.
    * \return true if the state was 'started' (or 'active') and OnStopStep() (and OnDeactivateStep()) return true
    */
   bool StopStep();
 
   /**
    * \brief Should be called to restart the navigation step.
    * \return true if OnRestartStep() returns true
    */
   bool RestartStep();
 
   /**
    * \brief Should be called to finish the navigation step.
    * The state has to be 'active' before and is 'started' afterwards.
    *
    * \return true if the state was 'active' and DeactivateStep() and OnFinishStep() return true
    */
   bool FinishStep();
 
   /**
    * \brief Should be called to activate the navigation step.
    * The step gets started before if it was stopped.
    *
    * \return true if the state wasn't 'activated' and OnActivateStep() returns true
    */
   bool ActivateStep();
 
   /**
    * \brief Should be called to deactivate the navigation step.
    * \return true if the state was 'activated' and OnDeactivateStep() returns true
    */
   bool DeactivateStep();
 
   /**
    * \brief Should be called periodically while the navigation step is active.
    * Internal, the method OnUpdate() is called.
    */
   void Update();
 
   /**
    * \brief Get the current state of the navigation step.
    * \return State_Stopped, State_Started or State_Active
    */
   NavigationStepState GetNavigationStepState();
 
 protected:
   /**
    * \brief Called when the navigation step gets started.
    * This method has to be implemented by a concrete subclass to handle actions
    * necessary for starting the step (e.g. initializing that has only to be done
    * once).
    *
    * \return if the actions were done successfully
    */
   virtual bool OnStartStep() = 0;
 
   /**
    * \brief Callen when the navigation step gets stopped.
    * This method may be implemented by a concrete subclass to handle actions
    * necessary for stopping the step (e.g. cleanup). The default implementation
    * does nothing.
    *
    * \return if the actions were done successfully; true on every call for the default implementation
    */
   virtual bool OnStopStep() { return true; }
 
   /**
    * \brief Called when restarting a navigation step.
    * This method may be implemented by a concrete subclass to handle actions
    * necessary for restarting the navigation step. The default implementations
    * calls OnStopStep() followed by OnStartStep().
    *
    * \return if the actions were done successfully
    */
   virtual bool OnRestartStep();
 
   /**
    * \brief Called when all necessary actions for the step where done.
    * This method has to be implemented by a concrete subclass to handle actions
    * necessary for finishing the navigation step.
    *
    * \return if the actions were done successfully
    */
   virtual bool OnFinishStep() = 0;
 
   /**
    * \brief Called when the navigation step gets activated.
    * This method has to be implemented by a concrete subclass to handle actions
    * necessary on activating the navigation step.
    *
    * \return if the actions were done successfully
    */
   virtual bool OnActivateStep() = 0;
 
   /**
    * \brief Called when the navigation step gets deactivated (-> state started).
    * This method may be implemented by a concrete subclass to handle actions
    * necessary on deactivating the navigation step, which means switching to
    * another step.
    *
    * \return if the actions were done successfully; true on every call for the default implementation
    */
   virtual bool OnDeactivateStep() { return true; }
 
   /**
    * \brief Called periodically while a navigation step is active.
    * This method has to be implemented by a concrete subclass to handle all
    * periodic actions during the navigation step.
    */
   virtual void OnUpdate() = 0;
 
   /**
    * \brief Called every time SetCombinedModality() was called.
    * This method may be implemented by a concrete subclass to handle this event.
    * The default implementation does nothing.
    */
   virtual void OnSetCombinedModality() { }
 
   /**
    * \brief Returns the data storage set for the navigation step.
    *
    * \param throwNull if this method should throw an exception when the data storage is null (default: true)
    * \return the data storage set by SetDataStorage(); can only be null if the parameter throwNull is set to false
    * \throws mitk::Exception if the data storage is null and the parameter throwNull is set to true
    */
   itk::SmartPointer<mitk::DataStorage> GetDataStorage(bool throwNull = true);
 
   /**
    * \brief Returns the combined modality set for the navigation step.
    *
    * \param throwNull if this method should throw an exception when the combined modality is null (default: true)
    * \return the combined modality set by SetCombinedModality(); can only be null if the parameter throwNull is set to false
    * \throws mitk::Exception if the combined modality is null and the parameter throwNull is set to true
    */
   itk::SmartPointer<mitk::AbstractUltrasoundTrackerDevice> GetCombinedModality(bool throwNull = true);
 
   /**
    * \brief Returns node with the given name and the given source node (parent) from the data storage.
    *
    * \param name the name of the node which should be got from the data storage
    * \param sourceName name of the source node under which the node should be searched
    * \return node with the given name or null if no node with the given name and source node could be found
    * \throws mitk::Exception if the data storage (can be set by SetDataStorage()) is null
    */
   itk::SmartPointer<mitk::DataNode> GetNamedDerivedNode(const char* name, const char* sourceName);
 
   /**
    * \brief Returns node with the given name and the given source node (parent) from the data storage.
    * The node is created if no matching node was found.
    *
    * \param name the name of the node which should be got from the data storage
    * \param sourceName name of the source node under which the node should be searched
    * \return node with the given name
    * \throws mitk::Exception if the data storage (can be set by SetDataStorage()) is null
    */
   itk::SmartPointer<mitk::DataNode> GetNamedDerivedNodeAndCreate(const char* name, const char* sourceName);
 
 private:
   itk::SmartPointer<mitk::DataStorage>        m_DataStorage;
   itk::SmartPointer<mitk::AbstractUltrasoundTrackerDevice> m_CombinedModality;
 
   NavigationStepState                         m_NavigationStepState;
 };
 
 #endif // QMITKUSABSTRACTNAVIGATIONSTEP_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.cpp
index 6cf3cb256b..4495f02fcb 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.cpp
@@ -1,430 +1,430 @@
 /*===================================================================
 
 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 "QmitkUSNavigationStepCombinedModality.h"
 #include "ui_QmitkUSNavigationStepCombinedModality.h"
 
 #include "mitkAbstractUltrasoundTrackerDevice.h"
 #include "mitkUSCombinedModality.h"
 
 
 #include "../Widgets/QmitkUSCombinedModalityEditWidget.h"
 
 #include <QFileDialog>
 #include <QTextStream>
 #include <QSettings>
 
 #include "mitkBaseRenderer.h"
 
 QmitkUSNavigationStepCombinedModality::QmitkUSNavigationStepCombinedModality(QWidget *parent) :
   QmitkUSAbstractNavigationStep(parent),
   m_LastCalibrationFilename(""),
   m_CalibrationLoadedNecessary(true),
   m_ListenerDeviceChanged(this, &QmitkUSNavigationStepCombinedModality::OnDevicePropertyChanged),
   ui(new Ui::QmitkUSNavigationStepCombinedModality)
 {
   ui->setupUi(this);
 
   // combined modality create widget should only be visible after button press
   ui->combinedModalityCreateWidget->setVisible(false);
   ui->combinedModalityEditWidget->setVisible(false);
 
   connect(ui->combinedModalityListWidget, SIGNAL(ServiceSelectionChanged(us::ServiceReferenceU)), this, SLOT(OnDeviceSelectionChanged()));
   connect(ui->combinedModalityListWidget, SIGNAL(ServiceModified(us::ServiceReferenceU)), this, SLOT(OnDeviceSelectionChanged()));
   connect(ui->combinedModalityCreateWidget, SIGNAL(SignalAborted()), this, SLOT(OnCombinedModalityCreationExit()));
   connect(ui->combinedModalityCreateWidget, SIGNAL(SignalCreated()), this, SLOT(OnCombinedModalityCreationExit()));
 
   connect(ui->combinedModalityEditWidget, SIGNAL(SignalAborted()), this, SLOT(OnCombinedModalityEditExit()));
   connect(ui->combinedModalityEditWidget, SIGNAL(SignalSaved()), this, SLOT(OnCombinedModalityEditExit()));
 
   std::string filterOnlyCombinedModalities = "(&(" + us::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.AbstractUltrasoundTrackerDevice)(" + mitk::AbstractUltrasoundTrackerDevice::US_PROPKEY_CLASS + "=" + mitk::AbstractUltrasoundTrackerDevice::DeviceClassIdentifier + "))";
   //std::string filter = "(&(" + us::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.UltrasoundDevice))";
   ui->combinedModalityListWidget->Initialize<mitk::AbstractUltrasoundTrackerDevice>(filterOnlyCombinedModalities);
   ui->combinedModalityListWidget->SetAutomaticallySelectFirstEntry(true);
 
   //try to load UI settings
   QSettings settings;
   settings.beginGroup(QString::fromStdString("QmitkUSNavigationStepCombinedModality"));
   m_LastCalibrationFilename = settings.value("LastCalibrationFilename", QVariant("")).toString().toStdString();
   MITK_DEBUG << "PERSISTENCE load: " << m_LastCalibrationFilename;
   settings.endGroup();
 }
 
 QmitkUSNavigationStepCombinedModality::~QmitkUSNavigationStepCombinedModality()
 {
   ui->combinedModalityListWidget->blockSignals(true);
   //save UI settings
   QSettings settings;
   settings.beginGroup(QString::fromStdString("QmitkUSNavigationStepCombinedModality"));
   settings.setValue("LastCalibrationFilename", QVariant(m_LastCalibrationFilename.c_str()));
   settings.endGroup();
   MITK_DEBUG << "PERSISTENCE save: " << m_LastCalibrationFilename;
   //delete UI
   delete ui;
 }
 
 void QmitkUSNavigationStepCombinedModality::OnDeviceSelectionChanged()
 {
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetSelectedCombinedModality();
   bool combinedModalitySelected = combinedModality.IsNotNull();
 
   ui->calibrationGroupBox->setEnabled(combinedModalitySelected);
   ui->combinedModalityDeleteButton->setEnabled(combinedModalitySelected);
   ui->combinedModalitEditButton->setEnabled(combinedModalitySelected);
 
   if (!combinedModalitySelected || m_CombinedModality != combinedModality)
   {
     emit SignalNoLongerReadyForNextStep();
 
     if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull())
     {
       m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
     }
 
     if (combinedModalitySelected && combinedModality->GetUltrasoundDevice().IsNotNull())
     {
       combinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
     }
   }
   m_CombinedModality = combinedModality;
 
   if (combinedModalitySelected)
   {
     bool calibrated = this->UpdateCalibrationState();
 
     if (!m_CalibrationLoadedNecessary) { emit SignalReadyForNextStep(); }
     else
     {
       if (calibrated) { emit SignalReadyForNextStep(); }
       else { emit SignalNoLongerReadyForNextStep(); }
     }
 
     // enable disconnect button only if combined modality is connected or active
     ui->combinedModalityDistconnectButton->setEnabled(combinedModality->GetUltrasoundDevice()->GetDeviceState() >= mitk::USDevice::State_Connected);
     ui->combinedModalityActivateButton->setEnabled(combinedModality->GetUltrasoundDevice()->GetDeviceState() < mitk::USDevice::State_Activated);
 
     this->UpdateTrackingToolNames();
   }
   else
   {
     ui->combinedModalityDistconnectButton->setEnabled(false);
     ui->combinedModalityActivateButton->setEnabled(false);
   }
 }
 
 void QmitkUSNavigationStepCombinedModality::OnLoadCalibration()
 {
   QString filename = QFileDialog::getOpenFileName(QApplication::activeWindow(),
     "Load Calibration",
     m_LastCalibrationFilename.c_str(),
     "Calibration files *.cal");
   m_LastCalibrationFilename = filename.toStdString();
 
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetSelectedCombinedModality();
   if (combinedModality.IsNull())
   {
     ui->calibrationLoadStateLabel->setText("Selected device is no USCombinedModality.");
     emit SignalNoLongerReadyForNextStep();
     return;
   }
 
   if (filename.isEmpty())
   {
     bool calibrated = this->UpdateCalibrationState();
     if (!calibrated) { emit SignalNoLongerReadyForNextStep(); }
 
     return;
   }
 
   QFile file(filename);
   if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
   {
     MITK_WARN << "Cannot open file '" << filename.toStdString() << "' for reading.";
     ui->calibrationLoadStateLabel->setText("Cannot open file '" + filename + "' for reading.");
     emit SignalNoLongerReadyForNextStep();
     return;
   }
 
   QTextStream inStream(&file);
   m_LoadedCalibration = inStream.readAll().toStdString();
   if (m_LoadedCalibration.empty())
   {
     MITK_WARN << "Failed to load file. Unsupported format?";
     ui->calibrationLoadStateLabel->setText("Failed to load file. Unsupported format?");
     emit SignalNoLongerReadyForNextStep();
     return;
   }
 
   try
   {
     combinedModality->DeserializeCalibration(m_LoadedCalibration);
   }
   catch (const mitk::Exception& /*exception*/)
   {
     MITK_WARN << "Failed to deserialize calibration. Unsuppoerted format?";
     ui->calibrationLoadStateLabel->setText("Failed to deserialize calibration. Unsuppoerted format?");
     emit SignalNoLongerReadyForNextStep();
     return;
   }
 
   ui->calibrationLoadStateLabel->setText("Loaded calibration : " + filename);
 
   m_CombinedModality = combinedModality;
 
   emit SignalReadyForNextStep();
 }
 
 void QmitkUSNavigationStepCombinedModality::OnCombinedModalityCreateNewButtonClicked()
 {
   this->SetCombinedModalityCreateWidgetEnabled(true);
 }
 
 void QmitkUSNavigationStepCombinedModality::OnCombinedModalityCreationExit()
 {
   this->SetCombinedModalityCreateWidgetEnabled(false);
   mitk::DataNode::Pointer usNode = mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetDataStorage()//GetDataStorage
     ->GetNamedNode("US Viewing Stream - Image 0");
   if (usNode.IsNotNull())
   {
     mitk::RenderingManager::GetInstance()->InitializeViews(//Reinit
       usNode->GetData()->GetTimeGeometry());//GetNode
   }
   else
   {
     MITK_WARN << "No reinit possible";
   }
 }
 
 void QmitkUSNavigationStepCombinedModality::OnCombinedModalityEditExit()
 {
   this->SetCombinedModalityEditWidgetEnabled(false);
-  ui->combinedModalityEditWidget->SetCombinedModality(0);
+  ui->combinedModalityEditWidget->SetCombinedModality(nullptr);
 }
 
 void QmitkUSNavigationStepCombinedModality::OnDeleteButtonClicked()
 {
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetSelectedCombinedModality();
   if (combinedModality.IsNotNull())
   {
     combinedModality->RemoveAllObservers();
     combinedModality->UnregisterOnService();
   }
 }
 
 void QmitkUSNavigationStepCombinedModality::OnCombinedModalityEditButtonClicked()
 {
   ui->combinedModalityEditWidget->SetCombinedModality(m_CombinedModality);
   this->SetCombinedModalityEditWidgetEnabled(true);
 }
 
 void QmitkUSNavigationStepCombinedModality::OnActivateButtonClicked()
 {
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetSelectedCombinedModality();
   if (combinedModality.IsNotNull())
   {
     if (!combinedModality->GetUltrasoundDevice()->GetIsConnected()) { combinedModality->GetUltrasoundDevice()->Connect(); }
     if (!combinedModality->GetUltrasoundDevice()->GetIsActive()) { combinedModality->GetUltrasoundDevice()->Activate(); }
   }
 }
 
 void QmitkUSNavigationStepCombinedModality::OnDisconnectButtonClicked()
 {
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetSelectedCombinedModality();
   if (combinedModality.IsNotNull())
   {
     if (combinedModality->GetUltrasoundDevice()->GetIsActive()) { combinedModality->GetUltrasoundDevice()->Deactivate(); }
     if (combinedModality->GetUltrasoundDevice()->GetIsConnected()) { combinedModality->GetUltrasoundDevice()->Disconnect(); }
   }
 }
 
 bool QmitkUSNavigationStepCombinedModality::OnStartStep()
 {
   return true;
 }
 
 bool QmitkUSNavigationStepCombinedModality::OnRestartStep()
 {
   return true;
 }
 
 bool QmitkUSNavigationStepCombinedModality::OnFinishStep()
 {
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetSelectedCombinedModality();
   if (combinedModality.IsNotNull())
   {
     QApplication::setOverrideCursor(Qt::WaitCursor);
     // make sure that the combined modality is in connected state before using it
     if (combinedModality->GetUltrasoundDevice()->GetDeviceState() < mitk::USDevice::State_Connected) { combinedModality->GetUltrasoundDevice()->Connect(); }
     if (combinedModality->GetUltrasoundDevice()->GetDeviceState() < mitk::USDevice::State_Activated) { combinedModality->GetUltrasoundDevice()->Activate(); }
     QApplication::restoreOverrideCursor();
   }
 
   emit SignalCombinedModalityChanged(combinedModality);
 
   this->CreateCombinedModalityResultAndSignalIt();
 
   return true;
 }
 
 bool QmitkUSNavigationStepCombinedModality::OnActivateStep()
 {
   // make sure that device selection status is up-to-date
   this->OnDeviceSelectionChanged();
 
   return true;
 }
 
 void QmitkUSNavigationStepCombinedModality::OnUpdate()
 {
 }
 
 QString QmitkUSNavigationStepCombinedModality::GetTitle()
 {
   return "Selection of Combined Modality";
 }
 
 bool QmitkUSNavigationStepCombinedModality::GetIsRestartable()
 {
   return false;
 }
 
 void QmitkUSNavigationStepCombinedModality::SetCombinedModalityCreateWidgetEnabled(bool enabled)
 {
   ui->combinedModalityLabel->setVisible(!enabled);
   ui->combinedModalityListWidget->setVisible(!enabled);
   ui->combinedModalityCreateButton->setVisible(!enabled);
   ui->combinedModalityDeleteButton->setVisible(!enabled);
   ui->combinedModalitEditButton->setVisible(!enabled);
   ui->combinedModalityActivateButton->setVisible(!enabled);
   ui->combinedModalityDistconnectButton->setVisible(!enabled);
   ui->helpLabel->setVisible(!enabled);
   ui->calibrationGroupBox->setVisible(!enabled);
   ui->combinedModalityCreateWidget->setVisible(enabled);
 }
 
 void QmitkUSNavigationStepCombinedModality::SetCombinedModalityEditWidgetEnabled(bool enabled)
 {
   ui->combinedModalityLabel->setVisible(!enabled);
   ui->combinedModalityListWidget->setVisible(!enabled);
   ui->combinedModalityCreateButton->setVisible(!enabled);
   ui->combinedModalityDeleteButton->setVisible(!enabled);
   ui->combinedModalitEditButton->setVisible(!enabled);
   ui->combinedModalityActivateButton->setVisible(!enabled);
   ui->combinedModalityDistconnectButton->setVisible(!enabled);
   ui->helpLabel->setVisible(!enabled);
   ui->calibrationGroupBox->setVisible(!enabled);
   ui->combinedModalityEditWidget->setVisible(enabled);
 }
 
 void QmitkUSNavigationStepCombinedModality::CreateCombinedModalityResultAndSignalIt()
 {
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetCombinedModality();
   mitk::USDevice::Pointer usDevice = combinedModality->GetUltrasoundDevice();
 
   // save identifiers and calibration to a result object
   mitk::DataNode::Pointer combinedModalityResult = mitk::DataNode::New();
   combinedModalityResult->SetName("CombinedModalityResult");
   combinedModalityResult->SetStringProperty("USNavigation::CombinedModality",
     std::string(combinedModality->GetUltrasoundDevice()->GetManufacturer() + ": " + combinedModality->GetUltrasoundDevice()->GetName()
     + " (" + combinedModality->GetUltrasoundDevice()->GetComment() + ")").c_str());
   combinedModalityResult->SetStringProperty("USNavigation::UltrasoundDevice",
     std::string(usDevice->GetManufacturer() + ": " + usDevice->GetName()
     + " (" + usDevice->GetComment() + ")").c_str());
   combinedModalityResult->SetStringProperty("USNavigation::TrackingDevice",
     combinedModality->GetNavigationDataSource()->GetName().c_str());
   combinedModalityResult->SetStringProperty("USNavigation::Calibration",
     combinedModality->SerializeCalibration().c_str());
 
   emit SignalIntermediateResult(combinedModalityResult);
 }
 
 bool QmitkUSNavigationStepCombinedModality::UpdateCalibrationState()
 {
   if (m_CombinedModality.IsNull()) { return false; }
 
   bool calibrated = m_CombinedModality->GetContainsAtLeastOneCalibration();
 
   if (calibrated) { ui->calibrationLoadStateLabel->setText("Selected device contains at least one calibration."); }
   else { ui->calibrationLoadStateLabel->setText("Selected device is not calibrated."); }
 
   return calibrated;
 }
 
 mitk::AbstractUltrasoundTrackerDevice::Pointer QmitkUSNavigationStepCombinedModality::GetSelectedCombinedModality()
 {
   // nothing more to do if no device is selected at the moment
-  if (!ui->combinedModalityListWidget->GetIsServiceSelected()) { return 0; }
+  if (!ui->combinedModalityListWidget->GetIsServiceSelected()) { return nullptr; }
 
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = ui->combinedModalityListWidget->GetSelectedService<mitk::AbstractUltrasoundTrackerDevice>();
 
   if (combinedModality.IsNull())
   {
     MITK_WARN << "Selected device is no USCombinedModality.";
   }
 
   return combinedModality;
 }
 
 void QmitkUSNavigationStepCombinedModality::SetCalibrationLoadedNecessary(bool necessary)
 {
   m_CalibrationLoadedNecessary = necessary;
 }
 
 void QmitkUSNavigationStepCombinedModality::OnDevicePropertyChanged(const std::string& key, const std::string&)
 {
   // property changes only matter if the navigation step is currently active
   // (being sensitive to them in other states may even be dangerous)
   if (this->GetNavigationStepState() < QmitkUSAbstractNavigationStep::State_Active) { return; }
 
   // calibration state could have changed if the depth was changed
   if (key == mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH)
   {
     bool calibrated = this->UpdateCalibrationState();
     if (calibrated) { emit SignalReadyForNextStep(); }
     else { emit SignalNoLongerReadyForNextStep(); }
   }
 }
 
 void QmitkUSNavigationStepCombinedModality::UpdateTrackingToolNames()
 {
   //check if everything is initialized
   if (m_CombinedModality.IsNull()) { return; }
   mitk::NavigationDataSource::Pointer navigationDataSource = m_CombinedModality->GetNavigationDataSource();
   if (navigationDataSource.IsNull()) { return; }
   if (GetDataStorage(false).IsNull()) { return; }
 
   // get the settings node
   mitk::DataNode::Pointer settingsNode = this->GetNamedDerivedNode(DATANAME_SETTINGS, DATANAME_BASENODE);
   std::string needleNames;
 
   itk::ProcessObject::DataObjectPointerArray outputs = navigationDataSource->GetOutputs();
   for (itk::ProcessObject::DataObjectPointerArray::iterator it = outputs.begin(); it != outputs.end(); ++it)
   {
     needleNames += std::string((static_cast<mitk::NavigationData*>(it->GetPointer()))->GetName()) + ";";
   }
 
   // change the settings node only if the settings changed
   std::string oldProperty;
   if (!settingsNode->GetStringProperty("settings.needle-names", oldProperty)
     || oldProperty != needleNames
     || !settingsNode->GetStringProperty("settings.reference-names", oldProperty)
     || oldProperty != needleNames)
   {
     settingsNode->SetStringProperty("settings.needle-names", needleNames.c_str());
     settingsNode->SetStringProperty("settings.reference-names", needleNames.c_str());
 
     emit SignalSettingsNodeChanged(settingsNode);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.h
index 0cf4295dcf..f0db5cc35a 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.h
@@ -1,122 +1,122 @@
 /*===================================================================
 
 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 QMITKUSNAVIGATIONSTEPCOMBINEDMODALITY_H
 #define QMITKUSNAVIGATIONSTEPCOMBINEDMODALITY_H
 
 #include "QmitkUSAbstractNavigationStep.h"
 
 namespace Ui {
 class QmitkUSNavigationStepCombinedModality;
 }
 
 /**
  * \brief Navigation step for creating and selecting a combined modality.
  * Already created combined modalities can be selected from a service list
  * widget and calibrations can be loaded for them. New combined modalities can
  * be created from two service list widgets of NavigationDataSources and
  * USDevices.
  */
 class QmitkUSNavigationStepCombinedModality : public QmitkUSAbstractNavigationStep
 {
   Q_OBJECT
 
 protected slots:
   /**
    * \brief Triggered, when the selection in the service list widget has changed.
    */
   void OnDeviceSelectionChanged();
 
   /**
    * \brief Triggered, when the user has clicked "Load Calibration".
    * Opens a file open dialog and sets the selected calibration for the selected
    * combined modality.
    */
   void OnLoadCalibration();
 
   /**
    * \brief Triggered, when the button for creating a new combined modality was clicked.
    */
   void OnCombinedModalityCreateNewButtonClicked();
 
   /**
    * \brief Triggered, when the dialog for creating a new combined modality was closed.
    */
   void OnCombinedModalityCreationExit();
 
   void OnCombinedModalityEditExit();
 
   /**
    * \brief Triggered, when the button for deleting a combined modality was clicked.
    * Unregisters the combined modality from the microservice and removes it.
    */
   void OnDeleteButtonClicked();
 
   void OnCombinedModalityEditButtonClicked();
 
   void OnActivateButtonClicked();
 
   /**
    * \brief Triggered, when the button for disconnecting a combined modality was clicked.
    * The state of the combined modality is changed to 'initialized'.
    */
   void OnDisconnectButtonClicked();
 
 public:
-  explicit QmitkUSNavigationStepCombinedModality(QWidget *parent = 0);
+  explicit QmitkUSNavigationStepCombinedModality(QWidget *parent = nullptr);
   ~QmitkUSNavigationStepCombinedModality() override;
 
   bool OnStartStep() override;
   bool OnRestartStep() override;
   bool OnFinishStep() override;
 
   bool OnActivateStep() override;
   void OnUpdate() override;
 
   QString GetTitle() override;
   bool GetIsRestartable() override;
 
   mitk::AbstractUltrasoundTrackerDevice::Pointer GetSelectedCombinedModality();
 
   void SetCalibrationLoadedNecessary(bool);
 
   void OnDevicePropertyChanged(const std::string&, const std::string&);
 
 protected:
   void SetCombinedModalityCreateWidgetEnabled(bool enabled);
   void SetCombinedModalityEditWidgetEnabled(bool enabled);
   void CreateCombinedModalityResultAndSignalIt();
 
   bool UpdateCalibrationState();
   void UpdateTrackingToolNames();
 
   /**
    * \brief The Combined Modality which was selected by the user.
    */
   itk::SmartPointer<mitk::AbstractUltrasoundTrackerDevice> m_CombinedModality;
 
   std::string m_LoadedCalibration; //<<< Temporary saving point for loaded calibration data.
   std::string m_LastCalibrationFilename; //<<< saves the filename last loaded calibration
 
   bool m_CalibrationLoadedNecessary;
 
 private:
   mitk::MessageDelegate2<QmitkUSNavigationStepCombinedModality, const std::string&, const std::string&> m_ListenerDeviceChanged;
 
   Ui::QmitkUSNavigationStepCombinedModality *ui;
 };
 
 #endif // QMITKUSNAVIGATIONSTEPCOMBINEDMODALITY_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.h
index f1ce1a52df..9acc1472ce 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.h
@@ -1,237 +1,237 @@
 /*===================================================================
 
 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 QMITKUSNAVIGATIONSTEPCTUSREGISTRATION_H
 #define QMITKUSNAVIGATIONSTEPCTUSREGISTRATION_H
 
 #include "QmitkUSAbstractNavigationStep.h"
 
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateOr.h>
 
 #include <mitkPointSet.h>
 #include <mitkImage.h>
 #include <mitkPlaneFit.h>
 
 #include <itkImage.h>
 #include <itkThresholdImageFilter.h>
 #include <itkBinaryThresholdImageFilter.h>
 #include <itkGradientMagnitudeImageFilter.h>
 #include <itkLaplacianRecursiveGaussianImageFilter.h>
 #include "itkVotingBinaryIterativeHoleFillingImageFilter.h"
 #include <itkBinaryImageToShapeLabelMapFilter.h>
 
 namespace itk {
 template<class T> class SmartPointer;
 
 }
 
 namespace mitk {
 class NodeDisplacementFilter;
 class NavigationDataSource;
 class PlaneFit;
 class FloatingImageToUltrasoundRegistrationFilter;
 }
 
 namespace Ui {
 class QmitkUSNavigationStepCtUsRegistration;
 }
 
 // Declare typedefs:
 typedef itk::Image<int, 3>  ImageType;
 typedef itk::ThresholdImageFilter<ImageType> ThresholdImageFilterType;
 typedef itk::BinaryThresholdImageFilter <ImageType, ImageType> BinaryThresholdImageFilterType;
 typedef itk::LaplacianRecursiveGaussianImageFilter<ImageType, ImageType> LaplacianRecursiveGaussianImageFilterType;
 typedef itk::VotingBinaryIterativeHoleFillingImageFilter<ImageType> VotingBinaryIterativeHoleFillingImageFilterType;
 typedef itk::BinaryImageToShapeLabelMapFilter<ImageType> BinaryImageToShapeLabelMapFilterType;
 /**
  * \brief Navigation step for marking risk structures.
  * The user can add risk structures by interacting with the render windows. The
  * risk structures are organized in an embedded table view.
  *
  * The risk structures are stored under DATANAME_BASENODE -> DATANAME_ZONES.
  *
  * This step is ready for the next step directly after activating. All actions
  * to be done in this step are optional.
  */
 class QmitkUSNavigationStepCtUsRegistration : public QmitkUSAbstractNavigationStep
 {
   Q_OBJECT
 
 public:
-  explicit QmitkUSNavigationStepCtUsRegistration(QWidget *parent = 0);
+  explicit QmitkUSNavigationStepCtUsRegistration(QWidget *parent = nullptr);
   ~QmitkUSNavigationStepCtUsRegistration() override;
 
   /**
    * \brief Initialization of the data storage nodes.
    * \return always true
    */
   bool OnStartStep() override;
 
   /**
    * \brief Resets widget and filter and removes nodes from the data storage.
    * \return always true
    */
   bool OnStopStep() override;
 
   /**
    * \brief There is nothing to be done.
    * \return always true
    */
   bool OnFinishStep() override;
 
   /**
    * \brief Selects input for the node displacement filter and emits "ReadyForNextStep" signal.
    * The input selection cannot be done earlier.
    * \return
    */
   bool OnActivateStep() override;
 
   bool OnDeactivateStep() override;
 
   /**
    * \brief Updates the tracking validity status and the combined modality.
    */
   void OnUpdate() override;
 
   /**
    * The property "settings.interaction-concept" is used.
    */
   void OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode) override;
 
   QString GetTitle() override;
 
   /**
    * @return a node displacement filter for the zone surfaces
    */
   FilterVector GetFilter() override;
 
   void OnCalculateTRE(mitk::Point3D centroidOfTargetInUSImage);
 
 signals:
   void ActualizeCtToUsRegistrationWidget();
   void GetCursorPosition();
 
 protected:
   void OnSetCombinedModality() override;
 
   void UnsetFloatingImageGeometry();
   void SetFloatingImageGeometryInformation(mitk::Image* image);
   double GetVoxelVolume();
   double GetFiducialVolume(double radius);
 
   bool FilterFloatingImage();
   void InitializeImageFilters();
 
   double GetCharacteristicDistanceAWithUpperMargin();
   double GetCharacteristicDistanceBWithLowerMargin();
   double GetCharacteristicDistanceBWithUpperMargin();
   double GetMinimalFiducialConfigurationDistance();
   void CreateMarkerModelCoordinateSystemPointSet();
 
   //Methods for Ground-Truth-Fiducial-Localization-Protocol-Evaluation
   void InitializePointsToTransformForGroundTruthProtocol();
   void CreatePointsToTransformForGroundTruthProtocol();
   void TransformPointsGroundTruthProtocol();
   void AddTransformedPointsToDataStorage();
   double CalculateMeanFRE();
   double CalculateStandardDeviationOfFRE(double meanFRE);
   void CalculateGroundTruthProtocolTRE();
   // End methods Ground-Truth-Protocol
 
   void EliminateTooSmallLabeledObjects( ImageType::Pointer binaryImage);
   bool EliminateFiducialCandidatesByEuclideanDistances();
   void ClassifyFiducialCandidates();
   void GetCentroidsOfLabeledObjects();
   void NumerateFiducialMarks();
   void CalculateDistancesBetweenFiducials(std::vector<std::vector<double>> &distanceVectorsFiducials);
   bool FindFiducialNo1(std::vector<std::vector<double>> &distanceVectorsFiducials);
   bool FindFiducialNo2And3();
   bool FindFiducialNo4(std::vector<std::vector<double>> &distanceVectorsFiducials);
   bool FindFiducialNo5();
   bool FindFiducialNo6();
   bool FindFiducialNo7();
   bool FindFiducialNo8();
   void DefineDataStorageImageFilter();
   void CreateQtPartControl(QWidget *parent);
 
 protected slots:
   void OnFloatingImageComboBoxSelectionChanged(const mitk::DataNode* node);
   void OnRegisterMarkerToFloatingImageCS();
   void OnLocalizeFiducials();
   void OnVisualizeCTtoUSregistration();
   void OnFreeze();
   void OnActualizeSegmentationSurfacePointSetData();
   void OnGetCursorPosition();
 
   void OnCalculateCenter();
 
   //Methods for Ground-Truth-Fiducial-Localization-Protocol-Evaluation
   void OnAddCtImageClicked();
   void OnRemoveCtImageClicked();
   void OnEvaluateGroundTruthFiducialLocalizationProtocol();
 
 private:
   Ui::QmitkUSNavigationStepCtUsRegistration *ui;
 
   mitk::NodePredicateAnd::Pointer m_IsOfTypeImagePredicate;
   mitk::NodePredicateOr::Pointer m_IsASegmentationImagePredicate;
   mitk::NodePredicateAnd::Pointer m_IsAPatientImagePredicate;
   mitk::TNodePredicateDataType<mitk::PointSet>::Pointer m_IsAPointSetPredicate;
   mitk::NodePredicateDataType::Pointer m_IsASurfacePredicate;
 
   itk::SmartPointer<mitk::NavigationDataSource> m_NavigationDataSource;
   mitk::Image::Pointer m_FloatingImage;
   mitk::PointSet::Pointer m_MarkerModelCoordinateSystemPointSet;
   mitk::PointSet::Pointer m_MarkerFloatingImageCoordinateSystemPointSet;
 
   std::vector<mitk::Image::Pointer> m_ImagesGroundTruthProtocol;
   bool m_PerformingGroundTruthProtocolEvaluation;
   std::vector<double> m_GroundTruthProtocolFRE;
   std::map<int, double> m_GroundTruthProtocolTRE;
   std::map<int, mitk::Point3D> m_PointsToTransformGroundTruthProtocol;
   std::map<int, mitk::PointSet::Pointer> m_GroundTruthProtocolTransformedPoints;
 
   ThresholdImageFilterType::Pointer m_ThresholdFilter;
   BinaryThresholdImageFilterType::Pointer m_BinaryThresholdFilter;
   LaplacianRecursiveGaussianImageFilterType::Pointer m_LaplacianFilter1;
   LaplacianRecursiveGaussianImageFilterType::Pointer m_LaplacianFilter2;
   VotingBinaryIterativeHoleFillingImageFilterType::Pointer m_HoleFillingFilter;
   BinaryImageToShapeLabelMapFilterType::Pointer m_BinaryImageToShapeLabelMapFilter;
 
   itk::SmartPointer<mitk::FloatingImageToUltrasoundRegistrationFilter> m_FloatingImageToUltrasoundRegistrationFilter;
 
   std::vector<mitk::Vector3D> m_CentroidsOfFiducialCandidates;
   std::map<double, mitk::Vector3D> m_EigenVectorsFiducialCandidates;
   std::vector<double> m_EigenValuesFiducialCandidates;
   mitk::Vector3D m_MeanCentroidFiducialCandidates;
   std::map<int, mitk::Vector3D> m_FiducialMarkerCentroids;
 
   mitk::AffineTransform3D::Pointer m_TransformMarkerCSToFloatingImageCS;
 
   /*!
   \brief The 3D dimension of the CT image given in index size.
   */
   mitk::Vector3D m_ImageDimension;
   mitk::Vector3D m_ImageSpacing;
 
   bool m_FreezeCombinedModality;
   mitk::Point3D m_CentroidOfTargetInUSImage;
 
 };
 
 #endif // QMITKUSNAVIGATIONSTEPCTUSREGISTRATION_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp
index 93257aefb5..85fa3fb48c 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp
@@ -1,1017 +1,1017 @@
 /*===================================================================
 
 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 "QmitkUSNavigationStepMarkerIntervention.h"
 #include "ui_QmitkUSNavigationStepMarkerIntervention.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkContourModel.h"
 #include "mitkNeedleProjectionFilter.h"
 #include "mitkNodeDisplacementFilter.h"
 #include "mitkSurface.h"
 #include "mitkTextAnnotation2D.h"
 #include <mitkBaseGeometry.h>
 #include <mitkManualPlacementAnnotationRenderer.h>
 
 #include "../Filter/mitkUSNavigationTargetIntersectionFilter.h"
 #include "../Filter/mitkUSNavigationTargetOcclusionFilter.h"
 #include "../Filter/mitkUSNavigationTargetUpdateFilter.h"
 
 #include "../QmitkUSNavigationMarkerPlacement.h"
 #include "../Widgets/QmitkZoneProgressBar.h"
 #include "../mitkUSTargetPlacementQualityCalculator.h"
 
 #include "../Interactors/mitkUSPointMarkInteractor.h"
 #include "usModuleRegistry.h"
 
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 
 #include "mitkSurface.h"
 
 // VTK
 #include "vtkCellLocator.h"
 #include "vtkDataSet.h"
 #include "vtkDoubleArray.h"
 #include "vtkFloatArray.h"
 #include "vtkIdList.h"
 #include "vtkLinearTransform.h"
 #include "vtkLookupTable.h"
 #include "vtkMath.h"
 #include "vtkOBBTree.h"
 #include "vtkPointData.h"
 #include "vtkPointData.h"
 #include "vtkPolyData.h"
 #include "vtkSelectEnclosedPoints.h"
 #include "vtkSmartPointer.h"
 #include <vtkSphereSource.h>
 #include "vtkTransformPolyDataFilter.h"
 #include "vtkWarpScalar.h"
 
 
 QmitkUSNavigationStepMarkerIntervention::QmitkUSNavigationStepMarkerIntervention(QWidget *parent)
   : QmitkUSAbstractNavigationStep(parent),
     m_NumberOfTargets(0),
     m_PlannedTargetsNodes(),
     m_ReachedTargetsNodes(),
     m_TargetProgressBar(new QmitkZoneProgressBar(QString::fromStdString("Target: %1 mm"), 200, 0, this)),
     m_PlannedTargetProgressBar(nullptr),
     m_CurrentTargetIndex(0),
     m_CurrentTargetReached(false),
     m_ShowPlanningColors(false),
     m_PointMarkInteractor(mitk::USPointMarkInteractor::New()),
     m_TargetNode(nullptr),
     m_TargetColorLookupTableProperty(nullptr),
     m_TargetSurface(nullptr),
     m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()),
     m_NodeDisplacementFilter(mitk::NodeDisplacementFilter::New()),
     m_TargetUpdateFilter(mitk::USNavigationTargetUpdateFilter::New()),
     m_TargetOcclusionFilter(mitk::USNavigationTargetOcclusionFilter::New()),
     m_TargetIntersectionFilter(mitk::USNavigationTargetIntersectionFilter::New()),
     m_PlacementQualityCalculator(mitk::USTargetPlacementQualityCalculator::New()),
     m_TargetStructureWarnOverlay(mitk::TextAnnotation2D::New()),
     m_ReferenceSensorName(),
     m_NeedleSensorName(),
     m_ReferenceSensorIndex(1),
     m_NeedleSensorIndex(0),
     m_ListenerTargetCoordinatesChanged(this, &QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates),
     ui(new Ui::QmitkUSNavigationStepMarkerIntervention)
 {
   m_ActiveTargetColor[0] = 1;
   m_ActiveTargetColor[1] = 1;
   m_ActiveTargetColor[2] = 0;
   m_InactiveTargetColor[0] = 1;
   m_InactiveTargetColor[1] = 1;
   m_InactiveTargetColor[2] = 0.5;
   m_ReachedTargetColor[0] = 0.6;
   m_ReachedTargetColor[1] = 1;
   m_ReachedTargetColor[2] = 0.6;
 
   ui->setupUi(this);
 
   connect(ui->freezeImageButton, SIGNAL(SignalFreezed(bool)), this, SLOT(OnFreeze(bool)));
   connect(ui->backToLastTargetButton, SIGNAL(clicked()), this, SLOT(OnBackToLastTargetClicked()));
   connect(ui->targetReachedButton, SIGNAL(clicked()), this, SLOT(OnTargetLeft()));
   connect(this, SIGNAL(TargetReached(int)), this, SLOT(OnTargetReached()));
   connect(this, SIGNAL(TargetLeft(int)), this, SLOT(OnTargetLeft()));
   connect(ui->riskStructuresRangeWidget,
           SIGNAL(SignalZoneViolated(const mitk::DataNode *, mitk::Point3D)),
           this,
           SLOT(OnRiskZoneViolated(const mitk::DataNode *, mitk::Point3D)));
 
   m_PointMarkInteractor->CoordinatesChangedEvent.AddListener(m_ListenerTargetCoordinatesChanged);
 
   this->GenerateTargetColorLookupTable();
 
   m_TargetProgressBar->SetTextFormatInvalid("Target is not on Needle Path");
   ui->targetStructuresRangeLayout->addWidget(m_TargetProgressBar);
 
   m_TargetUpdateFilter->SetScalarArrayIdentifier("USNavigation::ReachedTargetScores");
 }
 
 QmitkUSNavigationStepMarkerIntervention::~QmitkUSNavigationStepMarkerIntervention()
 {
   mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(false);
   if (dataStorage.IsNotNull())
   {
     // remove the node for the needle path
     mitk::DataNode::Pointer node =
       this->GetNamedDerivedNode("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
     if (node.IsNotNull())
     {
       dataStorage->Remove(node);
     }
   }
 
   delete ui;
 
   m_PointMarkInteractor->CoordinatesChangedEvent.RemoveListener(m_ListenerTargetCoordinatesChanged);
 }
 
 bool QmitkUSNavigationStepMarkerIntervention::OnStartStep()
 {
   m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex);
 
   // create node for Needle Projection
   mitk::DataNode::Pointer node =
     this->GetNamedDerivedNodeAndCreate("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
   node->SetData(m_NeedleProjectionFilter->GetProjection());
   node->SetBoolProperty("show contour", true);
 
   // initialize warning overlay (and do not display it, yet)
   m_TargetStructureWarnOverlay->SetText("Warning: Needle is Inside the Target Structure.");
   m_TargetStructureWarnOverlay->SetVisibility(false);
 
   // set position and font size for the text overlay
   mitk::Point2D overlayPosition;
   overlayPosition.SetElement(0, 10.0f);
   overlayPosition.SetElement(1, 10.0f);
   m_TargetStructureWarnOverlay->SetPosition2D(overlayPosition);
   m_TargetStructureWarnOverlay->SetFontSize(18);
 
   // overlay should be red
   mitk::Color color;
   color[0] = 1;
   color[1] = 0;
   color[2] = 0;
   m_TargetStructureWarnOverlay->SetColor(color);
 
   mitk::ManualPlacementAnnotationRenderer::AddAnnotation(m_TargetStructureWarnOverlay.GetPointer(), "stdmulti.widget4");
 
   return true;
 }
 
 bool QmitkUSNavigationStepMarkerIntervention::OnStopStep()
 {
   mitk::DataStorage::Pointer dataStorage = this->GetDataStorage();
 
   // remove all reached nodes from the data storage
   for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_ReachedTargetsNodes.begin();
        it != m_ReachedTargetsNodes.end();
        ++it)
   {
     dataStorage->Remove(*it);
   }
   m_ReachedTargetsNodes.clear();
   m_CurrentTargetIndex = 0;
 
   // reset button states
   ui->freezeImageButton->setEnabled(false);
   ui->backToLastTargetButton->setEnabled(false);
   ui->targetReachedButton->setEnabled(true);
 
   // make sure that it is unfreezed after stopping the step
   ui->freezeImageButton->Unfreeze();
 
   // remove base node for reached targets from the data storage
   mitk::DataNode::Pointer reachedTargetsNode = this->GetNamedDerivedNode(
     QmitkUSAbstractNavigationStep::DATANAME_BASENODE, QmitkUSNavigationMarkerPlacement::DATANAME_REACHED_TARGETS);
   if (reachedTargetsNode.IsNotNull())
   {
     dataStorage->Remove(reachedTargetsNode);
   }
 
   return true;
 }
 
 bool QmitkUSNavigationStepMarkerIntervention::OnFinishStep()
 {
   return true;
 }
 
 bool QmitkUSNavigationStepMarkerIntervention::OnActivateStep()
 {
   this->ClearZones(); // clear risk zones before adding new ones
 
   // get target node from data storage and make sure that it contains data
   m_TargetNode = this->GetNamedDerivedNode(QmitkUSNavigationMarkerPlacement::DATANAME_TARGETSURFACE,
     QmitkUSNavigationMarkerPlacement::DATANAME_TUMOUR);
-  if (m_TargetNode.IsNull() || m_TargetNode->GetData() == 0)
+  if (m_TargetNode.IsNull() || m_TargetNode->GetData() == nullptr)
   {
     mitkThrow() << "Target node (" << QmitkUSNavigationMarkerPlacement::DATANAME_TARGETSURFACE << ") must not be null.";
   }
 
   // get target data and make sure that it is a surface
   m_TargetSurface = dynamic_cast<mitk::Surface *>(m_TargetNode->GetData());
   if (m_TargetSurface.IsNull())
   {
     mitkThrow() << "Target node (" << QmitkUSNavigationMarkerPlacement::DATANAME_TARGETSURFACE
                 << ") data must be of type mitk::Surface";
   }
 
   // delete progress bars for reinitializing them again afterwards
   if (m_PlannedTargetProgressBar)
   {
     ui->targetStructuresRangeLayout->removeWidget(m_PlannedTargetProgressBar);
     delete m_PlannedTargetProgressBar;
-    m_PlannedTargetProgressBar = 0;
+    m_PlannedTargetProgressBar = nullptr;
   }
 
   m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex);
 
   this->UpdateTargetProgressDisplay();
 
   mitk::DataNode::Pointer tumourNode = this->GetNamedDerivedNode(QmitkUSNavigationMarkerPlacement::DATANAME_TUMOUR,
                                                                  QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
   if (tumourNode.IsNotNull())
   {
     // do not show tumour node during intervention (target surface is shown)
     tumourNode->SetBoolProperty("visible", false);
 
     // add tumour as a risk structure
     ui->riskStructuresRangeWidget->AddZone(tumourNode);
   }
 
   // set target structure for target update filter
   m_TargetUpdateFilter->SetTargetStructure(m_TargetNode);
   m_TargetOcclusionFilter->SetTargetStructure(m_TargetNode);
 
   // set lookup table of tumour node
   m_TargetNode->SetProperty("LookupTable", m_TargetColorLookupTableProperty);
 
   //
   mitk::DataNode::Pointer targetsBaseNode = this->GetNamedDerivedNode(QmitkUSNavigationMarkerPlacement::DATANAME_TARGETS,
                                                                       QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
   mitk::DataStorage::SetOfObjects::ConstPointer plannedTargetNodes;
   if (targetsBaseNode.IsNotNull())
   {
     plannedTargetNodes = this->GetDataStorage()->GetDerivations(targetsBaseNode);
   }
   if (plannedTargetNodes.IsNotNull() && plannedTargetNodes->Size() > 0)
   {
     for (mitk::DataStorage::SetOfObjects::ConstIterator it = plannedTargetNodes->Begin();
          it != plannedTargetNodes->End();
          ++it)
     {
       m_PlannedTargetsNodes.push_back(it->Value());
     }
 
     m_PlannedTargetProgressBar = new QmitkZoneProgressBar(QString::fromStdString("Planned Target"), 200, 0);
     ui->targetStructuresRangeLayout->addWidget(m_PlannedTargetProgressBar);
   }
 
   // add progress bars for risk zone nodes
   mitk::DataNode::Pointer zonesBaseNode = this->GetNamedDerivedNode(QmitkUSNavigationMarkerPlacement::DATANAME_ZONES,
                                                                     QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
   // only add progress bars if the base node for zones was created
   if (zonesBaseNode.IsNotNull())
   {
     mitk::DataStorage::SetOfObjects::ConstPointer zoneNodes = this->GetDataStorage()->GetDerivations(zonesBaseNode);
 
     for (mitk::DataStorage::SetOfObjects::ConstIterator it = zoneNodes->Begin(); it != zoneNodes->End(); ++it)
     {
       ui->riskStructuresRangeWidget->AddZone(it->Value());
     }
 
     m_TargetOcclusionFilter->SelectStartPositionInput(m_NeedleSensorIndex);
     m_TargetOcclusionFilter->SetObstacleStructures(zoneNodes);
   }
 
   return true;
 }
 
 bool QmitkUSNavigationStepMarkerIntervention::OnDeactivateStep()
 {
   ui->freezeImageButton->Unfreeze();
 
   return true;
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnUpdate()
 {
   // get navigation data source and make sure that it is not null
   mitk::NavigationDataSource::Pointer navigationDataSource = this->GetCombinedModality()->GetNavigationDataSource();
   if (navigationDataSource.IsNull())
   {
     MITK_ERROR("QmitkUSAbstractNavigationStep")
     ("QmitkUSNavigationStepMarkerIntervention") << "Navigation Data Source of Combined Modality must not be null.";
     mitkThrow() << "Navigation Data Source of Combined Modality must not be null.";
   }
 
   ui->riskStructuresRangeWidget->UpdateDistancesToNeedlePosition(navigationDataSource->GetOutput(m_NeedleSensorIndex));
   this->UpdateBodyMarkerStatus(navigationDataSource->GetOutput(m_ReferenceSensorIndex));
 
   this->UpdateTargetColors();
   this->UpdateTargetScore();
 
   this->UpdateTargetViolationStatus();
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode)
 {
   if (settingsNode.IsNull())
   {
     return;
   }
 
   int numberOfTargets;
   if (settingsNode->GetIntProperty("settings.number-of-targets", numberOfTargets))
   {
     m_NumberOfTargets = numberOfTargets;
     m_TargetUpdateFilter->SetNumberOfTargets(numberOfTargets);
 
     m_PlacementQualityCalculator->SetOptimalAngle(m_TargetUpdateFilter->GetOptimalAngle());
   }
 
   std::string referenceSensorName;
   if (settingsNode->GetStringProperty("settings.reference-name-selected", referenceSensorName))
   {
     m_ReferenceSensorName = referenceSensorName;
   }
 
   std::string needleSensorName;
   if (settingsNode->GetStringProperty("settings.needle-name-selected", needleSensorName))
   {
     m_NeedleSensorName = needleSensorName;
   }
 
   this->UpdateSensorsNames();
 }
 
 QString QmitkUSNavigationStepMarkerIntervention::GetTitle()
 {
   return "Computer-assisted Intervention";
 }
 
 bool QmitkUSNavigationStepMarkerIntervention::GetIsRestartable()
 {
   return true;
 }
 
 QmitkUSAbstractNavigationStep::FilterVector QmitkUSNavigationStepMarkerIntervention::GetFilter()
 {
   FilterVector filter;
   filter.push_back(m_NeedleProjectionFilter.GetPointer());
   filter.push_back(m_NodeDisplacementFilter.GetPointer());
   filter.push_back(m_TargetOcclusionFilter.GetPointer());
   return filter;
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnSetCombinedModality()
 {
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetCombinedModality(false);
   if (combinedModality.IsNotNull())
   {
     mitk::AffineTransform3D::Pointer calibration = combinedModality->GetCalibration();
     if (calibration.IsNotNull())
     {
       m_NeedleProjectionFilter->SetTargetPlane(calibration);
     }
   }
 
   ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex);
 
   this->UpdateSensorsNames();
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnTargetReached()
 {
   m_CurrentTargetReached = true;
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnTargetLeft()
 {
   m_CurrentTargetReached = false;
 
   m_CurrentTargetIndex++;
 
   if (m_CurrentTargetIndex >= 0 && static_cast<unsigned int>(m_CurrentTargetIndex) >= m_NumberOfTargets)
   {
     ui->targetReachedButton->setDisabled(true);
   }
 
   ui->backToLastTargetButton->setEnabled(true);
   ui->freezeImageButton->setEnabled(true);
 
   this->UpdateTargetProgressDisplay();
 
   if (m_ReachedTargetsNodes.size() < m_CurrentTargetIndex)
   {
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetName(
       (QString("Target ") + QString("%1").arg(m_CurrentTargetIndex, 2, 10, QLatin1Char('0'))).toStdString());
     this->GetDataStorage()->Add(
       node,
       this->GetNamedDerivedNodeAndCreate(QmitkUSNavigationMarkerPlacement::DATANAME_REACHED_TARGETS,
                                          QmitkUSAbstractNavigationStep::DATANAME_BASENODE));
     m_ReachedTargetsNodes.push_back(node);
   }
 
   mitk::DataNode::Pointer node = m_ReachedTargetsNodes.at(m_CurrentTargetIndex - 1);
   mitk::Surface::Pointer zone = mitk::Surface::New();
 
   // create a vtk sphere with given radius
   vtkSmartPointer<vtkSphereSource> vtkSphere = vtkSmartPointer<vtkSphereSource>::New();
   vtkSphere->SetRadius(5);
   vtkSphere->SetCenter(0, 0, 0);
   vtkSphere->Update();
   zone->SetVtkPolyData(vtkSphere->GetOutput());
 
   // set vtk sphere and origin to data node
   node->SetData(zone);
   node->GetData()->GetGeometry()->SetOrigin(
     this->GetCombinedModality()->GetNavigationDataSource()->GetOutput(m_NeedleSensorIndex)->GetPosition());
   node->SetColor(0.2, 0.9, 0.2);
   this->UpdateTargetCoordinates(node);
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnBackToLastTargetClicked()
 {
   if (m_CurrentTargetIndex < 1)
   {
     MITK_WARN << "Cannot go back to last target as there is no last target.";
     return;
   }
 
   m_CurrentTargetIndex--;
 
   if (m_ReachedTargetsNodes.size() > m_CurrentTargetIndex)
   {
     this->GetDataStorage()->Remove(m_ReachedTargetsNodes.last());
     MITK_INFO("QmitkUSAbstractNavigationStep")
     ("QmitkUSNavigationStepMarkerIntervention") << "Removed Target " << m_ReachedTargetsNodes.size();
     m_ReachedTargetsNodes.pop_back();
   }
 
   if (m_CurrentTargetIndex == 0)
   {
     ui->backToLastTargetButton->setDisabled(true);
   }
   if (m_CurrentTargetIndex >= 0 && static_cast<unsigned int>(m_CurrentTargetIndex) < m_NumberOfTargets)
   {
     ui->targetReachedButton->setEnabled(true);
   }
 
   ui->freezeImageButton->setEnabled(false);
   ui->freezeImageButton->Unfreeze();
 
   this->UpdateTargetProgressDisplay();
 
   m_TargetUpdateFilter->RemovePositionOfTarget(m_CurrentTargetIndex);
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnFreeze(bool freezed)
 {
   if (freezed)
   {
     this->GetCombinedModality()->SetIsFreezed(true);
     // load state machine and event config for data interactor
     m_PointMarkInteractor->LoadStateMachine("USPointMarkInteractions.xml", us::ModuleRegistry::GetModule("MitkUS"));
     m_PointMarkInteractor->SetEventConfig("globalConfig.xml");
 
     if (m_CurrentTargetIndex < 1)
     {
       mitkThrow() << "Current target index has to be greater zero when freeze button is clicked.";
     }
 
     if (m_ReachedTargetsNodes.size() < m_CurrentTargetIndex)
     {
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetName(
         (QString("Target ") + QString("%1").arg(m_CurrentTargetIndex, 2, 10, QLatin1Char('0'))).toStdString());
       this->GetDataStorage()->Add(
         node,
         this->GetNamedDerivedNodeAndCreate(QmitkUSNavigationMarkerPlacement::DATANAME_REACHED_TARGETS,
                                            QmitkUSAbstractNavigationStep::DATANAME_BASENODE));
       m_ReachedTargetsNodes.push_back(node);
     }
 
     m_PointMarkInteractor->SetDataNode(m_ReachedTargetsNodes.last());
   }
   else
   {
-    m_PointMarkInteractor->SetDataNode(0);
+    m_PointMarkInteractor->SetDataNode(nullptr);
     this->GetCombinedModality()->SetIsFreezed(false);
   }
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnShowPlanningView(bool show)
 {
   m_ShowPlanningColors = show;
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnRiskZoneViolated(const mitk::DataNode *node, mitk::Point3D position)
 {
   MITK_INFO << "Risk zone (" << node->GetName() << ") violated at position " << position << ".";
 }
 
 void QmitkUSNavigationStepMarkerIntervention::ClearZones()
 {
   ui->riskStructuresRangeWidget->ClearZones();
 
   // remove all reached target nodes from the data storage and clear the list
   mitk::DataStorage::Pointer dataStorage = this->GetDataStorage();
   for (QVector<mitk::DataNode::Pointer>::iterator it = m_ReachedTargetsNodes.begin(); it != m_ReachedTargetsNodes.end();
        ++it)
   {
     if (it->IsNotNull())
     {
       dataStorage->Remove(*it);
     }
   }
   m_ReachedTargetsNodes.clear();
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates(mitk::DataNode *dataNode)
 {
   m_NodeDisplacementFilter->ResetNodes();
   for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_ReachedTargetsNodes.begin();
        it != m_ReachedTargetsNodes.end();
        ++it)
   {
-    if (it->IsNotNull() && (*it)->GetData() != 0)
+    if (it->IsNotNull() && (*it)->GetData() != nullptr)
     {
       m_NodeDisplacementFilter->AddNode(*it);
     }
   }
 
   mitk::BaseData *baseData = dataNode->GetData();
   if (!baseData)
   {
     mitkThrow() << "Data of the data node must not be null.";
   }
 
   mitk::BaseGeometry::Pointer geometry = baseData->GetGeometry();
   if (geometry.IsNull())
   {
     mitkThrow() << "Geometry of the data node must not be null.";
   }
 
   m_TargetUpdateFilter->SetControlNode(m_CurrentTargetIndex - 1, dataNode);
 
   if (m_PlannedTargetsNodes.size() > m_CurrentTargetIndex - 1)
   {
     m_PlannedTargetsNodes.at(m_CurrentTargetIndex - 1)->SetVisibility(false);
   }
 
   MITK_INFO("QmitkUSAbstractNavigationStep")
   ("QmitkUSNavigationStepMarkerIntervention") << "Target " << m_CurrentTargetIndex << " reached at position "
                                               << geometry->GetOrigin();
 
   this->CalculateTargetPlacementQuality();
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker)
 {
   if (bodyMarker.IsNull())
   {
     MITK_ERROR("QmitkUSAbstractNavigationStep")
     ("QmitkUSNavigationStepMarkerIntervention")
       << "Current Navigation Data for body marker of Combined Modality must not be null.";
     mitkThrow() << "Current Navigation Data for body marker of Combined Modality must not be null.";
   }
 
   bool valid = bodyMarker->IsDataValid();
 
   // update body marker status label
   if (valid)
   {
     ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
       "background-color: #8bff8b; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
     ui->bodyMarkerTrackingStatusLabel->setText("Body marker is inside the tracking volume.");
   }
   else
   {
     ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
       "background-color: #ff7878; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
     ui->bodyMarkerTrackingStatusLabel->setText("Body marker is not inside the tracking volume.");
   }
 
   ui->targetStructuresRangeGroupBox->setEnabled(valid);
   ui->riskStructuresRangeGroupBox->setEnabled(valid);
 }
 
 void QmitkUSNavigationStepMarkerIntervention::GenerateTargetColorLookupTable()
 {
   vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
   lookupTable->SetHueRange(0.0, 0.33);
   lookupTable->SetSaturationRange(1.0, 1.0);
   lookupTable->SetValueRange(1.0, 1.0);
   lookupTable->SetTableRange(0.0, 1.0);
   lookupTable->Build();
 
   mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
   lut->SetVtkLookupTable(lookupTable);
 
   m_TargetColorLookupTableProperty = mitk::LookupTableProperty::New(lut);
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdateTargetColors()
 {
   if (m_TargetNode.IsNull())
   {
     return;
   }
 
   m_TargetNode->SetColor(1, 1, 1);
 
   mitk::BaseData *targetNodeData = m_TargetNode->GetData();
-  if (targetNodeData == 0)
+  if (targetNodeData == nullptr)
   {
     return;
   }
 
   mitk::Surface::Pointer targetNodeSurface = dynamic_cast<mitk::Surface *>(targetNodeData);
   vtkSmartPointer<vtkPolyData> targetNodeSurfaceVtk = targetNodeSurface->GetVtkPolyData();
 
   vtkPointData *targetPointData = targetNodeSurface->GetVtkPolyData()->GetPointData();
 
   vtkFloatArray *scalars = dynamic_cast<vtkFloatArray *>(targetPointData->GetScalars("USNavigation::Occlusion"));
   vtkFloatArray *targetScoreScalars;
 
   if (m_ShowPlanningColors)
   {
     targetScoreScalars = dynamic_cast<vtkFloatArray *>(targetPointData->GetScalars("USNavigation::PlanningScalars"));
   }
   else
   {
     targetScoreScalars =
       dynamic_cast<vtkFloatArray *>(targetPointData->GetScalars("USNavigation::ReachedTargetScores"));
   }
 
   if (!scalars || !targetScoreScalars)
   {
     return;
   }
 
   unsigned int numberOfTupels = scalars->GetNumberOfTuples();
 
   vtkSmartPointer<vtkFloatArray> colors = vtkSmartPointer<vtkFloatArray>::New();
   colors->SetNumberOfComponents(1);
   colors->SetNumberOfTuples(numberOfTupels);
   colors->SetName("Colors");
 
   double color, intersection, markerScore;
 
   for (unsigned int n = 0; n < numberOfTupels; n++)
   {
     scalars->GetTuple(n, &intersection);
     targetScoreScalars->GetTuple(n, &markerScore);
 
     if (intersection > 0)
     {
       color = 0;
     }
     else
     {
       color = markerScore;
     }
 
     colors->SetTuple(n, &color);
   }
 
   if (numberOfTupels > 0)
   {
     targetNodeSurfaceVtk->GetPointData()->SetScalars(colors);
     targetNodeSurfaceVtk->GetPointData()->Update();
   }
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdateTargetScore()
 {
   if (m_NeedleProjectionFilter->GetProjection()->GetSize() != 2)
   {
     return;
   }
 
   vtkSmartPointer<vtkPolyData> targetSurfaceVtk = m_TargetSurface->GetVtkPolyData();
 
   m_TargetIntersectionFilter->SetTargetSurface(m_TargetSurface);
   m_TargetIntersectionFilter->SetLine(m_NeedleProjectionFilter->GetProjection());
 
   m_TargetIntersectionFilter->CalculateIntersection();
 
   if (m_TargetIntersectionFilter->GetIsIntersecting())
   {
     vtkFloatArray *scalars =
       dynamic_cast<vtkFloatArray *>(targetSurfaceVtk->GetPointData()->GetScalars("USNavigation::ReachedTargetScores"));
     double score;
     scalars->GetTuple(m_TargetIntersectionFilter->GetIntersectionNearestSurfacePointId(), &score);
 
     double color[3];
     m_TargetColorLookupTableProperty->GetLookupTable()->GetVtkLookupTable()->GetColor(score, color);
 
     float colorF[3];
     colorF[0] = color[0];
     colorF[1] = color[1];
     colorF[2] = color[2];
     m_TargetProgressBar->SetColor(colorF);
     m_TargetProgressBar->SetBorderColor(colorF);
     m_TargetProgressBar->setValue(m_TargetIntersectionFilter->GetDistanceToIntersection());
 
     if (m_PlannedTargetProgressBar)
     {
       vtkFloatArray *scalars =
         dynamic_cast<vtkFloatArray *>(targetSurfaceVtk->GetPointData()->GetScalars("USNavigation::PlanningScalars"));
       if (scalars)
       {
         double score;
         scalars->GetTuple(m_TargetIntersectionFilter->GetIntersectionNearestSurfacePointId(), &score);
 
         double color[3];
         m_TargetColorLookupTableProperty->GetLookupTable()->GetVtkLookupTable()->GetColor(score, color);
 
         float colorF[3];
         colorF[0] = color[0];
         colorF[1] = color[1];
         colorF[2] = color[2];
         m_PlannedTargetProgressBar->SetColor(colorF);
         m_PlannedTargetProgressBar->SetBorderColor(colorF);
         m_PlannedTargetProgressBar->SetTextFormatValid("Planned Target: %1 mm");
 
         mitk::Point3D intersectionPoint = m_TargetIntersectionFilter->GetIntersectionPoint();
 
         mitk::ScalarType minDistance = -1;
         for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_PlannedTargetsNodes.begin();
              it != m_PlannedTargetsNodes.end();
              ++it)
         {
           mitk::ScalarType distance =
             intersectionPoint.EuclideanDistanceTo((*it)->GetData()->GetGeometry()->GetOrigin());
           if (minDistance < 0 || distance < minDistance)
           {
             minDistance = distance;
           }
         }
 
         m_PlannedTargetProgressBar->setValue(minDistance);
       }
     }
   }
   else
   {
     m_TargetProgressBar->setValueInvalid();
   }
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdateTargetProgressDisplay()
 {
   QString description;
   if (m_CurrentTargetIndex >= static_cast<int>(m_NumberOfTargets))
   {
     description = "All Targets Reached";
     if (m_TargetProgressBar)
     {
       m_TargetProgressBar->hide();
     }
   }
   else
   {
     description = QString("Distance to Target ") + QString::number(m_CurrentTargetIndex + 1) + QString(" of ") +
                   QString::number(m_NumberOfTargets);
     if (m_TargetProgressBar)
     {
       m_TargetProgressBar->show();
     }
   }
 
   ui->targetStructuresRangeGroupBox->setTitle(description);
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdatePlannedTargetProgressDisplay()
 {
   // make sure that the needle projection consists of two points
   if (m_NeedleProjectionFilter->GetProjection()->GetSize() != 2)
   {
     return;
   }
 
   vtkSmartPointer<vtkPolyData> targetSurfaceVtk = m_TargetSurface->GetVtkPolyData();
 
   m_TargetIntersectionFilter->SetTargetSurface(m_TargetSurface);
   m_TargetIntersectionFilter->SetLine(m_NeedleProjectionFilter->GetProjection());
 
   m_TargetIntersectionFilter->CalculateIntersection();
 
   // update target progress bar according to the color of the intersection
   // point on the target surface and the distance to the intersection
   if (m_TargetIntersectionFilter->GetIsIntersecting())
   {
     vtkFloatArray *scalars = dynamic_cast<vtkFloatArray *>(targetSurfaceVtk->GetPointData()->GetScalars("Colors"));
     double score;
     scalars->GetTuple(m_TargetIntersectionFilter->GetIntersectionNearestSurfacePointId(), &score);
 
     double color[3];
     m_TargetColorLookupTableProperty->GetLookupTable()->GetVtkLookupTable()->GetColor(score, color);
 
     float colorF[3];
     colorF[0] = color[0];
     colorF[1] = color[1];
     colorF[2] = color[2];
     m_TargetProgressBar->SetColor(colorF);
     m_TargetProgressBar->SetBorderColor(colorF);
     m_TargetProgressBar->setValue(m_TargetIntersectionFilter->GetDistanceToIntersection());
   }
   else
   {
     float red[3] = {0.6f, 0.0f, 0.0f};
     m_TargetProgressBar->SetBorderColor(red);
     m_TargetProgressBar->setValueInvalid();
   }
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdateTargetViolationStatus()
 {
   // transform vtk polydata according to mitk geometry
   vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
   transformFilter->SetInputData(0, m_TargetSurface->GetVtkPolyData());
   transformFilter->SetTransform(m_TargetSurface->GetGeometry()->GetVtkTransform());
   transformFilter->Update();
 
   vtkSmartPointer<vtkSelectEnclosedPoints> enclosedPoints = vtkSmartPointer<vtkSelectEnclosedPoints>::New();
   enclosedPoints->Initialize(transformFilter->GetOutput());
 
   mitk::Point3D needleTip = m_NeedleProjectionFilter->GetProjection()->GetPoint(0);
 
   // show warning if the needle tip is inside the target surface
   if (enclosedPoints->IsInsideSurface(needleTip[0], needleTip[1], needleTip[2]))
   {
-    if (!m_TargetStructureWarnOverlay->IsVisible(NULL))
+    if (!m_TargetStructureWarnOverlay->IsVisible(nullptr))
     {
       m_TargetStructureWarnOverlay->SetVisibility(true);
 
       mitk::DataNode::Pointer targetViolationResult = mitk::DataNode::New();
       targetViolationResult->SetName("TargetViolation");
       targetViolationResult->SetProperty("USNavigation::TargetViolationPoint", mitk::Point3dProperty::New(needleTip));
 
       emit SignalIntermediateResult(targetViolationResult);
     }
 
     MITK_INFO("QmitkUSAbstractNavigationStep")
     ("QmitkUSNavigationStepMarkerIntervention") << "Target surface violated at " << needleTip << ".";
   }
   else
   {
     m_TargetStructureWarnOverlay->SetVisibility(false);
   }
 }
 
 void QmitkUSNavigationStepMarkerIntervention::CalculateTargetPlacementQuality()
 {
   // clear quality display if there aren't all targets reached
   if (m_ReachedTargetsNodes.size() != static_cast<int>(m_NumberOfTargets))
   {
     ui->placementQualityGroupBox->setEnabled(false);
     ui->angleDifferenceValue->setText("");
     ui->centersOfMassValue->setText("");
     return;
   }
 
   ui->placementQualityGroupBox->setEnabled(true);
 
   mitk::Surface::Pointer targetSurface = dynamic_cast<mitk::Surface *>(m_TargetNode->GetData());
   if (targetSurface.IsNull())
   {
     mitkThrow() << "Target surface must not be null.";
   }
 
   m_PlacementQualityCalculator->SetTargetSurface(targetSurface);
   mitk::PointSet::Pointer targetPointSet = mitk::PointSet::New();
 
   // copy the origins of all reached target nodes into a point set
   // for the quality calculator
   mitk::PointSet::PointIdentifier n = 0;
   for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_ReachedTargetsNodes.begin();
        it != m_ReachedTargetsNodes.end();
        ++it)
   {
     targetPointSet->InsertPoint(n++, (*it)->GetData()->GetGeometry()->GetOrigin());
   }
   m_PlacementQualityCalculator->SetTargetPoints(targetPointSet);
 
   m_PlacementQualityCalculator->Update();
 
   double centersOfMassDistance = m_PlacementQualityCalculator->GetCentersOfMassDistance();
   ui->centersOfMassValue->setText(QString::number(centersOfMassDistance, 103, 2) + " mm");
 
   double meanAnglesDifference = m_PlacementQualityCalculator->GetMeanAngleDifference();
   ui->angleDifferenceValue->setText(QString::number(meanAnglesDifference, 103, 2) + QString::fromLatin1(" °"));
 
   // create an intermediate result of the placement quality
   mitk::DataNode::Pointer placementQualityResult = mitk::DataNode::New();
   placementQualityResult->SetName("PlacementQuality");
   placementQualityResult->SetFloatProperty("USNavigation::CentersOfMassDistance", centersOfMassDistance);
   placementQualityResult->SetFloatProperty("USNavigation::MeanAngleDifference", meanAnglesDifference);
   placementQualityResult->SetProperty(
     "USNavigation::AngleDifferences",
     mitk::GenericProperty<mitk::VnlVector>::New(m_PlacementQualityCalculator->GetAngleDifferences()));
 
   if (m_PlannedTargetsNodes.size() == static_cast<int>(m_NumberOfTargets))
   {
     mitk::VnlVector reachedPlannedDifferences;
     double reachedPlannedDifferencesSum = 0;
     double reachedPlannedDifferencesMax = 0;
     reachedPlannedDifferences.set_size(m_NumberOfTargets);
 
     // get sum and maximum of the planning / reality differences
     for (unsigned int n = 0; n < m_NumberOfTargets; ++n)
     {
       mitk::ScalarType distance =
         m_PlannedTargetsNodes.at(n)->GetData()->GetGeometry()->GetOrigin().EuclideanDistanceTo(
           m_ReachedTargetsNodes.at(n)->GetData()->GetGeometry()->GetOrigin());
 
       reachedPlannedDifferences.put(n, distance);
       reachedPlannedDifferencesSum += distance;
 
       if (distance > reachedPlannedDifferencesMax)
       {
         reachedPlannedDifferencesMax = distance;
       }
     }
 
     // add distances between planning and reality to the quality intermediate result
     placementQualityResult->SetProperty("USNavigation::PlanningRealityDistances",
                                         mitk::GenericProperty<mitk::VnlVector>::New(reachedPlannedDifferences));
     placementQualityResult->SetProperty(
       "USNavigation::MeanPlanningRealityDistance",
       mitk::DoubleProperty::New(reachedPlannedDifferencesSum / static_cast<double>(m_NumberOfTargets)));
     placementQualityResult->SetProperty("USNavigation::MaximumPlanningRealityDistance",
                                         mitk::DoubleProperty::New(reachedPlannedDifferencesMax));
   }
 
   emit SignalIntermediateResult(placementQualityResult);
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdateSensorsNames()
 {
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetCombinedModality(false);
   if (combinedModality.IsNull())
   {
     return;
   }
 
   mitk::NavigationDataSource::Pointer navigationDataSource = combinedModality->GetNavigationDataSource();
   if (navigationDataSource.IsNull())
   {
     return;
   }
 
   if (!m_NeedleSensorName.empty())
   {
     try
     {
       m_NeedleSensorIndex = navigationDataSource->GetOutputIndex(m_NeedleSensorName);
     }
     catch (const std::exception &e)
     {
       MITK_WARN("QmitkUSAbstractNavigationStep")
       ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for needle sensor name: " << e.what();
     }
   }
   if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active)
   {
     m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex);
   }
 
   if (!m_ReferenceSensorName.empty())
   {
     try
     {
       m_ReferenceSensorIndex = navigationDataSource->GetOutputIndex(m_ReferenceSensorName);
     }
     catch (const std::exception &e)
     {
       MITK_WARN("QmitkUSAbstractNavigationStep")
       ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for reference sensor name: " << e.what();
     }
   }
   if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active)
   {
     m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex);
   }
 
   ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex);
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h
index 56ce3399a5..c606a7862c 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h
@@ -1,167 +1,167 @@
 /*===================================================================
 
 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 QMITKUSNAVIGATIONSTEPMARKERINTERVENTION_H
 #define QMITKUSNAVIGATIONSTEPMARKERINTERVENTION_H
 
 #include "QmitkUSAbstractNavigationStep.h"
 
 namespace mitk
 {
   class DataNode;
   class NeedleProjectionFilter;
   class NodeDisplacementFilter;
   class USNavigationGrabCutSegmentationUpdateFilter;
   class USNavigationTargetUpdateFilter;
   class USNavigationTargetOcclusionFilter;
   class USNavigationTargetIntersectionFilter;
   class USPointMarkInteractor;
   class LookupTableProperty;
   class Surface;
   class TextAnnotation2D;
   class USTargetPlacementQualityCalculator;
 }
 
 namespace Ui
 {
   class QmitkUSNavigationStepMarkerIntervention;
 }
 
 class QmitkZoneProgressBar;
 
 /**
  * \brief Navigation step for the actual marker placement.
  */
 class QmitkUSNavigationStepMarkerIntervention : public QmitkUSAbstractNavigationStep
 {
   Q_OBJECT
 
 signals:
   void TargetReached(int);
   void TargetLeft(int);
 
 protected slots:
   void OnTargetReached();
   void OnTargetLeft();
   void OnBackToLastTargetClicked();
   void OnFreeze(bool);
   void OnShowPlanningView(bool);
   void OnRiskZoneViolated(const mitk::DataNode *, mitk::Point3D);
 
 public:
-  explicit QmitkUSNavigationStepMarkerIntervention(QWidget *parent = 0);
+  explicit QmitkUSNavigationStepMarkerIntervention(QWidget *parent = nullptr);
   ~QmitkUSNavigationStepMarkerIntervention() override;
 
   bool OnStartStep() override;
   bool OnStopStep() override;
   bool OnFinishStep() override;
 
   bool OnActivateStep() override;
   bool OnDeactivateStep() override;
   void OnUpdate() override;
 
   void OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode) override;
 
   QString GetTitle() override;
   bool GetIsRestartable() override;
 
   FilterVector GetFilter() override;
 
 protected:
   void OnSetCombinedModality() override;
 
   void ClearZones();
   void UpdateTargetCoordinates(mitk::DataNode *);
   void UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker);
   void GenerateTargetColorLookupTable();
   void UpdateTargetColors();
 
   /**
    * \brief
    */
   void UpdateTargetScore();
 
   /**
    * \brief Updates display showing the number of the currently active target.
    */
   void UpdateTargetProgressDisplay();
 
   /**
    * \brief Updates color and distance of the progress bar for the planned target.
    * The intersection between needle path and target surface is calculated and
    * the color is got from the intersection point.
    */
   void UpdatePlannedTargetProgressDisplay();
 
   /**
    * \brief Tests for target violation and updates the display accordingly.
    * This method tests if the needle tip is inside the target surface.
    */
   void UpdateTargetViolationStatus();
 
   /**
    * \brief Calculates and display quality metrics if all three markers are placed.
    */
   void CalculateTargetPlacementQuality();
 
   void UpdateSensorsNames();
 
   unsigned int m_NumberOfTargets;
 
   QVector<itk::SmartPointer<mitk::DataNode>> m_PlannedTargetsNodes;
   QVector<itk::SmartPointer<mitk::DataNode>> m_ReachedTargetsNodes;
 
   QmitkZoneProgressBar *m_TargetProgressBar;
   QmitkZoneProgressBar *m_PlannedTargetProgressBar;
 
   int m_CurrentTargetIndex;
   bool m_CurrentTargetReached;
 
   mitk::ScalarType m_ActiveTargetColor[3];
   mitk::ScalarType m_InactiveTargetColor[3];
   mitk::ScalarType m_ReachedTargetColor[3];
 
   bool m_ShowPlanningColors;
   itk::SmartPointer<mitk::USPointMarkInteractor> m_PointMarkInteractor;
 
   itk::SmartPointer<mitk::DataNode> m_TargetNode;
   itk::SmartPointer<mitk::LookupTableProperty> m_TargetColorLookupTableProperty;
 
   itk::SmartPointer<mitk::Surface> m_TargetSurface;
 
   itk::SmartPointer<mitk::NeedleProjectionFilter> m_NeedleProjectionFilter;
   itk::SmartPointer<mitk::NodeDisplacementFilter> m_NodeDisplacementFilter;
 
   itk::SmartPointer<mitk::USNavigationTargetUpdateFilter> m_TargetUpdateFilter;
   itk::SmartPointer<mitk::USNavigationTargetOcclusionFilter> m_TargetOcclusionFilter;
   itk::SmartPointer<mitk::USNavigationTargetIntersectionFilter> m_TargetIntersectionFilter;
   itk::SmartPointer<mitk::USTargetPlacementQualityCalculator> m_PlacementQualityCalculator;
 
   itk::SmartPointer<mitk::TextAnnotation2D> m_TargetStructureWarnOverlay;
 
   std::string m_ReferenceSensorName;
   std::string m_NeedleSensorName;
 
   unsigned int m_ReferenceSensorIndex;
   unsigned int m_NeedleSensorIndex;
 
 private:
   mitk::MessageDelegate1<QmitkUSNavigationStepMarkerIntervention, mitk::DataNode *> m_ListenerTargetCoordinatesChanged;
 
   Ui::QmitkUSNavigationStepMarkerIntervention *ui;
 };
 
 #endif // QMITKUSNAVIGATIONSTEPMARKERINTERVENTION_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.cpp
index 16b74da2d9..45538ad89e 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.cpp
@@ -1,816 +1,816 @@
 /*===================================================================
 
 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 "QmitkUSNavigationStepPlacementPlanning.h"
 #include "ui_QmitkUSNavigationStepPlacementPlanning.h"
 
 #include "../Interactors/mitkUSPointMarkInteractor.h"
 #include "../mitkUSTargetPlacementQualityCalculator.h"
 #include "mitkNeedleProjectionFilter.h"
 #include "mitkNodeDisplacementFilter.h"
 #include "usModuleRegistry.h"
 
 #include "../Filter/mitkUSNavigationTargetIntersectionFilter.h"
 #include "../Filter/mitkUSNavigationTargetUpdateFilter.h"
 
 #include "../QmitkUSNavigationMarkerPlacement.h"
 
 #include "mitkLookupTableProperty.h"
 #include "mitkSurface.h"
 #include <mitkBaseGeometry.h>
 
 #include "mitkLayoutAnnotationRenderer.h"
 #include "mitkTextAnnotation3D.h"
 
 #include "vtkFloatArray.h"
 #include "vtkLookupTable.h"
 #include "vtkPointData.h"
 #include "vtkPolyData.h"
 #include "vtkSmartPointer.h"
 
 #include "vtkLineSource.h"
 #include <vtkSphereSource.h>
 
 #include "vtkCenterOfMass.h"
 #include "vtkLinearTransform.h"
 #include "vtkPoints.h"
 #include "vtkTransformPolyDataFilter.h"
 #include "vtkUnstructuredGrid.h"
 
 #include "vtkMath.h"
 
 QmitkUSNavigationStepPlacementPlanning::QmitkUSNavigationStepPlacementPlanning(QWidget *parent)
   : QmitkUSAbstractNavigationStep(parent),
     m_NumberOfTargets(0),
     m_CurrentTargetIndex(0),
     m_BodyMarkerValid(false),
     m_PointMarkInteractor(mitk::USPointMarkInteractor::New()),
     m_TargetUpdateFilter(mitk::USNavigationTargetUpdateFilter::New()),
     m_NodeDisplacementFilter(mitk::NodeDisplacementFilter::New()),
     m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()),
     m_TargetIntersectionFilter(mitk::USNavigationTargetIntersectionFilter::New()),
     m_PlacementQualityCalculator(mitk::USTargetPlacementQualityCalculator::New()),
     m_ReferenceSensorIndex(1),
     m_NeedleSensorIndex(0),
     m_ListenerTargetCoordinatesChanged(this, &QmitkUSNavigationStepPlacementPlanning::UpdateTargetCoordinates),
     ui(new Ui::QmitkUSNavigationStepPlacementPlanning)
 {
   ui->setupUi(this);
 
   connect(ui->freezeImageButton, SIGNAL(SignalFreezed(bool)), this, SLOT(OnFreeze(bool)));
 
   m_TargetUpdateFilter->SetScalarArrayIdentifier("USNavigation::PlanningPlacement");
 
   this->GenerateTargetColorLookupTable();
 }
 
 QmitkUSNavigationStepPlacementPlanning::~QmitkUSNavigationStepPlacementPlanning()
 {
   delete ui;
 }
 
 bool QmitkUSNavigationStepPlacementPlanning::OnStartStep()
 {
   // create node for needle projection
   mitk::DataNode::Pointer node =
     this->GetNamedDerivedNodeAndCreate("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
   node->SetData(m_NeedleProjectionFilter->GetProjection());
   node->SetBoolProperty("show contour", true);
 
   // make sure that the targets node exist in the data storage
   this->GetNamedDerivedNodeAndCreate(QmitkUSNavigationMarkerPlacement::DATANAME_TARGETS,
                                      QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
   this->GetNamedDerivedNodeAndCreate(QmitkUSNavigationMarkerPlacement::DATANAME_TARGETS_PATHS,
                                      QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
 
   // listen to event of point mark interactor
   m_PointMarkInteractor->CoordinatesChangedEvent.AddListener(m_ListenerTargetCoordinatesChanged);
 
   return true;
 }
 
 bool QmitkUSNavigationStepPlacementPlanning::OnStopStep()
 {
   // remove listener to event of point mark interactor
   m_PointMarkInteractor->CoordinatesChangedEvent.RemoveListener(m_ListenerTargetCoordinatesChanged);
 
   m_CurrentTargetIndex = 0;
   m_TargetUpdateFilter->Reset();
   m_NodeDisplacementFilter->ResetNodes();
 
   // remove the planned target nodes from the data storage
   mitk::DataStorage::Pointer dataStorage = this->GetDataStorage();
   for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_PlannedTargetNodes.begin();
        it != m_PlannedTargetNodes.end();
        ++it)
   {
     dataStorage->Remove(*it);
   }
   m_PlannedTargetNodes.clear();
 
   // remove the planned target path nodes from the data storage
   for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_PlannedNeedlePaths.begin();
        it != m_PlannedNeedlePaths.end();
        ++it)
   {
     dataStorage->Remove(*it);
   }
   m_PlannedNeedlePaths.clear();
 
   // remove the targets node from the data storage
   mitk::DataNode::Pointer targetsNode = this->GetNamedDerivedNode(QmitkUSNavigationMarkerPlacement::DATANAME_TARGETS,
                                                                   QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
   if (targetsNode.IsNotNull())
   {
     dataStorage->Remove(targetsNode);
   }
 
   // remove the target paths node from the data storage
   mitk::DataNode::Pointer targetPathsNode = this->GetNamedDerivedNode(
     QmitkUSNavigationMarkerPlacement::DATANAME_TARGETS_PATHS, QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
   if (targetPathsNode.IsNotNull())
   {
     dataStorage->Remove(targetPathsNode);
   }
 
   // make sure that the image is no longer freezed after stopping
   ui->freezeImageButton->Unfreeze();
 
   return true;
 }
 
 bool QmitkUSNavigationStepPlacementPlanning::OnRestartStep()
 {
   this->OnStopStep();
   this->OnStartStep();
 
   return true;
 }
 
 bool QmitkUSNavigationStepPlacementPlanning::OnFinishStep()
 {
   // create scalars showing the planned positions on the target surface
   if (!m_PlannedTargetNodes.isEmpty())
   {
     mitk::USNavigationTargetUpdateFilter::Pointer planningSurfaceFilter = mitk::USNavigationTargetUpdateFilter::New();
     planningSurfaceFilter->SetOptimalAngle(0);
     planningSurfaceFilter->SetScalarArrayIdentifier("USNavigation::PlanningScalars");
     planningSurfaceFilter->SetUseMaximumScore(true);
     planningSurfaceFilter->SetTargetStructure(m_TargetNode);
 
     unsigned int n = 0;
     for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_PlannedTargetNodes.begin();
          it != m_PlannedTargetNodes.end();
          ++it)
     {
       bool isSurfaceEmpty;
       if (((*it)->GetBoolProperty("surface_empty", isSurfaceEmpty)) && isSurfaceEmpty)
       {
         // remove node from data storage if it is not fully planned
         this->GetDataStorage()->Remove(*it);
       }
       else
       {
         // set origin to filter for coloring target surface (good
         // positions are positions near to the origin)
         planningSurfaceFilter->SetControlNode(n, *it);
       }
 
       n++;
     }
   }
 
   // make sure that the image is no longer freezed after finishing
   ui->freezeImageButton->Unfreeze();
 
   return true;
 }
 
 bool QmitkUSNavigationStepPlacementPlanning::OnActivateStep()
 {
   emit SignalReadyForNextStep();
 
   m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex);
   m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex);
 
   if (m_PlannedTargetNodes.empty())
   {
     m_CurrentTargetIndex = 0;
   }
   else
   {
     m_CurrentTargetIndex = m_PlannedTargetNodes.size() - 1;
   }
 
   m_TargetNode = this->GetNamedDerivedNode(QmitkUSNavigationMarkerPlacement::DATANAME_TARGETSURFACE,
                                            QmitkUSNavigationMarkerPlacement::DATANAME_TUMOUR);
   m_TargetNode->SetBoolProperty("visible", true);
 
   // set lookup table of tumour node
   m_TargetNode->SetProperty("LookupTable", m_TargetColorLookupTableProperty);
 
   m_TargetUpdateFilter->SetTargetStructure(m_TargetNode);
 
   for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_PlannedTargetNodes.begin();
        it != m_PlannedTargetNodes.end();
        ++it)
   {
     (*it)->SetBoolProperty("visible", true);
   }
 
   this->UpdateTargetDescriptions();
 
   // m_TargetUpdateFilter->UpdateTargetScores();
 
   return true;
 }
 
 bool QmitkUSNavigationStepPlacementPlanning::OnDeactivateStep()
 {
   ui->freezeImageButton->Unfreeze();
 
   return true;
 }
 
 void QmitkUSNavigationStepPlacementPlanning::OnUpdate()
 {
   this->UpdateTargetColors();
 
   // get navigation data source and make sure that it is not null
   mitk::NavigationDataSource::Pointer navigationDataSource = this->GetCombinedModality()->GetNavigationDataSource();
   if (navigationDataSource.IsNull())
   {
     MITK_ERROR("QmitkUSAbstractNavigationStep")
     ("QmitkUSNavigationStepPunctuationIntervention") << "Navigation Data Source of Combined Modality must not be null.";
     mitkThrow() << "Navigation Data Source of Combined Modality must not be null.";
   }
 
   navigationDataSource->Update();
   this->UpdateBodyMarkerStatus(navigationDataSource->GetOutput(m_ReferenceSensorIndex));
 
   ui->freezeImageButton->setEnabled(m_BodyMarkerValid);
 
   mitk::PointSet::Pointer needleProjectionPointSet = m_NeedleProjectionFilter->GetProjection();
   if (needleProjectionPointSet->GetSize() == 2)
   {
     m_TargetIntersectionFilter->SetTargetSurface(dynamic_cast<mitk::Surface *>(m_TargetNode->GetData()));
     m_TargetIntersectionFilter->SetLine(needleProjectionPointSet);
     m_TargetIntersectionFilter->CalculateIntersection();
     if (m_TargetIntersectionFilter->GetIsIntersecting())
     {
       // only enable button if body marker is in the tracking volume, too
       ui->placeTargetButton->setEnabled(m_BodyMarkerValid);
       ui->placeTargetButton->setToolTip("");
 
       if (m_PlannedTargetNodes.size() == m_NumberOfTargets - 1)
       {
         mitk::PointSet::Pointer targetPointSet = mitk::PointSet::New();
 
         mitk::PointSet::PointIdentifier n = 0;
         for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_PlannedTargetNodes.begin();
              it != m_PlannedTargetNodes.end();
              ++it)
         {
           targetPointSet->InsertPoint(n++, (*it)->GetData()->GetGeometry()->GetOrigin());
         }
         targetPointSet->InsertPoint(n, m_TargetIntersectionFilter->GetIntersectionPoint());
 
         this->CalculatePlanningQuality(dynamic_cast<mitk::Surface *>(m_TargetNode->GetData()), targetPointSet);
       }
     }
     else
     {
       ui->placeTargetButton->setEnabled(false);
       ui->placeTargetButton->setToolTip(
         "Target cannot be placed as the needle path is not intersecting the target surface.");
 
       // no not show planning quality if not all nodes are planned for now
       // and there is no needle path intersection
       if (m_PlannedTargetNodes.size() < m_NumberOfTargets)
       {
         ui->angleDifferenceValue->setText("");
         ui->centersOfMassValue->setText("");
       }
     }
   }
 }
 
 void QmitkUSNavigationStepPlacementPlanning::OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode)
 {
   int numberOfTargets;
   if (settingsNode->GetIntProperty("settings.number-of-targets", numberOfTargets))
   {
     m_NumberOfTargets = numberOfTargets;
     m_TargetUpdateFilter->SetNumberOfTargets(numberOfTargets);
 
     m_PlacementQualityCalculator->SetOptimalAngle(m_TargetUpdateFilter->GetOptimalAngle());
   }
 
   std::string referenceSensorName;
   if (settingsNode->GetStringProperty("settings.reference-name-selected", referenceSensorName))
   {
     m_ReferenceSensorName = referenceSensorName;
   }
 
   std::string needleSensorName;
   if (settingsNode->GetStringProperty("settings.needle-name-selected", needleSensorName))
   {
     m_NeedleSensorName = needleSensorName;
   }
 
   this->UpdateSensorsNames();
 }
 
 QString QmitkUSNavigationStepPlacementPlanning::GetTitle()
 {
   return "Placement Planning";
 }
 
 QmitkUSAbstractNavigationStep::FilterVector QmitkUSNavigationStepPlacementPlanning::GetFilter()
 {
   FilterVector filterVector;
   filterVector.push_back(m_NodeDisplacementFilter.GetPointer());
   filterVector.push_back(m_NeedleProjectionFilter.GetPointer());
   return filterVector;
 }
 
 void QmitkUSNavigationStepPlacementPlanning::OnSetCombinedModality()
 {
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetCombinedModality(false);
   if (combinedModality.IsNotNull())
   {
     mitk::AffineTransform3D::Pointer calibration = combinedModality->GetCalibration();
     if (calibration.IsNotNull())
     {
       m_NeedleProjectionFilter->SetTargetPlane(calibration);
     }
   }
 
   ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex);
 
   this->UpdateSensorsNames();
 }
 
 void QmitkUSNavigationStepPlacementPlanning::OnFreeze(bool freeze)
 {
   if (freeze)
     this->GetCombinedModality()->SetIsFreezed(true);
   if (freeze)
   {
     // load state machine and event config for data interactor
     m_PointMarkInteractor->LoadStateMachine("USPointMarkInteractions.xml", us::ModuleRegistry::GetModule("MitkUS"));
     m_PointMarkInteractor->SetEventConfig("globalConfig.xml");
 
     this->CreateTargetNodesIfNecessary();
 
     m_PointMarkInteractor->SetDataNode(m_PlannedTargetNodes.at(m_CurrentTargetIndex));
   }
   else
   {
-    m_PointMarkInteractor->SetDataNode(0);
+    m_PointMarkInteractor->SetDataNode(nullptr);
   }
 
   if (!freeze)
     this->GetCombinedModality()->SetIsFreezed(false);
 }
 
 void QmitkUSNavigationStepPlacementPlanning::OnPlaceTargetButtonClicked()
 {
   this->CreateTargetNodesIfNecessary();
 
   mitk::DataNode::Pointer currentNode = m_PlannedTargetNodes.at(m_CurrentTargetIndex);
 
   currentNode->SetData(this->CreateSphere(5));
   currentNode->SetBoolProperty("surface_empty", false);
 
   mitk::PointSet::Pointer needleProjection = m_NeedleProjectionFilter->GetProjection();
 
   m_TargetIntersectionFilter->SetTargetSurface(dynamic_cast<mitk::Surface *>(m_TargetNode->GetData()));
   m_TargetIntersectionFilter->SetLine(m_NeedleProjectionFilter->GetProjection());
   m_TargetIntersectionFilter->CalculateIntersection();
   mitk::Point3D intersectionPoint = m_TargetIntersectionFilter->GetIntersectionPoint();
 
   currentNode->GetData()->GetGeometry()->SetOrigin(intersectionPoint);
   m_TargetUpdateFilter->SetControlNode(m_CurrentTargetIndex, currentNode);
 
   mitk::PointSet::Pointer plannedPath = mitk::PointSet::New();
   m_PlannedNeedlePaths.at(m_CurrentTargetIndex)->SetData(plannedPath);
   plannedPath->SetPoint(0, needleProjection->GetPoint(0));
   plannedPath->SetPoint(1, intersectionPoint);
 
   if (m_CurrentTargetIndex < m_NumberOfTargets - 1)
   {
     this->OnGoToNextTarget();
   }
   else
   {
     this->UpdateTargetDescriptions();
   }
 
   this->ReinitNodeDisplacementFilter();
 
   MITK_INFO("QmitkUSAbstractNavigationStep")
   ("QmitkUSNavigationStepPlacementPlanning") << "Target " << m_CurrentTargetIndex + 1 << " planned at position "
                                              << intersectionPoint << ".";
 }
 
 void QmitkUSNavigationStepPlacementPlanning::OnGoToPreviousTarget()
 {
   if (m_CurrentTargetIndex < 1)
   {
     mitkThrow() << "Cannot go to previous target as current target is first target.";
   }
 
   m_CurrentTargetIndex--;
 
   this->UpdateTargetDescriptions();
 }
 
 void QmitkUSNavigationStepPlacementPlanning::OnGoToNextTarget()
 {
   m_CurrentTargetIndex++;
 
   this->UpdateTargetDescriptions();
 }
 
 void QmitkUSNavigationStepPlacementPlanning::OnRemoveCurrentTargetClicked()
 {
   if (m_CurrentTargetIndex >= m_PlannedTargetNodes.size())
   {
     MITK_WARN << "Cannot remove current target as there aren't as much planned target nodes.";
     return;
   }
 
   this->GetDataStorage()->Remove(m_PlannedTargetNodes.at(m_CurrentTargetIndex));
   m_PlannedTargetNodes.remove(m_CurrentTargetIndex);
   this->GetDataStorage()->Remove(m_PlannedNeedlePaths.at(m_CurrentTargetIndex));
   m_PlannedNeedlePaths.remove(m_CurrentTargetIndex);
   this->ReinitNodeDisplacementFilter();
 
   for (int n = 0; n < m_PlannedTargetNodes.size(); ++n)
   {
     // set name of the target node according to its new index
     m_PlannedTargetNodes.at(n)->SetName(
       QString("Target %1").arg(n + 1, m_NumberOfTargets / 10 + 1, 10, QLatin1Char('0')).toStdString());
 
     m_PlannedNeedlePaths.at(n)->SetName(
       QString("Target Path %1").arg(n + 1, m_NumberOfTargets / 10 + 1, 10, QLatin1Char('0')).toStdString());
   }
 
   m_TargetUpdateFilter->RemovePositionOfTarget(m_CurrentTargetIndex);
 
   m_CurrentTargetIndex = m_PlannedTargetNodes.size();
 
   this->UpdateTargetDescriptions();
 
   MITK_INFO("QmitkUSAbstractNavigationStep")
   ("QmitkUSNavigationStepPlacementPlanning") << "Planned target " << m_CurrentTargetIndex + 1 << " removed.";
 }
 
 void QmitkUSNavigationStepPlacementPlanning::CreateTargetNodesIfNecessary()
 {
   mitk::DataStorage::Pointer dataStorage = this->GetDataStorage();
 
   while (m_PlannedTargetNodes.size() <= m_CurrentTargetIndex)
   {
     QString targetNumber =
       QString("%1").arg(m_PlannedTargetNodes.size() + 1, m_NumberOfTargets / 10 + 1, 10, QLatin1Char('0'));
 
     mitk::DataNode::Pointer targetNode = this->GetNamedDerivedNodeAndCreate(
       (QString("Target ") + targetNumber).toStdString().c_str(), QmitkUSNavigationMarkerPlacement::DATANAME_TARGETS);
     targetNode->SetOpacity(0.5);
     targetNode->SetBoolProperty("surface_empty", true);
     targetNode->SetData(mitk::Surface::New());
 
     m_PlannedTargetNodes.push_back(targetNode);
 
     mitk::DataNode::Pointer targetPathNode =
       this->GetNamedDerivedNodeAndCreate((QString("Target Path ") + targetNumber).toStdString().c_str(),
                                          QmitkUSNavigationMarkerPlacement::DATANAME_TARGETS_PATHS);
     targetPathNode->SetOpacity(0.5);
     targetPathNode->SetColor(1, 1, 1);
     targetPathNode->SetColor(1, 1, 1, nullptr, "contourcolor");
     targetPathNode->SetBoolProperty("show contour", true);
     m_PlannedNeedlePaths.push_back(targetPathNode);
 
     mitk::Surface::Pointer pathSurface = mitk::Surface::New();
     targetPathNode->SetData(pathSurface);
   }
 }
 
 void QmitkUSNavigationStepPlacementPlanning::UpdateTargetCoordinates(mitk::DataNode *dataNode)
 {
   bool surfaceEmpty;
   if (dataNode->GetBoolProperty("surface_empty", surfaceEmpty) && surfaceEmpty)
   {
     mitk::Point3D origin = dataNode->GetData()->GetGeometry()->GetOrigin();
     dataNode->SetData(this->CreateSphere(5));
     dataNode->SetBoolProperty("surface_empty", false);
     dataNode->GetData()->GetGeometry()->SetOrigin(origin);
   }
 
   this->ReinitNodeDisplacementFilter();
 
   mitk::BaseData *baseData = dataNode->GetData();
   if (!baseData)
   {
     mitkThrow() << "Data of the data node must not be null.";
   }
 
   mitk::BaseGeometry::Pointer geometry = baseData->GetGeometry();
   if (geometry.IsNull())
   {
     mitkThrow() << "Geometry of the data node must not be null.";
   }
 
   m_TargetUpdateFilter->SetControlNode(m_CurrentTargetIndex, dataNode);
 
   MITK_INFO("QmitkUSAbstractNavigationStep")
   ("QmitkUSNavigationStepPlacementPlanning") << "Target " << m_CurrentTargetIndex + 1 << " planned at position "
                                              << geometry->GetOrigin() << ".";
 
   if (ui->freezeImageButton->isChecked())
   {
     ui->freezeImageButton->Unfreeze();
 
     if (m_CurrentTargetIndex < m_NumberOfTargets - 1)
     {
       this->OnGoToNextTarget();
     }
   }
 
   this->UpdateTargetDescriptions();
 }
 
 void QmitkUSNavigationStepPlacementPlanning::UpdateTargetColors()
 {
   if (m_TargetNode.IsNull())
   {
     return;
   }
 
   m_TargetNode->SetColor(1, 1, 1);
 
   mitk::BaseData *targetNodeData = m_TargetNode->GetData();
-  if (targetNodeData == 0)
+  if (targetNodeData == nullptr)
   {
     return;
   }
 
   mitk::Surface::Pointer targetNodeSurface = dynamic_cast<mitk::Surface *>(targetNodeData);
   vtkSmartPointer<vtkPolyData> targetNodeSurfaceVtk = targetNodeSurface->GetVtkPolyData();
 
   vtkFloatArray *targetScoreScalars = dynamic_cast<vtkFloatArray *>(
     targetNodeSurface->GetVtkPolyData()->GetPointData()->GetScalars("USNavigation::PlanningPlacement"));
 
   if (!targetScoreScalars)
   {
     return;
   }
 
   unsigned int numberOfTupels = targetScoreScalars->GetNumberOfTuples();
 
   vtkSmartPointer<vtkFloatArray> colors = vtkSmartPointer<vtkFloatArray>::New();
   colors->SetNumberOfComponents(1);
   colors->SetNumberOfTuples(numberOfTupels);
   colors->SetName("Colors");
 
   double markerScore;
 
   for (unsigned int n = 0; n < numberOfTupels; n++)
   {
     targetScoreScalars->GetTuple(n, &markerScore);
     colors->SetTuple(n, &markerScore);
   }
 
   if (numberOfTupels > 0)
   {
     targetNodeSurfaceVtk->GetPointData()->SetScalars(colors);
     targetNodeSurfaceVtk->GetPointData()->Update();
   }
 }
 
 void QmitkUSNavigationStepPlacementPlanning::UpdateTargetDescriptions()
 {
   ui->previousButton->setEnabled(m_CurrentTargetIndex > 0);
   ui->nextButton->setEnabled(m_CurrentTargetIndex + 1 < m_PlannedTargetNodes.size());
   ui->removeButton->setEnabled(m_PlannedTargetNodes.size() > 0);
 
   ui->currentTargetLabel->setText(
     QString("Planning Target %1 of %2").arg(m_CurrentTargetIndex + 1).arg(m_NumberOfTargets));
 
   ui->removeButton->setEnabled(m_CurrentTargetIndex < m_PlannedTargetNodes.size());
 
   this->CalculatePlanningQuality();
 }
 
 void QmitkUSNavigationStepPlacementPlanning::GenerateTargetColorLookupTable()
 {
   vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
   lookupTable->SetHueRange(0.0, 0.27);
   lookupTable->SetSaturationRange(1.0, 1.0);
   lookupTable->SetValueRange(1.0, 1.0);
   lookupTable->SetTableRange(0.0, 1.0);
   lookupTable->Build();
 
   mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
   lut->SetVtkLookupTable(lookupTable);
 
   m_TargetColorLookupTableProperty = mitk::LookupTableProperty::New(lut);
 }
 
 void QmitkUSNavigationStepPlacementPlanning::ReinitNodeDisplacementFilter()
 {
   m_NodeDisplacementFilter->ResetNodes();
   for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_PlannedTargetNodes.begin();
        it != m_PlannedTargetNodes.end();
        ++it)
   {
-    if (it->IsNotNull() && (*it)->GetData() != 0)
+    if (it->IsNotNull() && (*it)->GetData() != nullptr)
     {
       m_NodeDisplacementFilter->AddNode(*it);
     }
   }
   for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_PlannedNeedlePaths.begin();
        it != m_PlannedNeedlePaths.end();
        ++it)
   {
-    if (it->IsNotNull() && (*it)->GetData() != 0)
+    if (it->IsNotNull() && (*it)->GetData() != nullptr)
     {
       m_NodeDisplacementFilter->AddNode(*it);
     }
   }
 }
 
 void QmitkUSNavigationStepPlacementPlanning::CalculatePlanningQuality()
 {
   if (m_PlannedTargetNodes.size() != m_NumberOfTargets)
   {
     ui->angleDifferenceLabel->setEnabled(false);
     ui->centersOfMassLabel->setEnabled(false);
     ui->allTargetsPlannedLabel->setEnabled(false);
     ui->angleDifferenceValue->setText("");
     ui->centersOfMassValue->setText("");
     return;
   }
 
   ui->angleDifferenceLabel->setEnabled(true);
   ui->centersOfMassLabel->setEnabled(true);
   ui->allTargetsPlannedLabel->setEnabled(true);
 
   mitk::PointSet::Pointer targetPointSet = mitk::PointSet::New();
 
   mitk::PointSet::PointIdentifier n = 0;
   for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_PlannedTargetNodes.begin();
        it != m_PlannedTargetNodes.end();
        ++it)
   {
     targetPointSet->InsertPoint(n++, (*it)->GetData()->GetGeometry()->GetOrigin());
   }
 
   mitk::DataNode::Pointer planningQualityResult =
     this->CalculatePlanningQuality(dynamic_cast<mitk::Surface *>(m_TargetNode->GetData()), targetPointSet);
   emit SignalIntermediateResult(planningQualityResult);
 }
 
 mitk::DataNode::Pointer QmitkUSNavigationStepPlacementPlanning::CalculatePlanningQuality(
   mitk::Surface::Pointer targetSurface, mitk::PointSet::Pointer targetPoints)
 {
   if (targetSurface.IsNull())
   {
     mitkThrow() << "Target surface must not be null.";
   }
 
   m_PlacementQualityCalculator->SetTargetSurface(targetSurface);
   m_PlacementQualityCalculator->SetTargetPoints(targetPoints);
   m_PlacementQualityCalculator->Update();
 
   mitk::DataNode::Pointer planningQualityResult = mitk::DataNode::New();
   planningQualityResult->SetName("PlanningQuality");
 
   double centersOfMassDistance = m_PlacementQualityCalculator->GetCentersOfMassDistance();
   ui->centersOfMassValue->setText(QString::number(centersOfMassDistance, 103, 2) + " mm");
   planningQualityResult->SetFloatProperty("USNavigation::CentersOfMassDistance", centersOfMassDistance);
 
   if (m_PlannedTargetNodes.size() > 1)
   {
     double meanAnglesDifference = m_PlacementQualityCalculator->GetMeanAngleDifference();
     ui->angleDifferenceValue->setText(QString::number(meanAnglesDifference, 103, 2) + QString::fromLatin1(" °"));
 
     planningQualityResult->SetFloatProperty("USNavigation::MeanAngleDifference", meanAnglesDifference);
     planningQualityResult->SetProperty(
       "USNavigation::AngleDifferences",
       mitk::GenericProperty<mitk::VnlVector>::New(m_PlacementQualityCalculator->GetAngleDifferences()));
   }
   else
   {
     ui->angleDifferenceValue->setText("not valid for one point");
   }
 
   return planningQualityResult;
 }
 
 itk::SmartPointer<mitk::Surface> QmitkUSNavigationStepPlacementPlanning::CreateSphere(float)
 {
   mitk::Surface::Pointer surface = mitk::Surface::New();
 
   // create a vtk sphere with fixed radius
   vtkSmartPointer<vtkSphereSource> vtkSphere = vtkSmartPointer<vtkSphereSource>::New();
   vtkSphere->SetRadius(5);
   vtkSphere->SetCenter(0, 0, 0);
   vtkSphere->Update();
   surface->SetVtkPolyData(vtkSphere->GetOutput());
 
   return surface;
 }
 
 void QmitkUSNavigationStepPlacementPlanning::UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker)
 {
   if (bodyMarker.IsNull())
   {
     MITK_ERROR("QmitkUSAbstractNavigationStep")
     ("QmitkUSNavigationStepPunctuationIntervention")
       << "Current Navigation Data for body marker of Combined Modality must not be null.";
     mitkThrow() << "Current Navigation Data for body marker of Combined Modality must not be null.";
   }
 
   m_BodyMarkerValid = bodyMarker->IsDataValid();
 
   // update body marker status label
   if (m_BodyMarkerValid)
   {
     ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
       "background-color: #8bff8b; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
     ui->bodyMarkerTrackingStatusLabel->setText("Body marker is inside the tracking volume.");
   }
   else
   {
     ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
       "background-color: #ff7878; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
     ui->bodyMarkerTrackingStatusLabel->setText("Body marker is not inside the tracking volume.");
   }
 }
 
 void QmitkUSNavigationStepPlacementPlanning::UpdateSensorsNames()
 {
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetCombinedModality(false);
   if (combinedModality.IsNull())
   {
     return;
   }
 
   mitk::NavigationDataSource::Pointer navigationDataSource = combinedModality->GetNavigationDataSource();
   if (navigationDataSource.IsNull())
   {
     return;
   }
 
   if (!m_NeedleSensorName.empty())
   {
     try
     {
       m_NeedleSensorIndex = navigationDataSource->GetOutputIndex(m_NeedleSensorName);
     }
     catch (const std::exception &e)
     {
       MITK_WARN("QmitkUSAbstractNavigationStep")
       ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for needle sensor name: " << e.what();
     }
   }
   if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active)
   {
     m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex);
   }
 
   if (!m_ReferenceSensorName.empty())
   {
     try
     {
       m_ReferenceSensorIndex = navigationDataSource->GetOutputIndex(m_ReferenceSensorName);
     }
     catch (const std::exception &e)
     {
       MITK_WARN("QmitkUSAbstractNavigationStep")
       ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for reference sensor name: " << e.what();
     }
   }
   if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active)
   {
     m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex);
   }
 
   ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex);
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h
index e404e5fb8f..26403771c0 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h
@@ -1,148 +1,148 @@
 /*===================================================================
 
 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 QMITKUSNAVIGATIONSTEPPLACEMENTPLANNING_H
 #define QMITKUSNAVIGATIONSTEPPLACEMENTPLANNING_H
 
 #include "QmitkUSAbstractNavigationStep.h"
 
 namespace Ui
 {
   class QmitkUSNavigationStepPlacementPlanning;
 }
 
 namespace mitk
 {
   class USNavigationTargetUpdateFilter;
   class USNavigationTargetIntersectionFilter;
   class USPointMarkInteractor;
   class NodeDisplacementFilter;
   class NeedleProjectionFilter;
   class LookupTableProperty;
   class TextAnnotation3D;
   class Surface;
   class PointSet;
   class USTargetPlacementQualityCalculator;
 }
 
 /**
  * \brief Navigation step for planning the positions for implanting markers.
  *
  * The planned targets are stored in the data storage under DATANAME_BASENODE ->
  * DATANAME_TARGETS and the needle path to the planned targets are stored under
  * DATANAME_BASENODE -> DATANAME_TARGETS_PATHS. The target structure is expected
  * to be stored under DATANAME_BASENODE -> DATANAME_TUMOR ->
  * DATANAME_TARGETSURFACE.
  *
  */
 class QmitkUSNavigationStepPlacementPlanning : public QmitkUSAbstractNavigationStep
 {
   Q_OBJECT
 
 protected slots:
   /**
    * \brief Freezes or unfreezes the combined modality.
    * In freeze state an interactor is activated in the render window, so the
    * position of the currently active target can be planned by clicking into the
    * render window.
    */
   void OnFreeze(bool freezed);
 
   /**
    * \brief Plan target position at the intersection between needle path and target surface.
    */
   void OnPlaceTargetButtonClicked();
 
   /**
    * \brief Selects the previous target as active target.
    */
   void OnGoToPreviousTarget();
 
   /**
    * \brief Selects the next target as active target.
    */
   void OnGoToNextTarget();
 
   /**
    * \brief The currently active target is removed from the data storage.
    */
   void OnRemoveCurrentTargetClicked();
 
 public:
-  explicit QmitkUSNavigationStepPlacementPlanning(QWidget *parent = 0);
+  explicit QmitkUSNavigationStepPlacementPlanning(QWidget *parent = nullptr);
   ~QmitkUSNavigationStepPlacementPlanning() override;
 
   QString GetTitle() override;
   FilterVector GetFilter() override;
 
 protected:
   bool OnStartStep() override;
   bool OnStopStep() override;
   bool OnRestartStep() override;
   bool OnFinishStep() override;
 
   bool OnActivateStep() override;
   bool OnDeactivateStep() override;
   void OnUpdate() override;
 
   void OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode) override;
   void OnSetCombinedModality() override;
 
   void CreateTargetNodesIfNecessary();
   void UpdateTargetCoordinates(mitk::DataNode *);
   void UpdateTargetColors();
   void UpdateTargetDescriptions();
   void GenerateTargetColorLookupTable();
   void ReinitNodeDisplacementFilter();
   void CalculatePlanningQuality();
   itk::SmartPointer<mitk::DataNode> CalculatePlanningQuality(itk::SmartPointer<mitk::Surface> targetSurface,
                                                              itk::SmartPointer<mitk::PointSet>);
   itk::SmartPointer<mitk::Surface> CreateSphere(float radius);
   void UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker);
   void UpdateSensorsNames();
 
   int m_NumberOfTargets;
   int m_CurrentTargetIndex;
   bool m_BodyMarkerValid;
 
   itk::SmartPointer<mitk::USPointMarkInteractor> m_PointMarkInteractor;
   itk::SmartPointer<mitk::USNavigationTargetUpdateFilter> m_TargetUpdateFilter;
   itk::SmartPointer<mitk::NodeDisplacementFilter> m_NodeDisplacementFilter;
   itk::SmartPointer<mitk::NeedleProjectionFilter> m_NeedleProjectionFilter;
   itk::SmartPointer<mitk::USNavigationTargetIntersectionFilter> m_TargetIntersectionFilter;
   itk::SmartPointer<mitk::USTargetPlacementQualityCalculator> m_PlacementQualityCalculator;
 
   itk::SmartPointer<mitk::LookupTableProperty> m_TargetColorLookupTableProperty;
 
   itk::SmartPointer<mitk::DataNode> m_TargetNode;
   QVector<itk::SmartPointer<mitk::DataNode>> m_PlannedTargetNodes;
   QVector<itk::SmartPointer<mitk::DataNode>> m_PlannedNeedlePaths;
 
   itk::SmartPointer<mitk::TextAnnotation3D> m_CurrentTargetNodeOverlay;
 
   std::string m_ReferenceSensorName;
   std::string m_NeedleSensorName;
 
   unsigned int m_ReferenceSensorIndex;
   unsigned int m_NeedleSensorIndex;
 
 private:
   mitk::MessageDelegate1<QmitkUSNavigationStepPlacementPlanning, mitk::DataNode *> m_ListenerTargetCoordinatesChanged;
 
   Ui::QmitkUSNavigationStepPlacementPlanning *ui;
 };
 
 #endif // QMITKUSNAVIGATIONSTEPPLACEMENTPLANNING_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.h
index d99b0899ee..b5e7a46f3b 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.h
@@ -1,123 +1,123 @@
 /*===================================================================
 
 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 QMITKUSNAVIGATIONSTEPPUNCTUATIONINTERVENTION_H
 #define QMITKUSNAVIGATIONSTEPPUNCTUATIONINTERVENTION_H
 
 #include "QmitkUSAbstractNavigationStep.h"
 #include <mitkPointSet.h>
 #include <mitkNavigationTool.h>
 #include <vtkSmartPointer.h>
 #include <vtkSphereSource.h>
 #include <vtkLine.h>
 #include <vtkOBBTree.h>
 
 namespace mitk {
 class DataNode;
 class NeedleProjectionFilter;
 class NodeDisplacementFilter;
 class USNavigationGrabCutSegmentationUpdateFilter;
 class USNavigationTargetUpdateFilter;
 class USNavigationTargetOcclusionFilter;
 class USPointMarkInteractor;
 class LookupTableProperty;
 class Surface;
 }
 
 namespace Ui {
 class QmitkUSNavigationStepPunctuationIntervention;
 }
 
 class QmitkZoneProgressBar;
 
 /**
  * \brief Navigations step for the actual punctuation intervention.
  * The needle path is projected onto the image plane and the distances to all
  * risk structures are displayed in the widget.
  *
  * The risk structures are expected to be in the data storage under
  * DATANAME_BASENODE -> DATANAME_ZONES. They should contain a property named
  * "zone.size" and it is assumed that they are spherical.
  */
 class QmitkUSNavigationStepPunctuationIntervention : public QmitkUSAbstractNavigationStep
 {
   Q_OBJECT
 
 public:
 
   /** Sets the navigation tool of the needle for the meta data (tool axis etc.)*/
   void SetNeedleMetaData(mitk::NavigationTool::Pointer needleNavigationTool);
-  explicit QmitkUSNavigationStepPunctuationIntervention(QWidget *parent = 0);
+  explicit QmitkUSNavigationStepPunctuationIntervention(QWidget *parent = nullptr);
   ~QmitkUSNavigationStepPunctuationIntervention() override;
 
   bool OnStartStep() override;
   bool OnRestartStep() override;
   bool OnFinishStep() override;
 
   bool OnActivateStep() override;
   void OnUpdate() override;
 
   void OnSettingsChanged(const itk::SmartPointer<mitk::DataNode>) override;
 
   QString GetTitle() override;
   bool GetIsRestartable() override;
 
   FilterVector GetFilter() override;
 
 signals:
 
   void AddAblationZoneClicked(int);
 
   void AblationZoneChanged(int,int);
 
 protected slots:
 
   void OnAddAblationZoneClicked();
   void OnEnableAblationZoneMarkingClicked();
   void OnAblationZoneSizeSliderChanged(int size);
   void OnShowToolAxisEnabled(int enabled);
 
 protected:
   void OnSetCombinedModality() override;
 
   void ClearZones();
   void UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker);
   /** Updates the critical structures which means that the distance to the needle tip is updated
       and also the color changes to red if the path projection intersects the critical structure. */
   void UpdateCriticalStructures(mitk::NavigationData::Pointer needle, mitk::PointSet::Pointer path);
   /** Checks if the given line intersects the given sphere. */
   bool CheckSphereLineIntersection(mitk::Point3D& sphereOrigin, float& sphereRadius, mitk::Point3D& lineStart, mitk::Point3D& lineEnd);
 
 private:
   Ui::QmitkUSNavigationStepPunctuationIntervention *m_Ui;
 
   mitk::DataStorage::SetOfObjects::ConstPointer m_ZoneNodes;
 
   /** \brief Creates a Pointset that projects the needle's path */
   itk::SmartPointer<mitk::NeedleProjectionFilter> m_NeedleProjectionFilter;
 
   /** holds the navigation tool of the needle for the meta data (tool axis etc.)*/
   mitk::NavigationTool::Pointer m_NeedleNavigationTool;
 
   std::map<mitk::DataNode::Pointer,mitk::Color> m_OldColors; //stores the original color of the critical structrue nodes
 
   //some help variables for the CheckSphereLineIntersection()-Method
   vtkSmartPointer<vtkSphereSource> m_SphereSource;
   vtkSmartPointer<vtkOBBTree> m_OBBTree;
   vtkSmartPointer<vtkPoints> m_IntersectPoints;
 };
 
 #endif // QMITKUSNAVIGATIONSTEPPUNCTUATIONINTERVENTION_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.cpp
index 781dc5ad12..ba42253461 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.cpp
@@ -1,430 +1,430 @@
 /*===================================================================
 
 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 "QmitkUSNavigationStepTumourSelection.h"
 #include "ui_QmitkUSNavigationStepTumourSelection.h"
 
 #include "usModuleRegistry.h"
 
 #include "mitkDataNode.h"
 #include "mitkSurface.h"
 #include "mitkUSCombinedModality.h"
 #include "../Interactors/mitkUSZonesInteractor.h"
 #include "mitkNodeDisplacementFilter.h"
 #include "QmitkUSNavigationStepCombinedModality.h"
 
 #include "../QmitkUSNavigationMarkerPlacement.h"
 
 #include "mitkIOUtil.h"
 
 #include "vtkSmartPointer.h"
 #include "vtkDoubleArray.h"
 #include "vtkPolyData.h"
 #include "vtkPointData.h"
 #include "vtkWarpScalar.h"
 
 QmitkUSNavigationStepTumourSelection::QmitkUSNavigationStepTumourSelection(QWidget* parent) :
   QmitkUSAbstractNavigationStep(parent),
   m_targetSelectionOptional(false),
   m_SecurityDistance(0),
   m_Interactor(mitk::USZonesInteractor::New()),
   m_NodeDisplacementFilter(mitk::NodeDisplacementFilter::New()),
   m_StateMachineFilename("USZoneInteractions.xml"),
   m_ReferenceSensorIndex(1),
   m_ListenerChangeNode(this, &QmitkUSNavigationStepTumourSelection::TumourNodeChanged),
   ui(new Ui::QmitkUSNavigationStepTumourSelection)
 {
   ui->setupUi(this);
 
   connect(ui->freezeImageButton, SIGNAL(SignalFreezed(bool)), this, SLOT(OnFreeze(bool)));
   connect(ui->tumourSizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnTumourSizeChanged(int)));
   connect(ui->deleteTumourButton, SIGNAL(clicked()), this, SLOT(OnDeleteButtonClicked()));
 
   m_SphereColor = mitk::Color();
   //default color: green
   m_SphereColor[0] = 0;
   m_SphereColor[1] = 255;
   m_SphereColor[2] = 0;
 }
 void QmitkUSNavigationStepTumourSelection::SetTumorColor(mitk::Color c)
 {
   m_SphereColor = c;
 }
 
 void QmitkUSNavigationStepTumourSelection::SetTargetSelectionOptional(bool t)
 {
   m_targetSelectionOptional = t;
 }
 
 QmitkUSNavigationStepTumourSelection::~QmitkUSNavigationStepTumourSelection()
 {
   delete ui;
 }
 
 bool QmitkUSNavigationStepTumourSelection::OnStartStep()
 {
   m_TumourNode = this->GetNamedDerivedNodeAndCreate(
     QmitkUSNavigationMarkerPlacement::DATANAME_TUMOUR,
     QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
   m_TumourNode->SetColor(m_SphereColor[0], m_SphereColor[1], m_SphereColor[2]);
 
   // load state machine and event config for data interactor
   m_Interactor->LoadStateMachine(m_StateMachineFilename, us::ModuleRegistry::GetModule("MitkUS"));
   m_Interactor->SetEventConfig("globalConfig.xml");
 
   this->GetDataStorage()->ChangedNodeEvent.AddListener(m_ListenerChangeNode);
 
   m_TargetSurfaceNode = this->GetNamedDerivedNodeAndCreate(
     QmitkUSNavigationMarkerPlacement::DATANAME_TARGETSURFACE,
     QmitkUSNavigationMarkerPlacement::DATANAME_TUMOUR);
 
   // do not show the surface until this is requested
   m_TargetSurfaceNode->SetBoolProperty("visible", false);
 
   // make sure that scalars will be renderer on the surface
   m_TargetSurfaceNode->SetBoolProperty("scalar visibility", true);
   m_TargetSurfaceNode->SetBoolProperty("color mode", true);
   m_TargetSurfaceNode->SetBoolProperty("Backface Culling", true);
 
   return true;
 }
 
 bool QmitkUSNavigationStepTumourSelection::OnStopStep()
 {
   // make sure that imaging isn't freezed anymore
   ui->freezeImageButton->Unfreeze();
 
   m_NodeDisplacementFilter->ResetNodes();
 
   mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(false);
   if (dataStorage.IsNotNull())
   {
     // remove target surface node from data storage, if available there
     if (m_TargetSurfaceNode.IsNotNull()) { dataStorage->Remove(m_TargetSurfaceNode); }
 
     dataStorage->ChangedNodeEvent.RemoveListener(m_ListenerChangeNode);
     dataStorage->Remove(m_TumourNode);
-    m_TumourNode = 0;
+    m_TumourNode = nullptr;
   }
 
   MITK_INFO("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepTumourSelection")
     << "Removing tumour.";
 
   return true;
 }
 
 bool QmitkUSNavigationStepTumourSelection::OnRestartStep()
 {
   ui->tumourSizeExplanationLabel->setEnabled(false);
   ui->tumourSizeLabel->setEnabled(false);
   ui->tumourSizeSlider->setEnabled(false);
   ui->deleteTumourButton->setEnabled(false);
 
   ui->tumourSizeSlider->blockSignals(true);
   ui->tumourSizeSlider->setValue(0);
   ui->tumourSizeSlider->blockSignals(false);
 
 
   return QmitkUSAbstractNavigationStep::OnRestartStep();
 }
 
 bool QmitkUSNavigationStepTumourSelection::OnFinishStep()
 {
   // make sure that the surface has the right extent (in case the
   // tumor size was changed since the initial surface creation)
   m_TargetSurfaceNode->SetData(this->CreateTargetSurface());
 
   return true;
 }
 
 bool QmitkUSNavigationStepTumourSelection::OnActivateStep()
 {
   m_Interactor = mitk::USZonesInteractor::New();
   m_Interactor->LoadStateMachine(m_StateMachineFilename, us::ModuleRegistry::GetModule("MitkUS"));
   m_Interactor->SetEventConfig("globalConfig.xml");
 
   m_NodeDisplacementFilter->ConnectTo(this->GetCombinedModality()->GetNavigationDataSource());
   m_NodeDisplacementFilter->SelectInput(1);//m_ReferenceSensorIndex
 
   //target selection is optional
   if (m_targetSelectionOptional) { emit SignalReadyForNextStep(); }
 
   return true;
 }
 
 bool QmitkUSNavigationStepTumourSelection::OnDeactivateStep()
 {
-  m_Interactor->SetDataNode(0);
+  m_Interactor->SetDataNode(nullptr);
 
   bool value;
   if (m_TumourNode.IsNotNull() && !(m_TumourNode->GetBoolProperty("zone.created", value) && value))
   {
-    m_TumourNode->SetData(0);
+    m_TumourNode->SetData(nullptr);
   }
 
   // make sure that imaging isn't freezed anymore
   ui->freezeImageButton->Unfreeze();
 
   return true;
 }
 
 void QmitkUSNavigationStepTumourSelection::OnUpdate()
 {
   if (m_NavigationDataSource.IsNull()) { return; }
 
   m_NavigationDataSource->Update();
   m_NodeDisplacementFilter->Update();
 
   bool valid = m_NavigationDataSource->GetOutput(m_ReferenceSensorIndex)->IsDataValid();
 
   if (valid)
   {
     ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
       "background-color: #8bff8b; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
     ui->bodyMarkerTrackingStatusLabel->setText("Body marker is inside the tracking volume.");
   }
   else
   {
     ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
       "background-color: #ff7878; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
     ui->bodyMarkerTrackingStatusLabel->setText("Body marker is not inside the tracking volume.");
   }
 
   ui->freezeImageButton->setEnabled(valid);
 
   bool created;
   if (m_TumourNode.IsNull() || !m_TumourNode->GetBoolProperty("zone.created", created) || !created)
   {
     ui->tumourSearchExplanationLabel->setEnabled(valid);
   }
 }
 
 void QmitkUSNavigationStepTumourSelection::OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode)
 {
   if (settingsNode.IsNull()) { return; }
 
   float securityDistance;
   if (settingsNode->GetFloatProperty("settings.security-distance", securityDistance))
   {
     m_SecurityDistance = securityDistance;
   }
 
   std::string stateMachineFilename;
   if (settingsNode->GetStringProperty("settings.interaction-concept", stateMachineFilename) && stateMachineFilename != m_StateMachineFilename)
   {
     m_StateMachineFilename = stateMachineFilename;
     m_Interactor->LoadStateMachine(stateMachineFilename, us::ModuleRegistry::GetModule("MitkUS"));
   }
 
   std::string referenceSensorName;
   if (settingsNode->GetStringProperty("settings.reference-name-selected", referenceSensorName))
   {
     m_ReferenceSensorName = referenceSensorName;
   }
 
   this->UpdateReferenceSensorName();
 }
 
 QString QmitkUSNavigationStepTumourSelection::GetTitle()
 {
   return "Localisation of Tumour Position";
 }
 
 QmitkUSAbstractNavigationStep::FilterVector QmitkUSNavigationStepTumourSelection::GetFilter()
 {
   return FilterVector(1, m_NodeDisplacementFilter.GetPointer());
 }
 
 void QmitkUSNavigationStepTumourSelection::OnFreeze(bool freezed)
 {
   if (freezed) this->GetCombinedModality()->SetIsFreezed(true);
 
   ui->tumourSelectionExplanation1Label->setEnabled(freezed);
   ui->tumourSelectionExplanation2Label->setEnabled(freezed);
 
   if (freezed)
   {
     if (!m_TumourNode->GetData())
     {
       // load state machine and event config for data interactor
       m_Interactor->LoadStateMachine(m_StateMachineFilename, us::ModuleRegistry::GetModule("MitkUS"));
       m_Interactor->SetEventConfig("globalConfig.xml");
 
       m_Interactor->SetDataNode(m_TumourNode);
       // feed reference pose to node displacement filter
       m_NodeDisplacementFilter->SetInitialReferencePose(this->GetCombinedModality()->GetNavigationDataSource()->GetOutput(m_ReferenceSensorIndex)->Clone());
     }
   }
   else
   {
     bool value;
     if (m_TumourNode->GetBoolProperty("zone.created", value) && value)
     {
       ui->freezeImageButton->setEnabled(false);
       ui->tumourSearchExplanationLabel->setEnabled(false);
     }
   }
 
   if (!freezed) this->GetCombinedModality()->SetIsFreezed(false);
 }
 
 void QmitkUSNavigationStepTumourSelection::OnSetCombinedModality()
 {
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetCombinedModality(false);
   if (combinedModality.IsNotNull())
   {
     m_NavigationDataSource = combinedModality->GetNavigationDataSource();
   }
   else
   {
-    m_NavigationDataSource = 0;
+    m_NavigationDataSource = nullptr;
   }
 
   ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex);
 
   this->UpdateReferenceSensorName();
 }
 
 void QmitkUSNavigationStepTumourSelection::OnTumourSizeChanged(int size)
 {
   m_TumourNode->SetFloatProperty("zone.size", static_cast<float>(size));
   mitk::USZonesInteractor::UpdateSurface(m_TumourNode);
 
   MITK_INFO("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepTumourSelection")
     << "Changing tumour radius to " << size << ".";
 }
 
 void QmitkUSNavigationStepTumourSelection::OnDeleteButtonClicked()
 {
   this->OnRestartStep();
 }
 
 void QmitkUSNavigationStepTumourSelection::TumourNodeChanged(const mitk::DataNode* dataNode)
 {
   // only changes of tumour node are of interest
   if (dataNode != m_TumourNode) { return; }
 
   float size;
   dataNode->GetFloatProperty("zone.size", size);
 
   ui->tumourSizeSlider->setValue(static_cast<int>(size));
 
   bool created;
   if (dataNode->GetBoolProperty("zone.created", created) && created)
   {
     if (ui->freezeImageButton->isChecked())
     {
       m_NodeDisplacementFilter->AddNode(const_cast<mitk::DataNode*>(dataNode));
 
       m_TargetSurfaceNode->SetData(this->CreateTargetSurface());
       m_NodeDisplacementFilter->AddNode(m_TargetSurfaceNode);
 
       MITK_INFO("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepTumourSelection")
         << "Tumour created with center " << dataNode->GetData()->GetGeometry()->GetOrigin()
         << " and radius " << size << ".";
 
       mitk::DataNode::Pointer tumourResultNode = mitk::DataNode::New();
       tumourResultNode->SetName("TumourResult");
       tumourResultNode->SetProperty("USNavigation::TumourCenter",
         mitk::Point3dProperty::New(dataNode->GetData()->GetGeometry()->GetOrigin()));
       tumourResultNode->SetProperty("USNavigation::TumourRadius", mitk::DoubleProperty::New(size));
 
       emit SignalIntermediateResult(tumourResultNode);
 
       ui->freezeImageButton->Unfreeze();
     }
 
     ui->tumourSearchExplanationLabel->setEnabled(false);
     ui->tumourSizeExplanationLabel->setEnabled(true);
     ui->tumourSizeLabel->setEnabled(true);
     ui->tumourSizeSlider->setEnabled(true);
     ui->deleteTumourButton->setEnabled(true);
 
     emit SignalReadyForNextStep();
   }
 }
 
 mitk::Surface::Pointer QmitkUSNavigationStepTumourSelection::CreateTargetSurface()
 {
   mitk::Surface::Pointer tumourSurface = dynamic_cast<mitk::Surface*>(m_TumourNode->GetData());
 
   if (tumourSurface.IsNull())
   {
     MITK_WARN << "No target selected, cannot create surface!";
     return mitk::Surface::New(); //return a empty surface in this case...
   }
 
   // make a deep copy of the tumour surface polydata
   vtkSmartPointer<vtkPolyData> tumourSurfaceVtk = vtkSmartPointer<vtkPolyData>::New();
   tumourSurfaceVtk->DeepCopy(tumourSurface->GetVtkPolyData());
 
   // create scalars for moving every point the same size onto its normal vector
   vtkSmartPointer<vtkDoubleArray> scalars = vtkSmartPointer<vtkDoubleArray>::New();
   int numberOfPoints = tumourSurfaceVtk->GetNumberOfPoints();
   scalars->SetNumberOfTuples(numberOfPoints);
 
   // set scalars for warp filter
   for (vtkIdType i = 0; i < numberOfPoints; ++i) { scalars->SetTuple1(i, m_SecurityDistance * 10); }
   tumourSurfaceVtk->GetPointData()->SetScalars(scalars);
 
   vtkSmartPointer<vtkWarpScalar> warpScalar = vtkSmartPointer<vtkWarpScalar>::New();
   warpScalar->SetInputData(tumourSurfaceVtk);
   warpScalar->SetScaleFactor(1); // use the scalars themselves
   warpScalar->Update();
   vtkSmartPointer<vtkPolyData> targetSurfaceVtk = warpScalar->GetPolyDataOutput();
 
   // set the moved points to the deep copied tumour surface; this is
   // necessary as setting the targetSurfaceVtk as polydata for the
   // targetSurface would result in flat shading for the surface (seems
   // to be a bug in MITK or VTK)
   tumourSurfaceVtk->SetPoints(targetSurfaceVtk->GetPoints());
 
   mitk::Surface::Pointer targetSurface = mitk::Surface::New();
   targetSurface->SetVtkPolyData(tumourSurfaceVtk);
   targetSurface->GetGeometry()->SetOrigin(tumourSurface->GetGeometry()->GetOrigin());
 
   return targetSurface;
 }
 
 itk::SmartPointer<mitk::NodeDisplacementFilter> QmitkUSNavigationStepTumourSelection::GetTumourNodeDisplacementFilter()
 {
   return m_NodeDisplacementFilter;
 }
 
 void QmitkUSNavigationStepTumourSelection::UpdateReferenceSensorName()
 {
   if (m_NavigationDataSource.IsNull()) { return; }
 
   if (!m_ReferenceSensorName.empty())
   {
     try
     {
       m_ReferenceSensorIndex = m_NavigationDataSource->GetOutputIndex(m_ReferenceSensorName);
     }
     catch (const std::exception &e)
     {
       MITK_WARN("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepTumourSelection")
         << "Cannot get index for reference sensor name: " << e.what();
     }
   }
 
   if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active)
   {
     MITK_INFO << "############### " << m_NodeDisplacementFilter->GetNumberOfIndexedInputs();
     m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex);
   }
 
   ui->freezeImageButton->SetCombinedModality(this->GetCombinedModality(false), m_ReferenceSensorIndex);
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.h
index 5d48b063e0..f41b3d8fb0 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.h
@@ -1,168 +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.
 
 ===================================================================*/
 
 #ifndef QMITKUSNAVIGATIONSTEPTUMOURSELECTION_H
 #define QMITKUSNAVIGATIONSTEPTUMOURSELECTION_H
 
 #include "QmitkUSAbstractNavigationStep.h"
 
 namespace itk {
 template<class T> class SmartPointer;
 }
 
 namespace mitk {
 class NavigationDataSource;
 class DataStorage;
 class DataNode;
 class USZonesInteractor;
 class NodeDisplacementFilter;
 class Surface;
 }
 
 namespace Ui {
 class QmitkUSNavigationStepTumourSelection;
 }
 
 class USNavigationMarkerPlacement;
 class QmitkUSNavigationStepCombinedModality;
 
 /**
  * \brief Navigation step for marking the tumor position and extent.
  * The user can mark the position by interacting with the render windows. The
  * tumor size can be changed afterwards and the tumor can be removed.
  */
 class QmitkUSNavigationStepTumourSelection : public QmitkUSAbstractNavigationStep
 {
   Q_OBJECT
 
 protected slots:
   /**
    * \brief Activates or deactivates the ineractor for tumour creation.
    */
   void OnFreeze(bool freezed);
 
   /**
    * \brief Updates the surface of the tumor node according to the new size.
    */
   void OnTumourSizeChanged(int);
 
   /**
    * \brief Just restarts the navigation step for deleting the tumour.
    */
   void OnDeleteButtonClicked();
 
 public:
-  explicit QmitkUSNavigationStepTumourSelection(QWidget* parent = 0);
+  explicit QmitkUSNavigationStepTumourSelection(QWidget* parent = nullptr);
   ~QmitkUSNavigationStepTumourSelection() override;
 
   void SetTargetSelectionOptional (bool t);
 
   /**
    * \brief Initializes tumour and target surface.
    * \return always true
    */
   bool OnStartStep() override;
 
   /**
    * \brief Removes target surface and tumour node from the data storage.
    * Additionally an unfreeze is done and the node displacement filter is
    * resetted.
    * \return always true
    */
   bool OnStopStep() override;
 
   /**
    * \brief Reinitializes buttons and sliders in addition of calling the default implementation.
    * \return result of the superclass implementation
    */
   bool OnRestartStep() override;
 
   /**
    * \brief (Re)creates the target surface.
    * \return always true
    */
   bool OnFinishStep() override;
 
   /**
    * \brief Initializes (but not activates) the interactor for tumour selection.
    * \return always true
    */
   bool OnActivateStep() override;
 
   /**
    * \brief Deactivates the interactor for tumour selection
    * and removes data of the tumour node if selection wasn't finished yet.
    *
    * \return always true
    */
   bool OnDeactivateStep() override;
 
   /**
    * \brief Updates tracking validity status and checks tumour node for the end of tumour creation.
    */
   void OnUpdate() override;
 
   /**
    * The properties "settings.security-distance" and
    * "settings.interaction-concept" are used.
    */
   void OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode) override;
 
   QString GetTitle() override;
 
   /**
    * @return a node displacement filter for tumour and target surfaces
    */
   FilterVector GetFilter() override;
 
   void SetTumorColor(mitk::Color c);
 
   /** @return Returns the current NodeDisplacementFilter which ist used for updating the targets pose. */
   itk::SmartPointer<mitk::NodeDisplacementFilter> GetTumourNodeDisplacementFilter();
 
 protected:
   void OnSetCombinedModality() override;
 
   void TumourNodeChanged(const mitk::DataNode*);
   itk::SmartPointer<mitk::Surface> CreateTargetSurface();
 
   void UpdateReferenceSensorName();
 
   itk::SmartPointer<mitk::NavigationDataSource>   m_NavigationDataSource;
 
   bool m_targetSelectionOptional;
 
   float                                           m_SecurityDistance;
 
   itk::SmartPointer<mitk::USZonesInteractor>      m_Interactor;
   itk::SmartPointer<mitk::DataNode>               m_TumourNode;
   itk::SmartPointer<mitk::DataNode>               m_TargetSurfaceNode;
 
   itk::SmartPointer<mitk::NodeDisplacementFilter> m_NodeDisplacementFilter;
 
   std::string                                     m_StateMachineFilename;
   std::string                                     m_ReferenceSensorName;
   unsigned int                                    m_ReferenceSensorIndex;
 
   mitk::Color                                     m_SphereColor;
 
 private:
   mitk::MessageDelegate1<QmitkUSNavigationStepTumourSelection, const mitk::DataNode*> m_ListenerChangeNode;
 
   Ui::QmitkUSNavigationStepTumourSelection *ui;
 };
 
 #endif // QMITKUSNAVIGATIONSTEPTUMOURSELECTION_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h
index 2aed3668a0..ce68c06865 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h
@@ -1,134 +1,134 @@
 /*===================================================================
 
 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 QMITKUSNAVIGATIONSTEPZONEMARKING_H
 #define QMITKUSNAVIGATIONSTEPZONEMARKING_H
 
 #include "QmitkUSAbstractNavigationStep.h"
 
 namespace itk {
 template<class T> class SmartPointer;
 }
 
 namespace mitk {
 class NodeDisplacementFilter;
 class NavigationDataSource;
 }
 
 namespace Ui {
 class QmitkUSNavigationStepZoneMarking;
 }
 
 /**
  * \brief Navigation step for marking risk structures.
  * The user can add risk structures by interacting with the render windows. The
  * risk structures are organized in an embedded table view.
  *
  * The risk structures are stored under DATANAME_BASENODE -> DATANAME_ZONES.
  *
  * This step is ready for the next step directly after activating. All actions
  * to be done in this step are optional.
  */
 class QmitkUSNavigationStepZoneMarking : public QmitkUSAbstractNavigationStep
 {
   Q_OBJECT
 
 protected slots:
   void OnFreeze(bool freezed);
 
   /**
    * \brief Triggered when a risk zone was added.
    * Adds the zone to a member variable and to the node displacement filter.
    */
   void OnZoneAdded();
 
   /**
    * \brief Triggered when a risk zone was removed.
    * Removes the zone from a member variable and from the node displacement
    * filter.
    */
   void OnZoneRemoved();
 
   void OnShowListClicked(int state);
 
 public:
-  explicit QmitkUSNavigationStepZoneMarking(QWidget *parent = 0);
+  explicit QmitkUSNavigationStepZoneMarking(QWidget *parent = nullptr);
   ~QmitkUSNavigationStepZoneMarking() override;
 
   /**
    * \brief Initialization of the data storage nodes.
    * \return always true
    */
   bool OnStartStep() override;
 
   /**
    * \brief Resets widget and filter and removes nodes from the data storage.
    * \return always true
    */
   bool OnStopStep() override;
 
   /**
    * \brief There is nothing to be done.
    * \return always true
    */
   bool OnFinishStep() override;
 
   /**
    * \brief Selects input for the node displacement filter and emits "ReadyForNextStep" signal.
    * The input selection cannot be done earlier.
    * \return
    */
   bool OnActivateStep() override;
 
   bool OnDeactivateStep() override;
 
   /**
    * \brief Updates just the tracking validity status.
    */
   void OnUpdate() override;
 
   /**
    * The property "settings.interaction-concept" is used.
    */
   void OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode) override;
 
   QString GetTitle() override;
 
   /**
    * @return a node displacement filter for the zone surfaces
    */
   FilterVector GetFilter() override;
 
 protected:
   void OnSetCombinedModality() override;
 
   void UpdateReferenceSensorName();
 
   itk::SmartPointer<mitk::NavigationDataSource>   m_NavigationDataSource;
   itk::SmartPointer<mitk::NodeDisplacementFilter> m_ZoneDisplacementFilter;
   std::vector<itk::SmartPointer<mitk::DataNode> > m_ZoneNodes;
 
   std::string                                     m_StateMachineFilename;
   std::string                                     m_ReferenceSensorName;
   unsigned int                                    m_ReferenceSensorIndex;
 
   bool                                            m_CurrentlyAddingZone;
 
 private:
   Ui::QmitkUSNavigationStepZoneMarking *ui;
 };
 
 #endif // QMITKUSNAVIGATIONSTEPZONEMARKING_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationRemoveDelegate.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationRemoveDelegate.h
index 5883a2c9a9..446534a8cc 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationRemoveDelegate.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationRemoveDelegate.h
@@ -1,38 +1,38 @@
 /*===================================================================
 
 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 QMITKUSNAVIGATIONCALIBRATIONREMOVEDELEGATE_H
 #define QMITKUSNAVIGATIONCALIBRATIONREMOVEDELEGATE_H
 
 #include <QStyledItemDelegate>
 
 /**
  * \brief QStyledItemDelegate that provides a QColorDialog as editor.
  */
 class QmitkUSNavigationCalibrationRemoveDelegate : public QStyledItemDelegate
 {
   Q_OBJECT
 
 public:
-  explicit QmitkUSNavigationCalibrationRemoveDelegate(QObject* parent = 0);
+  explicit QmitkUSNavigationCalibrationRemoveDelegate(QObject* parent = nullptr);
   ~QmitkUSNavigationCalibrationRemoveDelegate() override;
 
   /**
    * \brief A QColorDialog is opened on double click events.
    */
   bool editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index) override;
 };
 
 #endif // QMITKUSNAVIGATIONCALIBRATIONREMOVEDELEGATE_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationUpdateDepthDelegate.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationUpdateDepthDelegate.h
index c4ffd61f2b..3088ea6354 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationUpdateDepthDelegate.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationUpdateDepthDelegate.h
@@ -1,48 +1,48 @@
 /*===================================================================
 
 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 QMITKUSNAVIGATIONCALIBRATIONUPDATEDEPTHDELEGATE_H
 #define QMITKUSNAVIGATIONCALIBRATIONUPDATEDEPTHDELEGATE_H
 
 #include <QStyledItemDelegate>
 
 #include <mitkUSControlInterfaceBMode.h>
 
 /**
  * \brief QStyledItemDelegate that changes the current depth of the ultasound image on double click.
  */
 class QmitkUSNavigationCalibrationUpdateDepthDelegate : public QStyledItemDelegate
 {
   Q_OBJECT
 
 public:
-  explicit QmitkUSNavigationCalibrationUpdateDepthDelegate(QObject* parent = 0);
+  explicit QmitkUSNavigationCalibrationUpdateDepthDelegate(QObject* parent = nullptr);
   ~QmitkUSNavigationCalibrationUpdateDepthDelegate() override;
 
   void SetControlInterfaceBMode(mitk::USControlInterfaceBMode::Pointer controlInterfaceBMode);
 
   /**
    * \brief The depth of the b mode ultrasound is changed on double click.
    * A mitk::USControlInterfaceBMode has to be set before by calling
    * SetControlInterfaceBMode(). If no control interface was set (or it is
    * null) the QEvent gets ignored.
    */
   bool editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index) override;
 
 private:
   mitk::USControlInterfaceBMode::Pointer m_ControlInterfaceBMode;
 };
 
 #endif // QMITKUSNAVIGATIONCALIBRATIONUPDATEDEPTHDELEGATE_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationsDataModel.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationsDataModel.h
index cf54122edb..995c1f0b0d 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationsDataModel.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationsDataModel.h
@@ -1,74 +1,74 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QMITKUSNAVIGATIONCALIBRATIONSDATAMODEL_H
 #define QMITKUSNAVIGATIONCALIBRATIONSDATAMODEL_H
 
 #include <QAbstractTableModel>
 
 #include <mitkMessage.h>
 #include <itkSmartPointer.h>
 
 namespace mitk {
   class AbstractUltrasoundTrackerDevice;
   class USControlInterfaceBMode;
   class USControlInterfaceProbes;
 }
 
 class QmitkUSNavigationCalibrationsDataModel : public QAbstractTableModel
 {
   Q_OBJECT
 
 public:
-  explicit QmitkUSNavigationCalibrationsDataModel(QObject *parent = 0);
+  explicit QmitkUSNavigationCalibrationsDataModel(QObject *parent = nullptr);
   ~QmitkUSNavigationCalibrationsDataModel() override;
 
   void SetCombinedModality(itk::SmartPointer<mitk::AbstractUltrasoundTrackerDevice> combinedModality);
 
   void OnDeviceChanged(const std::string&, const std::string&);
 
   /** \brief Return number of rows of the model. */
   int rowCount ( const QModelIndex & parent = QModelIndex() ) const override;
 
   /** \brief Return number of columns (3) of the model. */
   int columnCount ( const QModelIndex & parent = QModelIndex() ) const override;
 
   /** \brief Return names for the columns, numbers for the rows and invalid for DisplayRole. */
   QVariant headerData ( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const override;
 
   /** \brief Return selectable and enabled for column 1 (size); selectable, enabled and editable for every other column. */
   Qt::ItemFlags flags ( const QModelIndex & index ) const override;
 
   /** \brief Return model data of the selected cell. */
   QVariant data ( const QModelIndex & index, int role = Qt::DisplayRole ) const override;
 
   /** \brief Set model data for the selected cell. */
   bool setData ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole ) override;
 
   using QAbstractTableModel::removeRows;
   /** \brief Remove given rows from the model.
    *  \param removeFromDataStorage zone nodes are removed from the data storage too, if this is set to true
    */
   virtual bool removeRows ( int row, int count, const QModelIndex& parent, bool removeFromDataStorage );
 
 private:
   itk::SmartPointer<mitk::AbstractUltrasoundTrackerDevice>       m_CombinedModality;
   itk::SmartPointer<mitk::USControlInterfaceBMode>  m_ControlInterfaceBMode;
 
   mitk::MessageDelegate2<QmitkUSNavigationCalibrationsDataModel, const std::string&, const std::string&> m_ListenerDeviceChanged;
 };
 
 #endif // QMITKUSNAVIGATIONCALIBRATIONSDATAMODEL_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationMarkerPlacement.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationMarkerPlacement.cpp
index 65a4152199..54a8e352d3 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationMarkerPlacement.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationMarkerPlacement.cpp
@@ -1,830 +1,830 @@
 /*===================================================================
 
 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 "QmitkUSNavigationMarkerPlacement.h"
 #include "ui_QmitkUSNavigationMarkerPlacement.h"
 
 #include "NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.h"
 #include "NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h"
 #include "NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h"
 #include "NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.h"
 #include "NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.h"
 #include "NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h"
 
 #include "SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.h"
 
 #include "mitkAbstractUltrasoundTrackerDevice.h"
 #include "mitkIRenderingManager.h"
 #include "mitkNodeDisplacementFilter.h"
 #include "mitkTrackedUltrasound.h"
 #include <mitkIOUtil.h>
 
 #include "IO/mitkUSNavigationStepTimer.h"
 
 #include <QDateTime>
 #include <QDir>
 #include <QInputDialog>
 #include <QMessageBox>
 #include <QSignalMapper>
 #include <QTimer>
 
 #include "QmitkRenderWindow.h"
 #include "QmitkStdMultiWidget.h"
 #include "QmitkStdMultiWidgetEditor.h"
 #include "mitkCameraController.h"
 #include "mitkLayoutAnnotationRenderer.h"
 #include <vtkSmartPointer.h>
 
 // scene serialization
 #include <mitkConvert2Dto3DImageFilter.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkSceneIO.h>
 #include <mitkSurface.h>
 
 const std::string QmitkUSNavigationMarkerPlacement::VIEW_ID = "org.mitk.views.usmarkerplacement";
 
 const char *QmitkUSNavigationMarkerPlacement::DATANAME_TUMOUR = "Tumour";
 const char *QmitkUSNavigationMarkerPlacement::DATANAME_TARGETSURFACE = "Target Surface";
 const char *QmitkUSNavigationMarkerPlacement::DATANAME_ZONES = "Zones";
 const char *QmitkUSNavigationMarkerPlacement::DATANAME_TARGETS = "Targets";
 const char *QmitkUSNavigationMarkerPlacement::DATANAME_TARGETS_PATHS = "Target Paths";
 const char *QmitkUSNavigationMarkerPlacement::DATANAME_REACHED_TARGETS = "Reached Targets";
 
 QmitkUSNavigationMarkerPlacement::QmitkUSNavigationMarkerPlacement()
   : m_Parent(nullptr),
     m_UpdateTimer(new QTimer(this)),
     m_ImageAndNavigationDataLoggingTimer(new QTimer(this)),
     m_StdMultiWidget(nullptr),
     m_CombinedModality(nullptr),
     m_ReinitAlreadyDone(false),
     m_IsExperimentRunning(false),
     m_CurrentApplicationName(),
     m_NavigationStepTimer(mitk::USNavigationStepTimer::New()),
     m_IconRunning(QPixmap(":/USNavigation/record.png")),
     m_IconNotRunning(QPixmap(":/USNavigation/record-gray.png")),
     m_ResultsDirectory(),
     m_ExperimentName(),
     m_ExperimentResultsSubDirectory(),
     m_NavigationStepNames(),
     m_LoggingBackend(),
     m_USImageLoggingFilter(mitk::USImageLoggingFilter::New()),
     m_NavigationDataRecorder(mitk::NavigationDataRecorder::New()),
     m_TargetNodeDisplacementFilter(nullptr),
     m_AblationZonesDisplacementFilter(mitk::NodeDisplacementFilter::New()),
     m_ToolVisualizationFilter(nullptr),
     m_AblationZonesVector(),
     m_NeedleIndex(0),
     m_MarkerIndex(1),
     m_SceneNumber(1),
     m_WarnOverlay(mitk::TextAnnotation2D::New()),
     m_NavigationDataSource(nullptr),
     m_CurrentStorage(nullptr),
     m_ImageStreamNode(nullptr),
     ui(new Ui::QmitkUSNavigationMarkerPlacement)
 {
   connect(m_UpdateTimer, SIGNAL(timeout()), this, SLOT(OnTimeout()));
   connect(
     m_ImageAndNavigationDataLoggingTimer, SIGNAL(timeout()), this, SLOT(OnImageAndNavigationDataLoggingTimeout()));
 
   // scale running (and not running) icon the specific height
   m_IconRunning = m_IconRunning.scaledToHeight(20, Qt::SmoothTransformation);
   m_IconNotRunning = m_IconNotRunning.scaledToHeight(20, Qt::SmoothTransformation);
 
 
 }
 
 QmitkUSNavigationMarkerPlacement::~QmitkUSNavigationMarkerPlacement()
 {
   this->GetDataStorage()->Remove(m_InstrumentNode);
   delete ui;
 }
 
 void QmitkUSNavigationMarkerPlacement::OnChangeAblationZone(int id, int newSize)
 {
   if ((static_cast<int>(m_AblationZonesVector.size()) < id) || (id < 0))
   {
     return;
   }
 
   MITK_INFO << "Ablation Zone " << id << " changed, new size: " << newSize;
 
   // create a vtk sphere with given radius
   vtkSmartPointer<vtkSphereSource> vtkSphere = vtkSmartPointer<vtkSphereSource>::New();
   vtkSphere->SetRadius(newSize / 2);
   vtkSphere->SetCenter(0, 0, 0);
   vtkSphere->SetPhiResolution(20);
   vtkSphere->SetThetaResolution(20);
   vtkSphere->Update();
 
   mitk::Surface::Pointer zoneSurface = dynamic_cast<mitk::Surface *>(m_AblationZonesVector.at(id)->GetData());
   zoneSurface->SetVtkPolyData(vtkSphere->GetOutput());
 }
 
 void QmitkUSNavigationMarkerPlacement::OnAddAblationZone(int size)
 {
   m_AblationZonesDisplacementFilter->SetInitialReferencePose(
     m_CombinedModality->GetNavigationDataSource()->GetOutput(m_MarkerIndex));
   mitk::DataNode::Pointer NewAblationZone = mitk::DataNode::New();
 
   mitk::Point3D origin = m_CombinedModality->GetNavigationDataSource()->GetOutput(m_NeedleIndex)->GetPosition();
 
   MITK_INFO("USNavigationLogging") << "Ablation Zone Added, initial size: " << size << ", origin: " << origin;
 
   mitk::Surface::Pointer zone = mitk::Surface::New();
 
   // create a vtk sphere with given radius
   vtkSmartPointer<vtkSphereSource> vtkSphere = vtkSmartPointer<vtkSphereSource>::New();
   vtkSphere->SetRadius(size / 2);
   vtkSphere->SetCenter(0, 0, 0);
   vtkSphere->SetPhiResolution(20);
   vtkSphere->SetThetaResolution(20);
   vtkSphere->Update();
   zone->SetVtkPolyData(vtkSphere->GetOutput());
 
   // set vtk sphere and origin to data node (origin must be set
   // again, because of the new sphere set as data)
   NewAblationZone->SetData(zone);
   NewAblationZone->GetData()->GetGeometry()->SetOrigin(origin);
   mitk::Color SphereColor = mitk::Color();
   // default color
   SphereColor[0] = 102;
   SphereColor[1] = 0;
   SphereColor[2] = 204;
   NewAblationZone->SetColor(SphereColor);
   NewAblationZone->SetOpacity(0.3);
 
   // set name of zone
   std::stringstream name;
   name << "Ablation Zone" << m_AblationZonesVector.size();
   NewAblationZone->SetName(name.str());
 
   // add zone to filter
   m_AblationZonesDisplacementFilter->AddNode(NewAblationZone);
   m_AblationZonesVector.push_back(NewAblationZone);
   this->GetDataStorage()->Add(NewAblationZone);
 }
 
 void QmitkUSNavigationMarkerPlacement::CreateQtPartControl(QWidget *parent)
 {
   m_Parent = parent;
   ui->setupUi(parent);
 
   connect(ui->startExperimentButton, SIGNAL(clicked()), this, SLOT(OnStartExperiment()));
   connect(ui->finishExperimentButton, SIGNAL(clicked()), this, SLOT(OnFinishExperiment()));
   connect(ui->m_enableNavigationLayout, SIGNAL(clicked()), this, SLOT(OnChangeLayoutClicked()));
   connect(ui->m_RenderWindowSelection, SIGNAL(valueChanged(int)), this, SLOT(OnRenderWindowSelection()));
   connect(ui->m_RefreshView, SIGNAL(clicked()), this, SLOT(OnRefreshView()));
 
   m_BaseNode = this->GetDataStorage()->GetNamedNode(QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
   if (m_BaseNode.IsNull())
   {
     m_BaseNode = mitk::DataNode::New();
     m_BaseNode->SetName(QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
     this->GetDataStorage()->Add(m_BaseNode);
   }
 
   connect(ui->m_CtToUsRegistrationWidget, SIGNAL(GetCursorPosition()), this, SLOT(OnGetCursorPosition()));
   connect(ui->m_CtToUsRegistrationWidget, SIGNAL(ActualizeCtToUsRegistrationWidget()), this, SLOT(OnActualizeCtToUsRegistrationWidget()));
   connect(ui->m_initializeCtToUsRegistration, SIGNAL(clicked()), this, SLOT(OnInitializeCtToUsRegistration()));
   connect(ui->m_initializeTargetMarking, SIGNAL(clicked()), this, SLOT(OnInitializeTargetMarking()));
   connect(ui->m_initializeCritStructureMarking, SIGNAL(clicked()), this, SLOT(OnInitializeCriticalStructureMarking()));
   connect(ui->m_initializeNavigation, SIGNAL(clicked()), this, SLOT(OnInitializeNavigation()));
 
   // indicate that no experiment is running at start
   ui->runningLabel->setPixmap(m_IconNotRunning);
 
   connect(ui->m_settingsWidget,
           SIGNAL(SettingsChanged(itk::SmartPointer<mitk::DataNode>)),
           this,
           SLOT(OnSettingsChanged(itk::SmartPointer<mitk::DataNode>)));
 }
 
 void QmitkUSNavigationMarkerPlacement::ReInitializeSettingsNodesAndImageStream()
 {
   //If update timer is not stopped (signals stopped), setting the m_CombinedModality
   // will cause a crash of the workbench in some times.
   m_UpdateTimer->blockSignals(true);
   m_UpdateTimer->stop();
   m_SettingsNode = mitk::DataNode::New();
   ui->m_settingsWidget->OnSetSettingsNode(m_SettingsNode, true);
   InitImageStream();
   m_CombinedModality = ui->m_CombinedModalityCreationWidget->GetSelectedCombinedModality();
   // Having set the m_CombinedModality reactivate the update timer again
   m_UpdateTimer->start(50); // every 50 Milliseconds = 20 Frames/Second
   m_UpdateTimer->blockSignals(false);
 }
 
 void QmitkUSNavigationMarkerPlacement::OnGetCursorPosition()
 {
   mitk::Point3D centroid = this->GetRenderWindowPart()->GetSelectedPosition();
   ui->m_CtToUsRegistrationWidget->OnCalculateTRE(centroid);
 }
 
 void QmitkUSNavigationMarkerPlacement::OnActualizeCtToUsRegistrationWidget()
 {
   m_SettingsNode = mitk::DataNode::New();
   ui->m_settingsWidget->OnSetSettingsNode(m_SettingsNode, true);
   this->InitImageStream();
 
   if (ui->m_CombinedModalityCreationWidget->GetSelectedCombinedModality().IsNull())
   {
     return;
   }
   ui->m_CtToUsRegistrationWidget->SetCombinedModality(
     ui->m_CombinedModalityCreationWidget->GetSelectedCombinedModality());
 
   m_CombinedModality = ui->m_CombinedModalityCreationWidget->GetSelectedCombinedModality();
 
   if (!m_StdMultiWidget)
   {
     // try to get the standard multi widget if it couldn't be got before
     mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart();
 
     QmitkStdMultiWidgetEditor *multiWidgetEditor = dynamic_cast<QmitkStdMultiWidgetEditor *>(renderWindow);
 
     // if there is a standard multi widget now, disable the level window and
     // change the layout to 2D up and 3d down
     if (multiWidgetEditor)
     {
       m_StdMultiWidget = multiWidgetEditor->GetStdMultiWidget();
       SetTwoWindowView();
     }
   }
   else
   {
     this->OnRefreshView();
   }
   m_UpdateTimer->start(50); // every 50 Milliseconds = 20 Frames/Second
 }
 
 void QmitkUSNavigationMarkerPlacement::OnInitializeCtToUsRegistration()
 {
   ui->m_CtToUsRegistrationWidget->SetDataStorage(this->GetDataStorage());
   ui->m_CtToUsRegistrationWidget->OnSettingsChanged(m_SettingsNode);
   ui->m_CtToUsRegistrationWidget->OnActivateStep();
   ui->m_CtToUsRegistrationWidget->OnStartStep();
   ui->m_CtToUsRegistrationWidget->Update();
 }
 
 
 
 void QmitkUSNavigationMarkerPlacement::OnInitializeTargetMarking()
 {
   ReInitializeSettingsNodesAndImageStream();
   ui->m_TargetMarkingWidget->SetCombinedModality(m_CombinedModality);
   ui->m_TargetMarkingWidget->SetDataStorage(this->GetDataStorage());
   ui->m_TargetMarkingWidget->OnSettingsChanged(m_SettingsNode);
   ui->m_TargetMarkingWidget->OnActivateStep();
   ui->m_TargetMarkingWidget->OnStartStep();
   ui->m_TargetMarkingWidget->Update();
 }
 void QmitkUSNavigationMarkerPlacement::OnInitializeCriticalStructureMarking()
 {
   ReInitializeSettingsNodesAndImageStream();
   ui->m_CriticalStructuresWidget->SetCombinedModality(m_CombinedModality);
   ui->m_CriticalStructuresWidget->SetDataStorage(this->GetDataStorage());
   ui->m_CriticalStructuresWidget->OnSettingsChanged(m_SettingsNode);
   ui->m_CriticalStructuresWidget->OnActivateStep();
   ui->m_CriticalStructuresWidget->OnStartStep();
   ui->m_CriticalStructuresWidget->Update();
 }
 void QmitkUSNavigationMarkerPlacement::OnInitializeNavigation()
 {
   ReInitializeSettingsNodesAndImageStream();
   ui->m_NavigationWidget->SetCombinedModality(m_CombinedModality);
   ui->m_NavigationWidget->SetDataStorage(this->GetDataStorage());
   ui->m_NavigationWidget->OnSettingsChanged(m_SettingsNode);
   ui->m_NavigationWidget->OnActivateStep();
   ui->m_NavigationWidget->OnStartStep();
   ui->m_NavigationWidget->Update();
 
   // test if it is tracked US, if yes add visualization filter
   if (m_CombinedModality->GetIsTrackedUltrasoundActive())
   {
     m_InstrumentNode = mitk::DataNode::New();
     m_InstrumentNode->SetName("Tracked US Instrument");
     m_InstrumentNode->SetData(
       m_CombinedModality->GetNavigationDataSource()->GetToolMetaData(0)->GetToolSurface()->Clone());
     this->GetDataStorage()->Add(m_InstrumentNode);
     m_ToolVisualizationFilter = mitk::NavigationDataObjectVisualizationFilter::New();
     m_ToolVisualizationFilter->ConnectTo(m_CombinedModality->GetNavigationDataSource());
     m_ToolVisualizationFilter->SetRepresentationObject(0, m_InstrumentNode->GetData()); //caution: currently hard coded that instrument has id 0
     //set dummy objects to avoid spamming of console
     mitk::Surface::Pointer dummyObject = mitk::Surface::New();
     m_ToolVisualizationFilter->SetRepresentationObject(1, dummyObject);
     m_ToolVisualizationFilter->SetRepresentationObject(2, dummyObject);
 
   }
 }
 
 void QmitkUSNavigationMarkerPlacement::InitImageStream()
 {
   if (m_ImageStreamNode.IsNull())
   {
     m_ImageStreamNode = mitk::DataNode::New();
     m_ImageStreamNode->SetName("US Navigation Viewing Stream");
     this->GetDataStorage()->Add(m_ImageStreamNode);
   }
 }
 
 void QmitkUSNavigationMarkerPlacement::OnCombinedModalityPropertyChanged(const std::string &key, const std::string &)
 {
   if (key == mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH)
   {
     m_ReinitAlreadyDone = false;
     this->ReinitOnImage();
 
     if (m_CombinedModality.IsNotNull() && !m_CombinedModality->GetIsCalibratedForCurrentStatus())
     {
       mitk::LayoutAnnotationRenderer::AddAnnotation(
         m_WarnOverlay.GetPointer(), "stdmulti.widget1", mitk::LayoutAnnotationRenderer::TopLeft);
       MITK_WARN << "No calibration available for the selected ultrasound image depth.";
     }
   }
 }
 
 void QmitkUSNavigationMarkerPlacement::SetFocus()
 {
   this->ReinitOnImage();
 }
 
 void QmitkUSNavigationMarkerPlacement::OnTimeout()
 {
   if (m_CombinedModality.IsNull())
     return;
   m_CombinedModality->Modified(); // shouldn't be nessecary ... fix in abstract ultrasound tracker device!
   m_CombinedModality->Update();
   if (m_ToolVisualizationFilter.IsNotNull())
   {
     m_ToolVisualizationFilter->Update();
   }
 
   ui->m_CtToUsRegistrationWidget->Update();
   ui->m_TargetMarkingWidget->Update();
   ui->m_CriticalStructuresWidget->Update();
   ui->m_NavigationWidget->Update();
 
   mitk::Image::Pointer image = m_CombinedModality->GetOutput();
   // make sure that always the current image is set to the data node
   if (image.IsNotNull() && m_ImageStreamNode->GetData() != image.GetPointer() && image->IsInitialized())
   {
     m_ImageStreamNode->SetData(image);
   }
 
   if (!m_StdMultiWidget)
   {
     // try to get the standard multi widget if it couldn't be got before
     mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart();
 
     QmitkStdMultiWidgetEditor *multiWidgetEditor = dynamic_cast<QmitkStdMultiWidgetEditor *>(renderWindow);
 
     // if there is a standard multi widget now, disable the level window and
     // change the layout to 2D up and 3d down
     if (multiWidgetEditor)
     {
       m_StdMultiWidget = multiWidgetEditor->GetStdMultiWidget();
       SetTwoWindowView();
     }
 
     this->CreateOverlays();
   }
 
   if (m_CombinedModality.IsNotNull() && !this->m_CombinedModality->GetIsFreezed()) // if the combined modality is freezed: do nothing
   {
     m_AblationZonesDisplacementFilter->Update();
 
     // update the 3D window only every fourth time to speed up the rendering (at least in 2D)
     this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
 
     // make sure that a reinit was performed on the image
     this->ReinitOnImage();
   }
 }
 
 void QmitkUSNavigationMarkerPlacement::OnEnableNavigationLayout()
 {
   MITK_INFO << "Navigation Layout";
   // try to get the standard multi widget if it couldn't be got before
   mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart();
 
   QmitkStdMultiWidgetEditor *multiWidgetEditor = dynamic_cast<QmitkStdMultiWidgetEditor *>(renderWindow);
 
   // if there is a standard multi widget now, disable the level window and
   // change the layout to 2D up and 3d down
   if (multiWidgetEditor)
   {
     m_StdMultiWidget = multiWidgetEditor->GetStdMultiWidget();
     SetTwoWindowView();
   }
 }
 
 void QmitkUSNavigationMarkerPlacement::OnRenderWindowSelection()
 {
   SetTwoWindowView();
 }
 
 void QmitkUSNavigationMarkerPlacement::OnRefreshView()
 {
   if (!ui->m_enableNavigationLayout->isChecked())
     OnResetStandardLayout();
   else
   {
     // Reinit the US Image Stream (this might be broken if there was a global reinit somewhere...)
     try
     {
       mitk::RenderingManager::GetInstance()->InitializeViews( // Reinit
         this
           ->GetDataStorage() // GetDataStorage
           ->GetNamedNode("US Viewing Stream - Image 0")
           ->GetData()
           ->GetTimeGeometry()); // GetNode
     }
     catch (...)
     {
       MITK_DEBUG << "No reinit possible";
     }
     SetTwoWindowView();
   }
 }
 
 void QmitkUSNavigationMarkerPlacement::SetTwoWindowView()
 {
   if (m_StdMultiWidget)
   {
     MITK_INFO << "m_StdMultiWidget exists and not null";
     m_StdMultiWidget->DisableStandardLevelWindow();
     int i, j, k;
     switch (this->ui->m_RenderWindowSelection->value())
     {
       case 1:
         mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))
           ->GetCameraController()
           ->SetViewToCaudal();
         i = 2;
         j = 3; // other windows
         k = 1;
         break;
       case 2:
         mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))
           ->GetCameraController()
           ->SetViewToSinister();
         i = 1;
         j = 3;
         k = 2;
         break;
       case 3:
         mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))
           ->GetCameraController()
           ->SetViewToAnterior();
         i = 2;
         j = 1;
         k = 3;
         break;
       default:
         return;
     }
     m_StdMultiWidget->changeLayoutTo2DUpAnd3DDown(k);
     ////Crosshair invisible in 3D view
     this->GetDataStorage()
       ->GetNamedNode("stdmulti.widget" + std::to_string(i) + ".plane")
       ->SetBoolProperty("visible",
                         false,
                         mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
     this->GetDataStorage()
       ->GetNamedNode("stdmulti.widget" + std::to_string(j) + ".plane")
       ->SetBoolProperty("visible",
                         false,
                         mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
     this->GetDataStorage()
       ->GetNamedNode("stdmulti.widget" + std::to_string(k) + ".plane")
       ->SetBoolProperty("visible",
                         true,
                         mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
     this->GetDataStorage()
       ->GetNamedNode("stdmulti.widget" + std::to_string(i) + ".plane")
       ->SetIntProperty("Crosshair.Gap Size", 0);
     this->GetDataStorage()
       ->GetNamedNode("stdmulti.widget" + std::to_string(j) + ".plane")
       ->SetIntProperty("Crosshair.Gap Size", 0);
   }
 }
 
 void QmitkUSNavigationMarkerPlacement::OnResetStandardLayout()
 {
   // reset render windows
   mitk::DataNode::Pointer widget1 = this->GetDataStorage()->GetNamedNode("stdmulti.widget1.plane");
   if (widget1.IsNotNull())
   {
     widget1->SetVisibility(true);
   }
   mitk::DataNode::Pointer widget2 = this->GetDataStorage()->GetNamedNode("stdmulti.widget2.plane");
   if (widget2.IsNotNull())
   {
     widget2->SetVisibility(true);
   }
   mitk::DataNode::Pointer widget3 = this->GetDataStorage()->GetNamedNode("stdmulti.widget3.plane");
   if (widget3.IsNotNull())
   {
     widget3->SetVisibility(true);
   }
   m_StdMultiWidget->changeLayoutToDefault();
 }
 
 void QmitkUSNavigationMarkerPlacement::OnChangeLayoutClicked()
 {
   if (ui->m_enableNavigationLayout->isChecked())
     OnEnableNavigationLayout();
   else
     OnResetStandardLayout();
 }
 
 void QmitkUSNavigationMarkerPlacement::OnImageAndNavigationDataLoggingTimeout()
 {
   // update filter for logging navigation data and ultrasound images
   if (m_CombinedModality.IsNotNull())
   {
     m_NavigationDataRecorder->Update();
     // get last messages for logging filer and store them
     std::vector<std::string> messages = m_LoggingBackend.GetNavigationMessages();
     std::string composedMessage = "";
     for (std::size_t i = 0; i < messages.size(); i++)
     {
       composedMessage += messages.at(i);
     }
     m_USImageLoggingFilter->AddMessageToCurrentImage(composedMessage);
     m_LoggingBackend.ClearNavigationMessages();
     // update logging filter
     m_USImageLoggingFilter->Update();
   }
 }
 
 void QmitkUSNavigationMarkerPlacement::OnStartExperiment()
 {
   // get name for the experiment by a QInputDialog
   bool ok;
   if (m_ExperimentName.isEmpty())
   { // default: current date
     m_ExperimentName = QString::number(QDateTime::currentDateTime().date().year()) + "_" +
                        QString::number(QDateTime::currentDateTime().date().month()) + "_" +
                        QString::number(QDateTime::currentDateTime().date().day()) + "_experiment_" +
                        QString::number(QDateTime::currentDateTime().time().hour()) + "." +
                        QString::number(QDateTime::currentDateTime().time().minute());
   }
   m_ExperimentName = QInputDialog::getText(
     m_Parent, QString("Experiment Name"), QString("Name of the Experiment"), QLineEdit::Normal, m_ExperimentName, &ok);
   MITK_INFO("USNavigationLogging") << "Experiment started: " << m_ExperimentName.toStdString();
   if (ok && !m_ExperimentName.isEmpty())
   {
     // display error message and call the function recursivly if a directory
     // with the given name already exists
     QDir experimentResultsDir(m_ResultsDirectory + QDir::separator() + m_ExperimentName);
     if (experimentResultsDir.exists())
     {
       QMessageBox::critical(
         m_Parent, "Results Directory Exists", "The result directory already exists.\nPlease choose an other name.");
       this->OnStartExperiment();
     }
     else
     {
       QDir(m_ResultsDirectory).mkdir(m_ExperimentName);
       m_ExperimentResultsSubDirectory = m_ResultsDirectory + QDir::separator() + m_ExperimentName;
 
       // experiment is running now
       ui->runningLabel->setPixmap(m_IconRunning);
 
       // (re)start timer for navigation step durations
       m_NavigationStepTimer->Reset();
       m_NavigationStepTimer->SetOutputFileName(
         QString(m_ExperimentResultsSubDirectory + QDir::separator() + QString("durations.cvs")).toStdString());
       m_NavigationStepTimer->SetActiveIndex(0, "Initialization");
 
       ui->finishExperimentButton->setEnabled(true);
       ui->startExperimentButton->setDisabled(true);
 
       // initialize and register logging backend
       QString loggingFilename = m_ExperimentResultsSubDirectory + QDir::separator() + "logging.txt";
       m_LoggingBackend.SetOutputFileName(loggingFilename.toStdString());
       mbilog::RegisterBackend(&m_LoggingBackend);
 
       // initialize and start navigation data recorder form xml recording
       m_NavigationDataRecorder->StartRecording();
 
       m_IsExperimentRunning = true;
 
       m_ImageAndNavigationDataLoggingTimer->start(1000);
     }
   }
 }
 
 void QmitkUSNavigationMarkerPlacement::OnFinishExperiment()
 {
   this->WaitCursorOn();
 
   MITK_INFO("USNavigationLogging") << "Experiment finished!";
   MITK_INFO("USNavigationLogging") << "Position/Orientation of needle tip: "
                                    << (dynamic_cast<mitk::NavigationData *>(
                                          m_CombinedModality->GetTrackingDeviceDataSource()->GetOutput(0)))
                                         ->GetPosition();
   MITK_INFO("USNavigationLogging")
     << "Position of target: " << m_TargetNodeDisplacementFilter->GetRawDisplacementNavigationData(0)->GetPosition();
   MITK_INFO("USNavigationLogging") << "Total duration: " << m_NavigationStepTimer->GetTotalDuration();
 
   m_ImageAndNavigationDataLoggingTimer->stop();
 
   ui->runningLabel->setPixmap(m_IconNotRunning);
 
   m_NavigationStepTimer->Stop();
 
   ui->finishExperimentButton->setDisabled(true);
   ui->startExperimentButton->setEnabled(true);
 
   MITK_INFO("USNavigationLogging") << "Writing logging data to " << m_ExperimentResultsSubDirectory.toStdString();
   //  save ultrasound images to the file system
   QDir(m_ExperimentResultsSubDirectory).mkdir("ImageStream");
   m_USImageLoggingFilter->Update();
   m_USImageLoggingFilter->SetImageFilesExtension(".jpg");
   m_USImageLoggingFilter->SaveImages(
     QString(m_ExperimentResultsSubDirectory + QDir::separator() + "ImageStream" + QDir::separator()).toStdString());
   m_USImageLoggingFilter = mitk::USImageLoggingFilter::New();
 
   m_NavigationDataRecorder->StopRecording();
 
   // Write data to csv and xml file
   mitk::IOUtil::Save(
     m_NavigationDataRecorder->GetNavigationDataSet(),
     (QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.xml").toStdString().c_str()));
   mitk::IOUtil::Save(
     m_NavigationDataRecorder->GetNavigationDataSet(),
     (QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.csv").toStdString().c_str()));
 
   // write logged navigation data messages to separate file
   std::stringstream csvNavigationMessagesFilename;
   csvNavigationMessagesFilename << m_ExperimentResultsSubDirectory.toStdString() << QDir::separator().toLatin1()
                                 << "CSVNavigationMessagesLogFile.csv";
   MITK_INFO("USNavigationLogging") << "Writing logged navigation messages to separate csv file: "
                                    << csvNavigationMessagesFilename.str();
   m_LoggingBackend.WriteCSVFileWithNavigationMessages(csvNavigationMessagesFilename.str());
 
   mbilog::UnregisterBackend(&m_LoggingBackend);
 
   m_IsExperimentRunning = false;
 
   m_ImageAndNavigationDataLoggingTimer->stop();
   m_CombinedModality = nullptr;
 
   // reset scene number for next experiment
   m_SceneNumber = 1;
 
   this->WaitCursorOff();
   MITK_INFO("USNavigationLogging") << "Finished!";
 }
 
 void QmitkUSNavigationMarkerPlacement::OnSettingsChanged(itk::SmartPointer<mitk::DataNode> settings)
 {
   // initialize gui according to the experiment mode setting
   bool experimentMode = false;
   settings->GetBoolProperty("settings.experiment-mode", experimentMode);
   ui->startExperimentButton->setVisible(experimentMode);
   ui->finishExperimentButton->setVisible(experimentMode);
   ui->runningLabel->setVisible(experimentMode);
   if (experimentMode && !m_IsExperimentRunning)
   {
     ui->runningLabel->setPixmap(m_IconNotRunning);
   }
   else if (!experimentMode)
   {
     if (m_IsExperimentRunning)
     {
       this->OnFinishExperiment();
     }
   }
 
   // get the results directory from the settings and use home directory if
   // there is no results directory configured
   std::string resultsDirectory;
   if (settings->GetStringProperty("settings.experiment-results-directory", resultsDirectory))
   {
     m_ResultsDirectory = QString::fromStdString(resultsDirectory);
   }
   else
   {
     m_ResultsDirectory = QDir::homePath();
   }
 
   // make sure that the results directory exists
   QDir resultsDirectoryQDir = QDir(m_ResultsDirectory);
   if (!resultsDirectoryQDir.exists())
   {
     resultsDirectoryQDir.mkpath(m_ResultsDirectory);
   }
 
   MITK_INFO("USNavigation") << "Results Directory: " << m_ResultsDirectory.toStdString();
 }
 
 void QmitkUSNavigationMarkerPlacement::ReinitOnImage()
 {
   if (!m_ReinitAlreadyDone && m_CombinedModality.IsNotNull())
   {
     // make sure that the output is already calibrated correctly
     // (if the zoom level was changed recently)
     m_CombinedModality->Modified();
     m_CombinedModality->Update();
 
     mitk::Image::Pointer image = m_CombinedModality->GetOutput();
     if (image.IsNotNull() && image->IsInitialized())
     {
       // make a reinit on the ultrasound image
       mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart();
-      if (renderWindow != NULL && image->GetTimeGeometry()->IsValid())
+      if (renderWindow != nullptr && image->GetTimeGeometry()->IsValid())
       {
         renderWindow->GetRenderingManager()->InitializeViews(
           image->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
         renderWindow->GetRenderingManager()->RequestUpdateAll();
       }
 
       this->RequestRenderWindowUpdate();
 
       m_ReinitAlreadyDone = true;
     }
   }
 }
 
 void QmitkUSNavigationMarkerPlacement::Convert2DImagesTo3D(mitk::DataStorage::SetOfObjects::ConstPointer nodes)
 {
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = nodes->Begin(); it != nodes->End(); ++it)
   {
     if (it->Value()->GetData() && strcmp(it->Value()->GetData()->GetNameOfClass(), "Image") == 0)
     {
       // convert image to 3d image if it is 2d at the moment
       mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(it->Value()->GetData());
       if (image.IsNotNull() && image->GetDimension() == 2 && !image->GetGeometry()->Is2DConvertable())
       {
         mitk::Convert2Dto3DImageFilter::Pointer convert2DTo3DImageFilter = mitk::Convert2Dto3DImageFilter::New();
         convert2DTo3DImageFilter->SetInput(image);
         convert2DTo3DImageFilter->Update();
         it->Value()->SetData(convert2DTo3DImageFilter->GetOutput());
       }
     }
   }
 }
 
 void QmitkUSNavigationMarkerPlacement::CreateOverlays()
 {
   // initialize warning overlay (and do not display it, yet)
   m_WarnOverlay->SetText("Warning: No calibration available for current depth.");
 
   // set position and font size for the text overlay
   // (nonesense postition as a layouter is used, but it ignored
   // the overlay without setting a position here)
   mitk::Point2D overlayPosition;
   overlayPosition.SetElement(0, -50.0f);
   overlayPosition.SetElement(1, -50.0f);
   m_WarnOverlay->SetPosition2D(overlayPosition);
   m_WarnOverlay->SetFontSize(22);
   m_WarnOverlay->SetColor(1, 0, 0); // overlay should be red
 }
 
 void QmitkUSNavigationMarkerPlacement::UpdateToolStorage()
 {
   if (m_NavigationDataSource.IsNull())
   {
     m_NavigationDataSource = m_CombinedModality->GetNavigationDataSource();
   }
   if (m_NavigationDataSource.IsNull())
   {
     MITK_WARN << "Found an invalid navigation data source object!";
   }
   us::ModuleContext *context = us::GetModuleContext();
   std::string id = m_NavigationDataSource->US_PROPKEY_ID;
   std::string filter = "(" + mitk::NavigationToolStorage::US_PROPKEY_SOURCE_ID + "=" + id + ")";
   // Get Storage
   std::vector<us::ServiceReference<mitk::NavigationToolStorage>> refs =
     context->GetServiceReferences<mitk::NavigationToolStorage>();
   m_CurrentStorage = context->GetService(refs.front());
 
   if (m_CurrentStorage.IsNull())
   {
     MITK_WARN << "Found an invalid storage object!";
   }
   else if (m_CurrentStorage->GetToolCount() !=
            m_NavigationDataSource->GetNumberOfOutputs()) // there is something wrong with the storage
   {
     MITK_WARN << "Found a tool storage, but it has not the same number of tools like the NavigationDataSource. This "
                  "storage won't be used because it isn't the right one.";
-    m_CurrentStorage = NULL;
+    m_CurrentStorage = nullptr;
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZoneManagementColorDialogDelegate.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZoneManagementColorDialogDelegate.h
index a2b3f05c34..0f80c62598 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZoneManagementColorDialogDelegate.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZoneManagementColorDialogDelegate.h
@@ -1,38 +1,38 @@
 /*===================================================================
 
 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 QMITKUSZONEMANAGEMENTCOLORDIALOGDELEGATE_H
 #define QMITKUSZONEMANAGEMENTCOLORDIALOGDELEGATE_H
 
 #include <QStyledItemDelegate>
 
 /**
  * \brief QStyledItemDelegate that provides a QColorDialog as editor.
  */
 class QmitkUSZoneManagementColorDialogDelegate : public QStyledItemDelegate
 {
   Q_OBJECT
 
 public:
-  explicit QmitkUSZoneManagementColorDialogDelegate(QObject* parent = 0);
+  explicit QmitkUSZoneManagementColorDialogDelegate(QObject* parent = nullptr);
   ~QmitkUSZoneManagementColorDialogDelegate() override;
 
   /**
    * \brief A QColorDialog is opened on double click events.
    */
   bool editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index) override;
 };
 
 #endif // QMITKUSZONEMANAGEMENTCOLORDIALOGDELEGATE_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZonesDataModel.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZonesDataModel.cpp
index c65029da61..8986193342 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZonesDataModel.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZonesDataModel.cpp
@@ -1,332 +1,332 @@
 /*===================================================================
 
 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 "QmitkUSZonesDataModel.h"
 
 #include <QBrush>
 
 #include "mitkMessage.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkNodePredicateSource.h"
 #include "Interactors/mitkUSZonesInteractor.h"
 
 QmitkUSZonesDataModel::QmitkUSZonesDataModel(QObject *parent) :
   QAbstractTableModel(parent),
   m_ListenerAddNode(this, &QmitkUSZonesDataModel::AddNode),
   m_ListenerChangeNode(this, &QmitkUSZonesDataModel::ChangeNode),
   m_ListenerRemoveNode(this, &QmitkUSZonesDataModel::RemoveNode)
 {
 }
 
 QmitkUSZonesDataModel::~QmitkUSZonesDataModel()
 {
   if ( m_DataStorage.IsNotNull() )
   {
     m_DataStorage->AddNodeEvent.RemoveListener(m_ListenerAddNode);
     m_DataStorage->ChangedNodeEvent.RemoveListener(m_ListenerChangeNode);
     m_DataStorage->InteractorChangedNodeEvent.RemoveListener(m_ListenerChangeNode);
     m_DataStorage->RemoveNodeEvent.RemoveListener(m_ListenerRemoveNode);
   }
 }
 
 void QmitkUSZonesDataModel::SetDataStorage(mitk::DataStorage::Pointer dataStorage, mitk::DataNode::Pointer baseNode)
 {
   m_DataStorage = dataStorage;
   m_BaseNode = baseNode;
 
   if ( m_DataStorage.IsNotNull() )
   {
     m_DataStorage->AddNodeEvent.AddListener(m_ListenerAddNode);
     m_DataStorage->RemoveNodeEvent.AddListener(m_ListenerRemoveNode);
     m_DataStorage->ChangedNodeEvent.AddListener(m_ListenerChangeNode);
     m_DataStorage->InteractorChangedNodeEvent.AddListener(m_ListenerChangeNode);
   }
 }
 
 void QmitkUSZonesDataModel::AddNode(const mitk::DataNode* node)
 {
   if ( m_DataStorage.IsNull() )
   {
     MITK_ERROR << "DataStorage has to be set before adding the first zone node.";
     mitkThrow() << "DataStorage has to be set before adding the first zone node.";
   }
 
   // do not add nodes, which aren't fully created yet
   bool boolValue;
   if ( ! (node->GetBoolProperty(mitk::USZonesInteractor::DATANODE_PROPERTY_CREATED, boolValue) && boolValue) )
   {
     return;
   }
 
   // get source node of given node and test if m_BaseNode is a source node
   mitk::DataStorage::SetOfObjects::ConstPointer sourceNodes = m_DataStorage->GetSources(node);
   mitk::DataStorage::SetOfObjects::ConstIterator baseNodeIt = sourceNodes->Begin();
   while ( baseNodeIt != sourceNodes->End() && baseNodeIt->Value() != m_BaseNode ) { ++baseNodeIt; }
 
   // only nodes below m_BaseNode should be added to the model
   if ( baseNodeIt == sourceNodes->End() ) { return; }
 
   int newRowIndex = this->rowCount();
   this->insertRow(newRowIndex);
   m_ZoneNodes.at(newRowIndex) = const_cast<mitk::DataNode*>(node);
 
   // get row of the changed node and emit signal that the data of this row changed
   emit dataChanged(this->index(newRowIndex, 0), this->index(newRowIndex, this->columnCount()));
 }
 
 void QmitkUSZonesDataModel::RemoveNode(const mitk::DataNode* node)
 {
   // find index of the given node in the nodes vector
   unsigned int index = 0;
   DataNodeVector::iterator current = m_ZoneNodes.begin();
   while (current != m_ZoneNodes.end())
   {
     if ( *current == node ) { break; }
     ++index;
     ++current;
   }
 
   // remove node from model if it was found
   if ( current != m_ZoneNodes.end() )
   {
     // remove node from the model and make sure that there will be no
     // recursive removing calls (as removing node from data storage inside
     // removeRows function will lead into another call of RemoveNode).
     this->removeRows(index, 1, QModelIndex(), false);
   }
 }
 
 void QmitkUSZonesDataModel::ChangeNode(const mitk::DataNode* node)
 {
   if ( static_cast<itk::SmartPointer<const mitk::DataNode> >(node).IsNull() ) { return; }
 
   DataNodeVector::iterator oldNodeIt = find (m_ZoneNodes.begin(), m_ZoneNodes.end(), node);
   if (oldNodeIt == m_ZoneNodes.end())
   {
     // if node was not added yet, but it's creation is finished -> add it now
     bool boolValue;
     if ( node->GetBoolProperty(mitk::USZonesInteractor::DATANODE_PROPERTY_CREATED, boolValue) && boolValue )
     {
       this->AddNode(node);
     }
 
     return;
   }
 
   // get row of the changed node and emit signal that the data of this row changed
   unsigned int row = oldNodeIt - m_ZoneNodes.begin();
   emit dataChanged(this->index(row, 0), this->index(row, this->columnCount()));
 }
 
 int QmitkUSZonesDataModel::rowCount ( const QModelIndex& /*parent*/ ) const
 {
   return m_ZoneNodes.size();
 }
 
 int QmitkUSZonesDataModel::columnCount ( const QModelIndex& /*parent*/ ) const
 {
   return 3;
 }
 
 QVariant QmitkUSZonesDataModel::headerData ( int section, Qt::Orientation orientation, int role ) const
 {
   if ( role != Qt::DisplayRole ) { return QVariant(QVariant::Invalid); }
 
   if ( orientation == Qt::Horizontal )
   {
     switch ( section )
     {
     case 0: return QVariant("Name");
     case 1: return QVariant("Size");
     case 2: return QVariant("Color");
     }
   }
   else
   {
     return QVariant(section+1);
   }
 
   return QVariant(QVariant::Invalid);
 }
 
 Qt::ItemFlags QmitkUSZonesDataModel::flags ( const QModelIndex& index ) const
 {
   if (index.column() == 1 || index.column() == 2) { return Qt::ItemIsSelectable | Qt::ItemIsEnabled; }
 
   return Qt::ItemIsSelectable |  Qt::ItemIsEditable | Qt::ItemIsEnabled;
 }
 
 QVariant QmitkUSZonesDataModel::data ( const QModelIndex& index, int role ) const
 {
   // make sure that row and column index fit data borders
   if (static_cast<unsigned int>(index.row()) >= m_ZoneNodes.size()
       || index.column() >= this->columnCount())
   {
     return QVariant(QVariant::Invalid);
   }
 
   mitk::DataNode::Pointer curNode = m_ZoneNodes.at(index.row());
 
   switch (role)
   {
   case Qt::BackgroundColorRole:
   {
     float color[3];
     if ( curNode->GetColor(color) )
     {
       QColor qColor(color[0] * 255, color[1] * 255, color[2] * 255);
       if (qColor.isValid()) { return QVariant(QBrush(qColor)); }
     }
 
     break;
   }
 
   case Qt::EditRole:
   case Qt::DisplayRole:
   {
     switch ( index.column() )
     {
     case 0:
     {
       return QString::fromStdString(curNode->GetName());
     }
     case 1:
     {
       float floatValue;
       if ( curNode->GetFloatProperty(mitk::USZonesInteractor::DATANODE_PROPERTY_SIZE, floatValue) )
       {
           return static_cast<int>(floatValue);
       }
       else
       {
           return QVariant(QVariant::Invalid);
       }
     }
     case 2:
     {
       float color[3];
       if ( curNode->GetColor(color) )
       {
         QColor qColor(color[0] * 255, color[1] * 255, color[2] * 255);
 
         if (qColor == Qt::darkGreen) { return QVariant("Green"); }
         else if (qColor == Qt::red) { return QVariant("Red"); }
         else if (qColor == Qt::blue) { return QVariant("Blue"); }
         else if (qColor == Qt::yellow) { return QVariant("Yellow"); }
         else { return QVariant(qColor.name()); }
       }
       else { return QVariant(QVariant::Invalid); }
     }
     }
     break;
   }
   }
 
   return QVariant(QVariant::Invalid);
 }
 
 bool QmitkUSZonesDataModel::setData ( const QModelIndex & index, const QVariant & value, int role )
 {
   if (role == Qt::EditRole)
   {
     if (static_cast<unsigned int>(index.row()) >= m_ZoneNodes.size()
         || index.column() >= this->columnCount())
     {
       return false;
     }
 
     mitk::DataNode::Pointer curNode = m_ZoneNodes.at(index.row());
 
     switch ( index.column() )
     {
     case 0:
     {
       curNode->SetName(value.toString().toStdString());
       break;
     }
     case 1:
     {
       curNode->SetFloatProperty(mitk::USZonesInteractor::DATANODE_PROPERTY_SIZE, value.toFloat());
 
-      if (curNode->GetData() != 0)
+      if (curNode->GetData() != nullptr)
       {
         curNode->SetFloatProperty(mitk::USZonesInteractor::DATANODE_PROPERTY_SIZE, value.toFloat());
         mitk::USZonesInteractor::UpdateSurface(curNode);
       }
 
       break;
     }
     case 2:
     {
       QColor color(value.toString());
       curNode->SetColor(color.redF(), color.greenF(), color.blueF());
       break;
     }
     default:
       return false;
     }
 
     emit dataChanged(index, index);
   }
 
   // update the RenderWindow to show new points
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   return true;
 }
 
 bool QmitkUSZonesDataModel::insertRows ( int row, int count, const QModelIndex & parent )
 {
   this->beginInsertRows(parent, row, row+count-1);
 
   for ( int n = 0; n < count; ++n )
   {
     m_ZoneNodes.insert(m_ZoneNodes.begin()+row, mitk::DataNode::New());
   }
 
   this->endInsertRows();
 
   return true;
 }
 
 bool QmitkUSZonesDataModel::removeRows ( int row, int count, const QModelIndex & parent )
 {
   return this->removeRows(row, count, parent, true);
 }
 
 bool QmitkUSZonesDataModel::removeRows ( int row, int count, const QModelIndex & parent, bool removeFromDataStorage )
 {
   if ( static_cast<unsigned int>(row+count) > m_ZoneNodes.size() ) { return false; }
 
   this->beginRemoveRows(parent, row, row+count-1);
 
   for ( int n = count-1; n >= 0; --n )
   {
     DataNodeVector::iterator it = m_ZoneNodes.begin()+row+n;
     mitk::DataNode::Pointer curNode = *it;
     m_ZoneNodes.erase(it);
 
     if ( removeFromDataStorage && m_DataStorage.IsNotNull() )
     {
       m_DataStorage->Remove(curNode);
     }
   }
 
   this->endRemoveRows();
 
   return true;
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZonesDataModel.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZonesDataModel.h
index ac34b2fbac..d50498247b 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZonesDataModel.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZonesDataModel.h
@@ -1,97 +1,97 @@
 /*===================================================================
 
 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 QMITKUSZONESDATAMODEL_H
 #define QMITKUSZONESDATAMODEL_H
 
 #include <mitkCommon.h>
 #include <mitkDataNode.h>
 #include <mitkDataStorage.h>
 #include <mitkNumericTypes.h>
 
 #include <QAbstractTableModel>
 
 /**
  * \brief Implementation of the QAbstractTableModel for ultrasound risk zones.
  * This class manages the data model for the QmitkUSZoneManagementWidget. It provides
  * consistency between the table in QmitkUSZoneManagementWidget and the DataStorage.
  */
 class QmitkUSZonesDataModel : public QAbstractTableModel
 {
   Q_OBJECT
 
 public:
   typedef std::vector<mitk::DataNode::Pointer> DataNodeVector;
 
-  explicit QmitkUSZonesDataModel(QObject *parent = 0);
+  explicit QmitkUSZonesDataModel(QObject *parent = nullptr);
   ~QmitkUSZonesDataModel() override;
 
   /**
    * \brief Set data storage and base node for the zone nodes of this model.
    * The node event listeners will only recognize nodes which are children
    * of the given base node.
    *
    * \param dataStorage DataStorage where the zone nodes will be contained
    * \param baseNode DataNode which is source node of the zone nodes
    */
   void SetDataStorage(mitk::DataStorage::Pointer dataStorage, mitk::DataNode::Pointer baseNode);
 
   void AddNode(const mitk::DataNode*);
   void RemoveNode(const mitk::DataNode*);
   void ChangeNode(const mitk::DataNode*);
 
   /** \brief Return number of rows of the model. */
   int rowCount ( const QModelIndex & parent = QModelIndex() ) const override;
 
   /** \brief Return number of columns (3) of the model. */
   int columnCount ( const QModelIndex & parent = QModelIndex() ) const override;
 
   /** \brief Return names for the columns, numbers for the rows and invalid for DisplayRole. */
   QVariant headerData ( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const override;
 
   /** \brief Return selectable and enabled for column 1 (size); selectable, enabled and editable for every other column. */
   Qt::ItemFlags flags ( const QModelIndex & index ) const override;
 
   /** \brief Return model data of the selected cell. */
   QVariant data ( const QModelIndex & index, int role = Qt::DisplayRole ) const override;
 
   /** \brief Set model data for the selected cell. */
   bool setData ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole ) override;
 
   /** \brief Insert empty rows into the model (creates zone nodes). */
   bool insertRows ( int row, int count, const QModelIndex& parent = QModelIndex() ) override;
 
   /** \brief Remove given rows from the model. */
   bool removeRows ( int row, int count, const QModelIndex& parent = QModelIndex() ) override;
 
   /** \brief Remove given rows from the model.
    *  \param removeFromDataStorage zone nodes are removed from the data storage too, if this is set to true
    */
   virtual bool removeRows ( int row, int count, const QModelIndex& parent, bool removeFromDataStorage );
 
 protected:
   DataNodeVector             m_ZoneNodes;
 
   mitk::DataStorage::Pointer m_DataStorage;
   mitk::DataNode::Pointer    m_BaseNode;
 
 private:
   mitk::MessageDelegate1<QmitkUSZonesDataModel, const mitk::DataNode*> m_ListenerAddNode;
   mitk::MessageDelegate1<QmitkUSZonesDataModel, const mitk::DataNode*> m_ListenerChangeNode;
   mitk::MessageDelegate1<QmitkUSZonesDataModel, const mitk::DataNode*> m_ListenerRemoveNode;
 };
 
 #endif // QMITKUSZONESDATAMODEL_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUltrasoundCalibration.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUltrasoundCalibration.cpp
index 7291d62388..a2d4ae1385 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUltrasoundCalibration.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUltrasoundCalibration.cpp
@@ -1,1397 +1,1397 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkUltrasoundCalibration.h"
 #include <QTimer>
 
 // Qt
 #include <QFileDialog>
 #include <QMessageBox>
 #include <QTextStream>
 #include <QmitkServiceListWidget.h>
 
 // MITK
 #include <mitkVector.h>
 #include "mitkIOUtil.h"
 #include "mitkIRenderingManager.h"
 #include <mitkBaseData.h>
 #include <mitkImageGenerator.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkPointSet.h>
 #include <mitkPointSetDataInteractor.h>
 #include <mitkPointSetShapeProperty.h>
 #include <mitkSceneIO.h>
 
 // us
 #include <usServiceReference.h>
 
 // VTK
 #include <vtkLandmarkTransform.h>
 #include <vtkMatrix4x4.h>
 #include <vtkPlane.h>
 #include <vtkPoints.h>
 #include <vtkSphereSource.h>
 #include <vtkTransform.h>
 
 #include <vtkVertexGlyphFilter.h>
 
 #include "internal/org_mbi_gui_qt_usnavigation_Activator.h"
 
 // sleep headers
 #include <chrono>
 #include <thread>
 
 const std::string QmitkUltrasoundCalibration::VIEW_ID = "org.mitk.views.ultrasoundcalibration";
 
 QmitkUltrasoundCalibration::QmitkUltrasoundCalibration()
   : m_PhantomConfigurationPointSet(nullptr),
     m_USDeviceChanged(this, &QmitkUltrasoundCalibration::OnUSDepthChanged)
 {
   ctkPluginContext *pluginContext = mitk::PluginActivator::GetContext();
 
   if (pluginContext)
   {
     // to be notified about service event of an USDevice
     pluginContext->connectServiceListener(this,
                                           "OnDeviceServiceEvent",
                                           QString::fromStdString("(" + us::ServiceConstants::OBJECTCLASS() + "=" +
                                                                  us_service_interface_iid<mitk::USDevice>() + ")"));
   }
 }
 
 QmitkUltrasoundCalibration::~QmitkUltrasoundCalibration()
 {
   m_Controls.m_CombinedModalityManagerWidget->blockSignals(true);
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality;
   combinedModality = m_Controls.m_CombinedModalityManagerWidget->GetSelectedCombinedModality();
   if (combinedModality.IsNotNull())
   {
     combinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_USDeviceChanged);
   }
   m_Timer->stop();
 
   this->OnStopCalibrationProcess();
 
   this->OnStopPlusCalibration();
 
   mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode("Needle Path");
   if (node.IsNotNull())
     this->GetDataStorage()->Remove(node);
 
   this->GetDataStorage()->Remove(m_VerificationReferencePointsDataNode);
 
   delete m_Timer;
 
   // remove observer for phantom-based point adding
   m_CalibPointsImage->RemoveAllObservers();
 }
 
 void QmitkUltrasoundCalibration::SetFocus()
 {
   m_Controls.m_ToolBox->setFocus();
 }
 
 void QmitkUltrasoundCalibration::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
 
   m_Controls.m_CombinedModalityManagerWidget->SetCalibrationLoadedNecessary(false);
 
   m_Timer = new QTimer(this);
   m_StreamingTimer = new QTimer(this);
 
   m_Controls.m_SpacingBtnFreeze->setEnabled(true);
   m_Controls.m_SpacingAddPoint->setEnabled(false);
   m_Controls.m_CalculateSpacing->setEnabled(false);
 
   m_SpacingPointsCount = 0;
   m_SpacingPoints = mitk::PointSet::New();
   m_SpacingNode = mitk::DataNode::New();
   m_SpacingNode->SetName("Spacing Points");
   m_SpacingNode->SetData(this->m_SpacingPoints);
   this->GetDataStorage()->Add(m_SpacingNode);
 
   // Pointset for Calibration Points
   m_CalibPointsTool = mitk::PointSet::New();
 
   // Pointset for Worldpoints
   m_CalibPointsImage = mitk::PointSet::New();
 
   m_CalibPointsCount = 0;
 
   // Evaluation Pointsets (Non-Visualized)
   m_EvalPointsImage = mitk::PointSet::New();
   m_EvalPointsTool = mitk::PointSet::New();
   m_EvalPointsProjected = mitk::PointSet::New();
 
   // Neelde Projection Filter
   m_NeedleProjectionFilter = mitk::NeedleProjectionFilter::New();
 
   // Tracking Status Widgets
   m_Controls.m_CalibTrackingStatus->ShowStatusLabels();
   m_Controls.m_EvalTrackingStatus->ShowStatusLabels();
 
   // General & Device Selection
   connect(m_Timer, SIGNAL(timeout()), this, SLOT(Update()));
 
   // Calibration
   connect(m_Controls.m_CalibBtnFreeze, SIGNAL(clicked()), this, SLOT(SwitchFreeze())); // Freeze
   connect(m_Controls.m_CalibBtnAddPoint,
           SIGNAL(clicked()),
           this,
           SLOT(OnAddCalibPoint())); // Tracking & Image Points (Calibration)
   connect(m_Controls.m_CalibBtnCalibrate, SIGNAL(clicked()), this, SLOT(OnCalibration())); // Perform Calibration
   // Phantom-based calibration
   connect(m_Controls.m_CalibBtnLoadPhantomConfiguration,
           SIGNAL(clicked()),
           this,
           SLOT(OnLoadPhantomConfiguration())); // Phantom configuration
   connect(m_Controls.m_CalibBtnMatchAnnotationToPhantomConfiguration,
           SIGNAL(clicked()),
           this,
           SLOT(OnMatchAnnotationToPhantomConfiguration()));
   connect(m_Controls.m_CalibBtnMoveUp, SIGNAL(clicked()), this, SLOT(OnMovePhantomAnnotationsUp()));
   connect(m_Controls.m_CalibBtnMoveDown, SIGNAL(clicked()), this, SLOT(OnMovePhantomAnnotationsDown()));
   connect(m_Controls.m_CalibBtnMoveLeft, SIGNAL(clicked()), this, SLOT(OnMovePhantomAnnotationsLeft()));
   connect(m_Controls.m_CalibBtnMoveRight, SIGNAL(clicked()), this, SLOT(OnMovePhantomAnnotationsRight()));
   connect(m_Controls.m_CalibBtnRotateRight, SIGNAL(clicked()), this, SLOT(OnRotatePhantomAnnotationsRight()));
   connect(m_Controls.m_CalibBtnRotateLeft, SIGNAL(clicked()), this, SLOT(OnRotatePhantomAnnotationsLeft()));
 
   connect(m_Controls.m_CalibBtnPerformPhantomCalibration,
           SIGNAL(clicked()),
           this,
           SLOT(OnPhantomBasedCalibration())); // Perform phantom-based calibration
   connect(m_Controls.m_CalibBtnSavePhantomCalibration,
           SIGNAL(clicked()),
           this,
           SLOT(OnSaveCalibration())); // Save phantom-based calibration
 
   // Evaluation
   connect(m_Controls.m_EvalBtnStep1, SIGNAL(clicked()), this, SLOT(OnAddEvalProjectedPoint())); // Needle Projection
   connect(m_Controls.m_EvalBtnStep2, SIGNAL(clicked()), this, SLOT(SwitchFreeze()));            // Freeze
   connect(m_Controls.m_EvalBtnStep3,
           SIGNAL(clicked()),
           this,
           SLOT(OnAddEvalTargetPoint())); // Tracking & Image Points (Evaluation)
   connect(m_Controls.m_EvalBtnSave, SIGNAL(clicked()), this, SLOT(OnSaveEvaluation())); // Save Evaluation Results
   connect(m_Controls.m_CalibBtnSaveCalibration,
           SIGNAL(clicked()),
           this,
           SLOT(OnSaveCalibration()));                                       // Save Evaluation Results
   connect(m_Controls.m_BtnReset, SIGNAL(clicked()), this, SLOT(OnReset())); // Reset Pointsets
 
   // PLUS Calibration
   connect(m_Controls.m_GetCalibrationFromPLUS, SIGNAL(clicked()), this, SLOT(OnGetPlusCalibration()));
   connect(m_Controls.m_StartStreaming, SIGNAL(clicked()), this, SLOT(OnStartStreaming()));
   connect(m_StreamingTimer, SIGNAL(timeout()), this, SLOT(OnStreamingTimerTimeout()));
   connect(m_Controls.m_StopPlusCalibration, SIGNAL(clicked()), this, SLOT(OnStopPlusCalibration()));
   connect(m_Controls.m_SavePlusCalibration, SIGNAL(clicked()), this, SLOT(OnSaveCalibration()));
   connect(this, SIGNAL(NewConnectionSignal()), this, SLOT(OnNewConnection()));
 
   // Determine Spacing for Calibration of USVideoDevice
   connect(m_Controls.m_SpacingBtnFreeze, SIGNAL(clicked()), this, SLOT(OnFreezeClicked()));
   connect(m_Controls.m_SpacingAddPoint, SIGNAL(clicked()), this, SLOT(OnAddSpacingPoint()));
   connect(m_Controls.m_CalculateSpacing, SIGNAL(clicked()), this, SLOT(OnCalculateSpacing()));
 
   connect(m_Controls.m_CombinedModalityManagerWidget, SIGNAL(SignalReadyForNextStep()), this, SLOT(OnDeviceSelected()));
   connect(m_Controls.m_CombinedModalityManagerWidget,
           SIGNAL(SignalNoLongerReadyForNextStep()),
           this,
           SLOT(OnDeviceDeselected()));
   connect(m_Controls.m_StartCalibrationButton, SIGNAL(clicked()), this, SLOT(OnStartCalibrationProcess()));
   connect(m_Controls.m_StartPlusCalibrationButton, SIGNAL(clicked()), this, SLOT(OnStartPlusCalibration()));
   connect(m_Controls.m_CalibBtnRestartCalibration, SIGNAL(clicked()), this, SLOT(OnReset()));
   connect(m_Controls.m_CalibBtnStopCalibration, SIGNAL(clicked()), this, SLOT(OnStopCalibrationProcess()));
 
   connect(m_Controls.m_AddReferencePoints, SIGNAL(clicked()), this, SLOT(OnAddCurrentTipPositionToReferencePoints()));
   connect(m_Controls.m_AddCurrentPointerTipForVerification,
           SIGNAL(clicked()),
           this,
           SLOT(OnAddCurrentTipPositionForVerification()));
   connect(m_Controls.m_StartVerification, SIGNAL(clicked()), this, SLOT(OnStartVerification()));
 
   // initialize data storage combo box
   m_Controls.m_ReferencePointsComboBox->SetDataStorage(this->GetDataStorage());
   m_Controls.m_ReferencePointsComboBox->SetAutoSelectNewItems(true);
   m_Controls.m_ReferencePointsComboBox->SetPredicate(mitk::NodePredicateDataType::New("PointSet"));
 
   // initialize point list widget
   if (m_VerificationReferencePoints.IsNull())
   {
     m_VerificationReferencePoints = mitk::PointSet::New();
   }
   if (m_VerificationReferencePointsDataNode.IsNull())
   {
     m_VerificationReferencePointsDataNode = mitk::DataNode::New();
     m_VerificationReferencePointsDataNode->SetName("US Verification Reference Points");
     m_VerificationReferencePointsDataNode->SetData(m_VerificationReferencePoints);
     this->GetDataStorage()->Add(m_VerificationReferencePointsDataNode);
   }
   m_Controls.m_ReferencePointsPointListWidget->SetPointSetNode(m_VerificationReferencePointsDataNode);
 
   m_Controls.m_ToolBox->setCurrentIndex(0);
 }
 
 void QmitkUltrasoundCalibration::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
                                                     const QList<mitk::DataNode::Pointer> & /*nodes*/)
 {
 }
 
 void QmitkUltrasoundCalibration::OnTabSwitch(int index)
 {
   switch (index)
   {
     case 0:
       if (m_Controls.m_ToolBox->isItemEnabled(1) || m_Controls.m_ToolBox->isItemEnabled(2))
       {
         this->OnStopCalibrationProcess();
       }
       break;
     default:;
   }
 }
 
 void QmitkUltrasoundCalibration::OnDeviceSelected()
 {
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality;
   combinedModality = m_Controls.m_CombinedModalityManagerWidget->GetSelectedCombinedModality();
   if (combinedModality.IsNotNull())
   {
     combinedModality->GetUltrasoundDevice()->AddPropertyChangedListener(m_USDeviceChanged);
 
     m_Controls.m_StartCalibrationButton->setEnabled(true);
     m_Controls.m_StartPlusCalibrationButton->setEnabled(true);
     m_Controls.m_ToolBox->setItemEnabled(1, true);
     m_Controls.m_ToolBox->setItemEnabled(2, true);
   }
 }
 
 void QmitkUltrasoundCalibration::OnDeviceDeselected()
 {
   mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality;
   combinedModality = m_Controls.m_CombinedModalityManagerWidget->GetSelectedCombinedModality();
   if (combinedModality.IsNotNull())
   {
     combinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_USDeviceChanged);
   }
   m_Controls.m_StartCalibrationButton->setEnabled(false);
   m_Controls.m_StartPlusCalibrationButton->setEnabled(false);
   m_Controls.m_ToolBox->setCurrentIndex(0);
   m_Controls.m_ToolBox->setItemEnabled(1, false);
   m_Controls.m_ToolBox->setItemEnabled(2, false);
 }
 
 void QmitkUltrasoundCalibration::OnAddCurrentTipPositionToReferencePoints()
 {
   if (m_Controls.m_VerificationPointerChoser->GetSelectedNavigationDataSource().IsNull() ||
       (m_Controls.m_VerificationPointerChoser->GetSelectedToolID() == -1))
   {
     MITK_WARN << "No tool selected, aborting";
     return;
   }
   mitk::NavigationData::Pointer currentPointerData =
     m_Controls.m_VerificationPointerChoser->GetSelectedNavigationDataSource()->GetOutput(
       m_Controls.m_VerificationPointerChoser->GetSelectedToolID());
   mitk::Point3D currentTipPosition = currentPointerData->GetPosition();
   m_VerificationReferencePoints->InsertPoint(m_VerificationReferencePoints->GetSize(), currentTipPosition);
 }
 
 void QmitkUltrasoundCalibration::OnStartVerification()
 {
   m_currentPoint = 0;
   mitk::PointSet::Pointer selectedPointSet =
     dynamic_cast<mitk::PointSet *>(m_Controls.m_ReferencePointsComboBox->GetSelectedNode()->GetData());
   m_Controls.m_CurrentPointLabel->setText("Point " + QString::number(m_currentPoint) + " of " +
                                           QString::number(selectedPointSet->GetSize()));
   m_allErrors = std::vector<double>();
   m_allReferencePoints = std::vector<mitk::Point3D>();
   for (int i = 0; i < selectedPointSet->GetSize(); i++)
   {
     m_allReferencePoints.push_back(selectedPointSet->GetPoint(i));
   }
 }
 
 void QmitkUltrasoundCalibration::OnAddCurrentTipPositionForVerification()
 {
   if (m_currentPoint == -1)
   {
     MITK_WARN << "Cannot add point";
     return;
   }
   if (m_Controls.m_VerificationPointerChoser->GetSelectedNavigationDataSource().IsNull() ||
       (m_Controls.m_VerificationPointerChoser->GetSelectedToolID() == -1))
   {
     MITK_WARN << "No tool selected, aborting";
     return;
   }
   mitk::NavigationData::Pointer currentPointerData =
     m_Controls.m_VerificationPointerChoser->GetSelectedNavigationDataSource()->GetOutput(
       m_Controls.m_VerificationPointerChoser->GetSelectedToolID());
   mitk::Point3D currentTipPosition = currentPointerData->GetPosition();
 
   double currentError = m_allReferencePoints.at(m_currentPoint).EuclideanDistanceTo(currentTipPosition);
   MITK_INFO << "Current Error: " << currentError << " mm";
   m_allErrors.push_back(currentError);
 
   if (++m_currentPoint < static_cast<int>(m_allReferencePoints.size()))
   {
     m_Controls.m_CurrentPointLabel->setText("Point " + QString::number(m_currentPoint) + " of " +
                                             QString::number(m_allReferencePoints.size()));
   }
   else
   {
     m_currentPoint = -1;
     double meanError = 0;
     for (std::size_t i = 0; i < m_allErrors.size(); ++i)
     {
       meanError += m_allErrors[i];
     }
     meanError /= m_allErrors.size();
 
     QString result = "Finished verification! \n Verification of " + QString::number(m_allErrors.size()) +
                      " points, mean error: " + QString::number(meanError) + " mm";
     m_Controls.m_ResultsTextEdit->setText(result);
     MITK_INFO << result.toStdString();
   }
 }
 
 void QmitkUltrasoundCalibration::OnStartCalibrationProcess()
 {
   // US Image Stream
   m_Node = this->GetDataStorage()->GetNamedNode("US Viewing Stream - Image 0")->Clone();
   m_Node->SetName("US Calibration Viewing Stream");
   this->GetDataStorage()->Add(m_Node);
 
   // data node for calibration point set
   m_CalibNode = mitk::DataNode::New();
   m_CalibNode->SetName("Tool Calibration Points");
   m_CalibNode->SetData(this->m_CalibPointsTool);
   this->GetDataStorage()->Add(m_CalibNode);
 
   // data node for world point set
   m_WorldNode = mitk::DataNode::New();
   m_WorldNode->SetName("Image Calibration Points");
   m_WorldNode->SetData(this->m_CalibPointsImage);
   this->GetDataStorage()->Add(m_WorldNode);
 
   m_CombinedModality = m_Controls.m_CombinedModalityManagerWidget->GetSelectedCombinedModality();
   m_CombinedModality->SetCalibration(mitk::AffineTransform3D::New()); // dummy calibration because without a calibration
                                                                       // the comined modality was laggy (maybe a bug?)
   if (m_CombinedModality.IsNull())
   {
     return;
   }
 
   m_Tracker = m_CombinedModality->GetNavigationDataSource();
 
   // Construct Pipeline
   this->m_NeedleProjectionFilter->SetInput(0, m_Tracker->GetOutput(0));
 
   QApplication::setOverrideCursor(Qt::WaitCursor);
   // make sure that the combined modality is in connected state before using it
   if (m_CombinedModality->GetUltrasoundDevice()->GetDeviceState() < mitk::USDevice::State_Connected)
   {
     m_CombinedModality->GetUltrasoundDevice()->Connect();
   }
   if (m_CombinedModality->GetUltrasoundDevice()->GetDeviceState() < mitk::USDevice::State_Activated)
   {
     m_CombinedModality->GetUltrasoundDevice()->Activate();
   }
   QApplication::restoreOverrideCursor();
 
   this->SwitchFreeze();
 
   // Trigger the ProbeChanged method for initializing/updating the spacing of the ultrasound image correctly
   std::string probeName = m_CombinedModality->GetUltrasoundDevice()->GetCurrentProbe()->GetName();
   m_CombinedModality->GetUltrasoundDevice()->ProbeChanged(probeName);
 
   mitk::DataNode::Pointer usNode = this->GetDataStorage()->GetNamedNode("US Viewing Stream - Image 0");
   if (usNode.IsNotNull())
   {
     this->GetDataStorage()->Remove(usNode);
   }
 
   // Todo: Maybe display this elsewhere
   this->ShowNeedlePath();
 
   // Switch active tab to Calibration page
   m_Controls.m_ToolBox->setItemEnabled(1, true);
   m_Controls.m_ToolBox->setCurrentIndex(1);
 }
 
 void QmitkUltrasoundCalibration::OnStartPlusCalibration()
 {
   if (m_CombinedModality.IsNull())
   {
     m_CombinedModality = m_Controls.m_CombinedModalityManagerWidget->GetSelectedCombinedModality();
     if (m_CombinedModality.IsNull())
     {
       return;
     } // something went wrong, there is no combined modality
   }
 
   // setup server to send UltrasoundImages to PLUS
   mitk::IGTLServer::Pointer m_USServer = mitk::IGTLServer::New(true);
   m_USServer->SetName("EchoTrack Image Source");
   m_USServer->SetHostname("127.0.0.1");
   m_USServer->SetPortNumber(18944);
 
   m_USMessageProvider = mitk::IGTLMessageProvider::New();
   m_USMessageProvider->SetIGTLDevice(m_USServer);
   m_USMessageProvider->SetFPS(5);
 
   m_USImageToIGTLMessageFilter = mitk::ImageToIGTLMessageFilter::New();
   m_USImageToIGTLMessageFilter->ConnectTo(m_CombinedModality->GetUltrasoundDevice());
   m_USImageToIGTLMessageFilter->SetName("USImage Filter");
 
   // setup server to send TrackingData to PLUS
   m_TrackingServer = mitk::IGTLServer::New(true);
   m_TrackingServer->SetName("EchoTrack Tracking Source");
   m_TrackingServer->SetHostname("127.0.0.1");
   m_TrackingServer->SetPortNumber(18945);
 
   m_TrackingMessageProvider = mitk::IGTLMessageProvider::New();
   m_TrackingMessageProvider->SetIGTLDevice(m_TrackingServer);
   m_TrackingMessageProvider->SetFPS(5);
 
   m_TrackingToIGTLMessageFilter = mitk::NavigationDataToIGTLMessageFilter::New();
   m_TrackingToIGTLMessageFilter->ConnectTo(m_CombinedModality->GetTrackingDeviceDataSource());
   m_TrackingToIGTLMessageFilter->SetName("Tracker Filter");
 
   typedef itk::SimpleMemberCommand<QmitkUltrasoundCalibration> CurCommandType;
 
   CurCommandType::Pointer newConnectionCommand = CurCommandType::New();
   newConnectionCommand->SetCallbackFunction(this, &QmitkUltrasoundCalibration::OnPlusConnected);
   this->m_NewConnectionObserverTag =
     this->m_TrackingServer->AddObserver(mitk::NewClientConnectionEvent(), newConnectionCommand);
 
   // Open connections of both servers
   if (m_USServer->OpenConnection())
   {
     MITK_INFO << "US Server opened its connection successfully";
     m_USServer->StartCommunication();
   }
   else
   {
     MITK_INFO << "US Server could not open its connection";
   }
   if (m_TrackingServer->OpenConnection())
   {
     MITK_INFO << "Tracking Server opened its connection successfully";
     m_TrackingServer->StartCommunication();
   }
   else
   {
     MITK_INFO << "Tracking Server could not open its connection";
   }
   if (m_USMessageProvider->IsCommunicating() && m_TrackingMessageProvider->IsCommunicating())
   {
     m_Controls.m_StartPlusCalibrationButton->setEnabled(false);
     m_Controls.m_GetCalibrationFromPLUS->setEnabled(true);
     m_Controls.m_StartStreaming->setEnabled(false);
     m_Controls.m_SavePlusCalibration->setEnabled(false);
     m_Controls.m_SetupStatus->setStyleSheet("QLabel { color : green; }");
     m_Controls.m_SetupStatus->setText("Setup successfull you can now connect PLUS");
   }
   else
   {
     m_Controls.m_SetupStatus->setStyleSheet("QLabel { color : red; }");
     m_Controls.m_SetupStatus->setText("Something went wrong. Please try again");
   }
 }
 
 void QmitkUltrasoundCalibration::OnStopPlusCalibration()
 {
   // closing all server and clients when PlusCalibration is finished
   if (m_USMessageProvider.IsNotNull())
   {
     if (m_USMessageProvider->IsStreaming())
     {
       m_USMessageProvider->StopStreamingOfSource(m_USImageToIGTLMessageFilter);
     }
   }
   if (m_TrackingMessageProvider.IsNotNull())
   {
     if (m_TrackingMessageProvider->IsStreaming())
     {
       m_TrackingMessageProvider->StopStreamingOfSource(m_TrackingToIGTLMessageFilter);
     }
   }
   if (m_USServer.IsNotNull())
   {
     m_USServer->CloseConnection();
   }
   if (m_TrackingServer.IsNotNull())
   {
     m_TrackingServer->CloseConnection();
   }
   if (m_TransformClient.IsNotNull())
   {
     m_TransformClient->CloseConnection();
   }
   m_Controls.m_GotCalibrationLabel->setText("");
   m_Controls.m_ConnectionStatus->setText("");
   m_Controls.m_SetupStatus->setText("");
   m_Controls.m_StartPlusCalibrationButton->setEnabled(true);
   m_StreamingTimer->stop();
   delete m_StreamingTimer;
 }
 
 void QmitkUltrasoundCalibration::OnPlusConnected()
 {
   emit NewConnectionSignal();
 }
 
 void QmitkUltrasoundCalibration::OnNewConnection()
 {
   m_Controls.m_StartStreaming->setEnabled(true);
   m_Controls.m_ConnectionStatus->setStyleSheet("QLabel { color : green; }");
   m_Controls.m_ConnectionStatus->setText("Connection successfull you can now start streaming");
 }
 
 void QmitkUltrasoundCalibration::OnStreamingTimerTimeout()
 {
   m_USMessageProvider->Update();
   m_TrackingMessageProvider->Update();
 }
 
 void QmitkUltrasoundCalibration::OnStartStreaming()
 {
   m_USMessageProvider->StartStreamingOfSource(m_USImageToIGTLMessageFilter, 5);
   m_TrackingMessageProvider->StartStreamingOfSource(m_TrackingToIGTLMessageFilter, 5);
   m_Controls.m_StartStreaming->setEnabled(false);
   m_Controls.m_ConnectionStatus->setText("");
   m_StreamingTimer->start((1.0 / 5.0 * 1000.0));
 }
 
 void QmitkUltrasoundCalibration::OnGetPlusCalibration()
 {
   m_TransformClient = mitk::IGTLClient::New(true);
   m_TransformClient->SetHostname("127.0.0.1");
   m_TransformClient->SetPortNumber(18946);
   m_TransformDeviceSource = mitk::IGTLDeviceSource::New();
   m_TransformDeviceSource->SetIGTLDevice(m_TransformClient);
   m_TransformDeviceSource->Connect();
   if (m_TransformDeviceSource->IsConnected())
   {
     MITK_INFO << "successfully connected";
     m_TransformDeviceSource->StartCommunication();
     if (m_TransformDeviceSource->IsCommunicating())
     {
       MITK_INFO << "communication started";
       mitk::IGTLMessage::Pointer receivedMessage;
       bool condition = false;
       igtl::Matrix4x4 transformPLUS;
       while (!(receivedMessage.IsNotNull() && receivedMessage->IsDataValid()))
       {
         std::this_thread::sleep_for(std::chrono::milliseconds(50));
         m_TransformDeviceSource->Update();
         receivedMessage = m_TransformDeviceSource->GetOutput();
         igtl::TransformMessage::Pointer msg =
           dynamic_cast<igtl::TransformMessage *>(m_TransformDeviceSource->GetOutput()->GetMessage().GetPointer());
         if (msg == nullptr || msg.IsNull())
         {
           MITK_INFO << "Received message could not be casted to TransformMessage. Skipping...";
           continue;
         }
         else
         {
           if (std::strcmp(msg->GetDeviceName(), "ImageToTracker") != 0)
           {
             MITK_INFO << "Was not Image to Tracker Transform. Skipping...";
             continue;
           }
           else
           {
             msg->GetMatrix(transformPLUS);
             condition = true;
             break;
           }
         }
       }
       if (condition)
       {
         this->ProcessPlusCalibration(transformPLUS);
       }
       else
       {
         m_Controls.m_GotCalibrationLabel->setStyleSheet("QLabel { color : red; }");
         m_Controls.m_GotCalibrationLabel->setText("Something went wrong. Please try again");
       }
     }
     else
     {
       MITK_INFO << " no connection";
       m_Controls.m_GotCalibrationLabel->setStyleSheet("QLabel { color : red; }");
       m_Controls.m_GotCalibrationLabel->setText("Something went wrong. Please try again");
     }
   }
   else
   {
     m_Controls.m_GotCalibrationLabel->setStyleSheet("QLabel { color : red; }");
     m_Controls.m_GotCalibrationLabel->setText("Something went wrong. Please try again");
   }
 }
 
 void QmitkUltrasoundCalibration::ProcessPlusCalibration(igtl::Matrix4x4 &imageToTracker)
 {
   mitk::AffineTransform3D::Pointer imageToTrackerTransform = mitk::AffineTransform3D::New();
   itk::Matrix<mitk::ScalarType, 3, 3> rotationFloat = itk::Matrix<mitk::ScalarType, 3, 3>();
   itk::Vector<mitk::ScalarType, 3> translationFloat = itk::Vector<mitk::ScalarType, 3>();
 
   rotationFloat[0][0] = imageToTracker[0][0];
   rotationFloat[0][1] = imageToTracker[0][1];
   rotationFloat[0][2] = imageToTracker[0][2];
   rotationFloat[1][0] = imageToTracker[1][0];
   rotationFloat[1][1] = imageToTracker[1][1];
   rotationFloat[1][2] = imageToTracker[1][2];
   rotationFloat[2][0] = imageToTracker[2][0];
   rotationFloat[2][1] = imageToTracker[2][1];
   rotationFloat[2][2] = imageToTracker[2][2];
   translationFloat[0] = imageToTracker[0][3];
   translationFloat[1] = imageToTracker[1][3];
   translationFloat[2] = imageToTracker[2][3];
 
   imageToTrackerTransform->SetTranslation(translationFloat);
   imageToTrackerTransform->SetMatrix(rotationFloat);
 
   m_CombinedModality->SetCalibration(imageToTrackerTransform);
   m_Controls.m_ToolBox->setItemEnabled(2, true);
   m_Controls.m_SavePlusCalibration->setEnabled(true);
   m_Controls.m_GotCalibrationLabel->setStyleSheet("QLabel { color : green; }");
   m_Controls.m_GotCalibrationLabel->setText("Recieved Calibration from PLUS you can now save it");
 }
 
 void QmitkUltrasoundCalibration::OnStopCalibrationProcess()
 {
   this->ClearTemporaryMembers();
 
   m_Timer->stop();
 
   this->GetDataStorage()->Remove(m_Node);
-  m_Node = 0;
+  m_Node = nullptr;
 
   this->GetDataStorage()->Remove(m_CalibNode);
-  m_CalibNode = 0;
+  m_CalibNode = nullptr;
 
   this->GetDataStorage()->Remove(m_WorldNode);
-  m_WorldNode = 0;
+  m_WorldNode = nullptr;
 
   m_Controls.m_ToolBox->setCurrentIndex(0);
 }
 
 void QmitkUltrasoundCalibration::OnDeviceServiceEvent(const ctkServiceEvent event)
 {
   if (m_CombinedModality.IsNull() || event.getType() != ctkServiceEvent::MODIFIED)
   {
     return;
   }
 
   ctkServiceReference service = event.getServiceReference();
 
   QString curDepth =
     service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH)).toString();
   if (m_CurrentDepth != curDepth)
   {
     m_CurrentDepth = curDepth;
     this->OnReset();
   }
 }
 
 void QmitkUltrasoundCalibration::OnAddCalibPoint()
 {
   mitk::Point3D world = this->GetRenderWindowPart()->GetSelectedPosition();
 
   this->m_CalibPointsImage->InsertPoint(m_CalibPointsCount, world);
   this->m_CalibPointsTool->InsertPoint(m_CalibPointsCount, this->m_FreezePoint);
 
   QString text = text.number(m_CalibPointsCount + 1);
   text = "Point " + text;
   this->m_Controls.m_CalibPointList->addItem(text);
 
   m_CalibPointsCount++;
   SwitchFreeze();
 }
 
 void QmitkUltrasoundCalibration::OnCalibration()
 {
   // Compute transformation
   vtkSmartPointer<vtkLandmarkTransform> transform = vtkSmartPointer<vtkLandmarkTransform>::New();
 
   transform->SetSourceLandmarks(this->ConvertPointSetToVtkPolyData(m_CalibPointsImage)->GetPoints());
   transform->SetTargetLandmarks(this->ConvertPointSetToVtkPolyData(m_CalibPointsTool)->GetPoints());
 
   if (!m_CombinedModality->GetIsTrackedUltrasoundActive())
   {
     if (m_Controls.m_ScaleTransform->isChecked())
     {
       transform->SetModeToSimilarity();
     } // use affine transform
     else
     {
       transform->SetModeToRigidBody();
     } // use similarity transform: scaling is not touched
     MITK_INFO << "TEST";
   }
   else
   {
     transform->SetModeToRigidBody(); // use similarity transform: scaling is not touched
   }
 
   transform->Modified();
   transform->Update();
 
   // Convert from vtk to itk data types
   itk::Matrix<mitk::ScalarType, 3, 3> rotationFloat = itk::Matrix<mitk::ScalarType, 3, 3>();
   itk::Vector<mitk::ScalarType, 3> translationFloat = itk::Vector<mitk::ScalarType, 3>();
   vtkSmartPointer<vtkMatrix4x4> m = transform->GetMatrix();
   rotationFloat[0][0] = m->GetElement(0, 0);
   rotationFloat[0][1] = m->GetElement(0, 1);
   rotationFloat[0][2] = m->GetElement(0, 2);
   rotationFloat[1][0] = m->GetElement(1, 0);
   rotationFloat[1][1] = m->GetElement(1, 1);
   rotationFloat[1][2] = m->GetElement(1, 2);
   rotationFloat[2][0] = m->GetElement(2, 0);
   rotationFloat[2][1] = m->GetElement(2, 1);
   rotationFloat[2][2] = m->GetElement(2, 2);
   translationFloat[0] = m->GetElement(0, 3);
   translationFloat[1] = m->GetElement(1, 3);
   translationFloat[2] = m->GetElement(2, 3);
 
   mitk::PointSet::Pointer ImagePointsTransformed = m_CalibPointsImage->Clone();
   this->ApplyTransformToPointSet(ImagePointsTransformed, transform);
   mitk::DataNode::Pointer CalibPointsImageTransformed =
     this->GetDataStorage()->GetNamedNode("Calibration Points Image (Transformed)");
   if (CalibPointsImageTransformed.IsNull())
   {
     CalibPointsImageTransformed = mitk::DataNode::New();
     CalibPointsImageTransformed->SetName("Calibration Points Image (Transformed)");
     this->GetDataStorage()->Add(CalibPointsImageTransformed);
   }
   CalibPointsImageTransformed->SetData(ImagePointsTransformed);
 
   // Set new calibration transform
   m_Transformation = mitk::AffineTransform3D::New();
   m_Transformation->SetTranslation(translationFloat);
   m_Transformation->SetMatrix(rotationFloat);
   MITK_INFO << "New Calibration transform: " << m_Transformation;
 
   mitk::SlicedGeometry3D::Pointer sliced3d = dynamic_cast<mitk::SlicedGeometry3D *>(m_Node->GetData()->GetGeometry());
 
   mitk::PlaneGeometry::Pointer plane = const_cast<mitk::PlaneGeometry *>(sliced3d->GetPlaneGeometry(0));
 
   plane->SetIndexToWorldTransform(m_Transformation);
 
   // Save to US-Device
   m_CombinedModality->SetCalibration(m_Transformation);
   m_Controls.m_ToolBox->setItemEnabled(2, true);
 
   // Save to NeedleProjectionFilter
   m_NeedleProjectionFilter->SetTargetPlane(m_Transformation);
 
   // Update Calibration FRE
   m_CalibrationStatistics = mitk::PointSetDifferenceStatisticsCalculator::New();
   mitk::PointSet::Pointer p1 =
     this->m_CalibPointsTool->Clone(); // We use clones to calculate statistics to avoid concurrency Problems
 
   // Create point set with transformed image calibration points for
   // calculating the difference of image calibration and tool
   // calibration points in one geometry space
   mitk::PointSet::Pointer p2 = mitk::PointSet::New();
   int n = 0;
   for (mitk::PointSet::PointsConstIterator it = m_CalibPointsImage->Begin(); it != m_CalibPointsImage->End(); ++it, ++n)
   {
     p2->InsertPoint(n, m_Transformation->TransformPoint(it->Value()));
   }
 
   m_CalibrationStatistics->SetPointSets(p1, p2);
   // QString text = text.number(m_CalibrationStatistics->GetRMS());
   QString text = QString::number(ComputeFRE(m_CalibPointsImage, m_CalibPointsTool, transform));
   MITK_INFO << "Calibration FRE: " << text.toStdString().c_str();
   m_Controls.m_EvalLblCalibrationFRE->setText(text);
 
   m_Node->SetStringProperty("Calibration FRE", text.toStdString().c_str());
   // Enable Button to save Calibration
   m_Controls.m_CalibBtnSaveCalibration->setEnabled(true);
 }
 
 void QmitkUltrasoundCalibration::OnLoadPhantomConfiguration()
 {
   // clear all data
   ClearTemporaryMembers();
   // reset UI
   m_Controls.m_CalibBtnMatchAnnotationToPhantomConfiguration->setEnabled(false);
   m_Controls.m_RefinePhantomAnnotationsGroupBox->setEnabled(false);
   m_Controls.m_CalibBtnPerformPhantomCalibration->setEnabled(false);
   m_Controls.m_CalibBtnSavePhantomCalibration->setEnabled(false);
 
   // open phantom configuration
   QString fileName = QFileDialog::getOpenFileName(nullptr, "Load phantom configuration", "", "*.mps");
 
   // dialog closed or selection canceled
   if (fileName.isNull())
   {
     return;
   }
 
   m_PhantomConfigurationPointSet = dynamic_cast<mitk::PointSet *>(mitk::IOUtil::Load(fileName.toStdString()).at(0).GetPointer());
 
   // transform phantom fiducials to tracking space
   mitk::NavigationData::Pointer currentSensorData = this->m_Tracker->GetOutput(0)->Clone();
 
   for (int i = 0; i < m_PhantomConfigurationPointSet->GetSize(); i++)
   {
     mitk::Point3D phantomPoint = m_PhantomConfigurationPointSet->GetPoint(i);
     mitk::Point3D transformedPoint = currentSensorData->TransformPoint(phantomPoint);
     this->m_CalibPointsTool->InsertPoint(i, transformedPoint);
   }
 
   // add point set interactor for image calibration points
   mitk::PointSetDataInteractor::Pointer imageCalibrationPointSetInteractor = mitk::PointSetDataInteractor::New();
   imageCalibrationPointSetInteractor->LoadStateMachine("PointSet.xml");
   imageCalibrationPointSetInteractor->SetEventConfig("PointSetConfig.xml");
   imageCalibrationPointSetInteractor->SetDataNode(m_WorldNode);
   imageCalibrationPointSetInteractor->SetMaxPoints(m_PhantomConfigurationPointSet->GetSize());
   // Call On AddCalibPointPhantomBased() when point was added
   itk::SimpleMemberCommand<QmitkUltrasoundCalibration>::Pointer pointAddedCommand =
     itk::SimpleMemberCommand<QmitkUltrasoundCalibration>::New();
   pointAddedCommand->SetCallbackFunction(this, &QmitkUltrasoundCalibration::OnPhantomCalibPointsChanged);
   m_CalibPointsImage->AddObserver(mitk::PointSetAddEvent(), pointAddedCommand);
   m_CalibPointsImage->AddObserver(mitk::PointSetMoveEvent(), pointAddedCommand);
   // Set size of image points points
   m_WorldNode->ReplaceProperty("point 2D size", mitk::FloatProperty::New(10.0));
 }
 
 void QmitkUltrasoundCalibration::OnPhantomCalibPointsChanged()
 {
   int currentIndex = m_CalibPointsImage->SearchSelectedPoint();
   mitk::Point3D currentImagePoint = m_CalibPointsImage->GetPoint(currentIndex);
   UpdatePhantomAnnotationPointVisualization(currentIndex);
   // create sphere to show radius in which next point has to be placed
    this->GetDataStorage()->Remove(this->GetDataStorage()->GetNamedNode("NextPointIndicator"));
    if (currentIndex < m_CalibPointsTool->GetSize() - 1)
   {
     float distanceToNextPoint =
       m_CalibPointsTool->GetPoint(currentIndex).EuclideanDistanceTo(m_CalibPointsTool->GetPoint(currentIndex + 1));
     vtkSmartPointer<vtkSphereSource> vtkHelperSphere = vtkSmartPointer<vtkSphereSource>::New();
     vtkHelperSphere->SetCenter(currentImagePoint[0], currentImagePoint[1], currentImagePoint[2]);
     vtkHelperSphere->SetRadius(distanceToNextPoint);
     vtkHelperSphere->SetPhiResolution(40);
     vtkHelperSphere->SetThetaResolution(40);
     vtkHelperSphere->Update();
     mitk::Surface::Pointer helperSphere = mitk::Surface::New();
     helperSphere->SetVtkPolyData(vtkHelperSphere->GetOutput());
     mitk::DataNode::Pointer helperSphereNode = mitk::DataNode::New();
     helperSphereNode->SetName("NextPointIndicator");
     helperSphereNode->SetData(helperSphere);
     helperSphereNode->SetColor(0.0, 1.0, 0.0);
     this->GetDataStorage()->Add(helperSphereNode);
   }
   if (m_CalibPointsTool->GetSize() == m_CalibPointsImage->GetSize())
   {
     m_Controls.m_CalibBtnMatchAnnotationToPhantomConfiguration->setEnabled(true);
   }
 }
 
 void QmitkUltrasoundCalibration::UpdatePhantomAnnotationPointVisualization(int index)
 {
   mitk::Point3D currentImagePoint = m_CalibPointsImage->GetPoint(index);
   // create sphere to show current fiducial
   std::stringstream pointName;
   pointName << "Point";
   pointName << index;
   this->GetDataStorage()->Remove(this->GetDataStorage()->GetNamedNode(pointName.str()));
   vtkSmartPointer<vtkSphereSource> vtkPointSphere = vtkSmartPointer<vtkSphereSource>::New();
   vtkPointSphere->SetCenter(currentImagePoint[0], currentImagePoint[1], currentImagePoint[2]);
   vtkPointSphere->SetRadius(5.0);
   vtkPointSphere->SetPhiResolution(40);
   vtkPointSphere->SetThetaResolution(40);
   vtkPointSphere->Update();
   mitk::Surface::Pointer pointSphere = mitk::Surface::New();
   pointSphere->SetVtkPolyData(vtkPointSphere->GetOutput());
   mitk::DataNode::Pointer sphereNode = mitk::DataNode::New();
   sphereNode->SetName(pointName.str());
   sphereNode->SetData(pointSphere);
   sphereNode->SetColor(1.0, 1.0, 0.0);
   this->GetDataStorage()->Add(sphereNode);
 }
 
 void QmitkUltrasoundCalibration::OnMatchAnnotationToPhantomConfiguration()
 {
   // Transform pointset of phantom configuration to currently annotated image points
   vtkSmartPointer<vtkLandmarkTransform> transform = vtkSmartPointer<vtkLandmarkTransform>::New();
   transform->SetModeToRigidBody();
   vtkSmartPointer<vtkPoints> toolLandmarks = this->ConvertPointSetToVtkPolyData(m_CalibPointsTool)->GetPoints();
   transform->SetSourceLandmarks(toolLandmarks);
   transform->SetTargetLandmarks(this->ConvertPointSetToVtkPolyData(m_CalibPointsImage)->GetPoints());
   transform->Update();
   // update image annotation with matched phantom configuration
   vtkSmartPointer<vtkPoints> transformedToolLandmarks = vtkSmartPointer<vtkPoints>::New();
   transform->TransformPoints(toolLandmarks, transformedToolLandmarks);
   for (int i = 0; i < transformedToolLandmarks->GetNumberOfPoints(); i++)
   {
     m_CalibPointsImage->InsertPoint(i, transformedToolLandmarks->GetPoint(i));
     UpdatePhantomAnnotationPointVisualization(i);
   }
   m_Controls.m_RefinePhantomAnnotationsGroupBox->setEnabled(true);
   m_Controls.m_CalibBtnPerformPhantomCalibration->setEnabled(true);
 }
 
 void QmitkUltrasoundCalibration::TranslatePhantomAnnotations(double tx, double ty, double tz)
 {
   vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
   transform->Translate(tx, ty, tz);
   vtkSmartPointer<vtkPoints> currentPoints = this->ConvertPointSetToVtkPolyData(m_CalibPointsImage)->GetPoints();
   vtkSmartPointer<vtkPoints> transformedPoints = vtkSmartPointer<vtkPoints>::New();
   transform->TransformPoints(currentPoints, transformedPoints);
   for (int i = 0; i < transformedPoints->GetNumberOfPoints(); i++)
   {
     m_CalibPointsImage->InsertPoint(i, transformedPoints->GetPoint(i));
     UpdatePhantomAnnotationPointVisualization(i);
   }
 }
 
 void QmitkUltrasoundCalibration::RotatePhantomAnnotations(double angle)
 {
   vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
   transform->RotateZ(angle);
   vtkSmartPointer<vtkPoints> currentPoints = this->ConvertPointSetToVtkPolyData(m_CalibPointsImage)->GetPoints();
   vtkSmartPointer<vtkPoints> transformedPoints = vtkSmartPointer<vtkPoints>::New();
   transform->TransformPoints(currentPoints, transformedPoints);
   for (int i = 0; i < transformedPoints->GetNumberOfPoints(); i++)
   {
     m_CalibPointsImage->InsertPoint(i, transformedPoints->GetPoint(i));
     UpdatePhantomAnnotationPointVisualization(i);
   }
 }
 
 void QmitkUltrasoundCalibration::OnMovePhantomAnnotationsUp()
 {
   this->TranslatePhantomAnnotations(0, -m_Image->GetGeometry()->GetSpacing()[1], 0);
 }
 
 void QmitkUltrasoundCalibration::OnMovePhantomAnnotationsDown()
 {
   this->TranslatePhantomAnnotations(0, m_Image->GetGeometry()->GetSpacing()[1], 0);
 }
 
 void QmitkUltrasoundCalibration::OnMovePhantomAnnotationsLeft()
 {
   this->TranslatePhantomAnnotations(-m_Image->GetGeometry()->GetSpacing()[0], 0, 0);
 }
 
 void QmitkUltrasoundCalibration::OnMovePhantomAnnotationsRight()
 {
   this->TranslatePhantomAnnotations(m_Image->GetGeometry()->GetSpacing()[0], 0, 0);
 }
 
 void QmitkUltrasoundCalibration::OnRotatePhantomAnnotationsRight()
 {
   mitk::BoundingBox::PointType centerOfPointSet = m_CalibPointsImage->GetGeometry()->GetBoundingBox()->GetCenter();
   this->TranslatePhantomAnnotations(-centerOfPointSet[0], -centerOfPointSet[1], -centerOfPointSet[2]);
   this->RotatePhantomAnnotations(0.5);
   this->TranslatePhantomAnnotations(centerOfPointSet[0], centerOfPointSet[1], centerOfPointSet[2]);
 }
 
 void QmitkUltrasoundCalibration::OnRotatePhantomAnnotationsLeft()
 {
   mitk::BoundingBox::PointType centerOfPointSet = m_CalibPointsImage->GetGeometry()->GetBoundingBox()->GetCenter();
   this->TranslatePhantomAnnotations(-centerOfPointSet[0], -centerOfPointSet[1], -centerOfPointSet[2]);
   this->RotatePhantomAnnotations(-0.5);
   this->TranslatePhantomAnnotations(centerOfPointSet[0], centerOfPointSet[1], centerOfPointSet[2]);
 }
 
 void QmitkUltrasoundCalibration::OnPhantomBasedCalibration()
 {
   // perform calibration
   OnCalibration();
   m_Controls.m_CalibBtnSavePhantomCalibration->setEnabled(true);
 }
 
 void QmitkUltrasoundCalibration::OnAddEvalTargetPoint()
 {
   mitk::Point3D world = this->GetRenderWindowPart()->GetSelectedPosition();
 
   this->m_EvalPointsImage->InsertPoint(m_EvalPointsImage->GetSize(), world);
   this->m_EvalPointsTool->InsertPoint(m_EvalPointsTool->GetSize(), this->m_FreezePoint);
 
   QString text = text.number(this->m_EvalPointsTool->GetSize());
   this->m_Controls.m_EvalLblNumTargetPoints->setText(text);
 
   // Update FREs
   // Update Evaluation FRE, but only if it contains more than one point (will crash otherwise)
   if ((m_EvalPointsProjected->GetSize() > 1) && (m_EvalPointsTool->GetSize() > 1))
   {
     m_EvaluationStatistics = mitk::PointSetDifferenceStatisticsCalculator::New();
     m_ProjectionStatistics = mitk::PointSetDifferenceStatisticsCalculator::New();
     mitk::PointSet::Pointer p1 =
       this->m_EvalPointsTool->Clone(); // We use clones to calculate statistics to avoid concurrency Problems
     mitk::PointSet::Pointer p2 = this->m_EvalPointsImage->Clone();
     mitk::PointSet::Pointer p3 = this->m_EvalPointsProjected->Clone();
     m_EvaluationStatistics->SetPointSets(p1, p2);
     m_ProjectionStatistics->SetPointSets(p1, p3);
     QString evalText = evalText.number(m_EvaluationStatistics->GetRMS());
     QString projText = projText.number(m_ProjectionStatistics->GetRMS());
     m_Controls.m_EvalLblEvaluationFRE->setText(evalText);
     m_Controls.m_EvalLblProjectionFRE->setText(projText);
   }
   SwitchFreeze();
 }
 
 void QmitkUltrasoundCalibration::OnAddEvalProjectedPoint()
 {
   MITK_WARN << "Projection Evaluation may currently be inaccurate.";
   // TODO: Verify correct Evaluation. Is the Point that is added really current?
   mitk::Point3D projection = this->m_NeedleProjectionFilter->GetProjection()->GetPoint(1);
   m_EvalPointsProjected->InsertPoint(m_EvalPointsProjected->GetSize(), projection);
   QString text = text.number(this->m_EvalPointsProjected->GetSize());
   this->m_Controls.m_EvalLblNumProjectionPoints->setText(text);
 }
 
 void QmitkUltrasoundCalibration::OnSaveEvaluation()
 {
   // Filename without suffix
   QString filename = m_Controls.m_EvalFilePath->text() + "//" + m_Controls.m_EvalFilePrefix->text();
 
   MITK_WARN << "CANNOT SAVE, ABORTING!";
   /* not working any more TODO!
   mitk::PointSetWriter::Pointer psWriter = mitk::PointSetWriter::New();
   psWriter->SetInput(0, m_CalibPointsImage);
   psWriter->SetInput(1, m_CalibPointsTool);
   psWriter->SetInput(2, m_EvalPointsImage);
   psWriter->SetInput(3, m_EvalPointsTool);
   psWriter->SetInput(4, m_EvalPointsProjected);
   psWriter->SetFileName(filename.toStdString() + ".xml");
   psWriter->Write();
   */
 
   // TODO: New writer for transformations must be implemented.
   /*
   mitk::TransformationFileWriter::Pointer tWriter = mitk::TransformationFileWriter::New();
   tWriter->SetInput(0, m_CalibPointsImage);
   tWriter->SetInput(1, m_CalibPointsTool);
   tWriter->SetInput(2, m_EvalPointsImage);
   tWriter->SetInput(3, m_EvalPointsTool);
   tWriter->SetInput(4, m_EvalPointsProjected);
   tWriter->SetOutputFilename(filename.toStdString() + ".txt");
   tWriter->DoWrite(this->m_Transformation);
   */
 }
 
 void QmitkUltrasoundCalibration::OnSaveCalibration()
 {
   m_Controls.m_GotCalibrationLabel->setText("");
   QString filename =
     QFileDialog::getSaveFileName(QApplication::activeWindow(), "Save Calibration", "", "Calibration files *.cal");
 
   QFile file(filename);
   if (!file.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate))
   {
     MITK_WARN << "Cannot open file '" << filename.toStdString() << "' for writing.";
     return;
   }
 
   std::string calibrationSerialization = m_CombinedModality->SerializeCalibration();
 
   QTextStream outStream(&file);
   outStream << QString::fromStdString(calibrationSerialization);
 
   // save additional information
   if (m_Controls.m_saveAdditionalCalibrationLog->isChecked())
   {
     mitk::SceneIO::Pointer mySceneIO = mitk::SceneIO::New();
     QString filenameScene = filename + "_mitkScene.mitk";
     mitk::NodePredicateNot::Pointer isNotHelperObject =
       mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)));
     mitk::DataStorage::SetOfObjects::ConstPointer nodesToBeSaved = this->GetDataStorage()->GetSubset(isNotHelperObject);
     mySceneIO->SaveScene(nodesToBeSaved, this->GetDataStorage(), filenameScene.toStdString().c_str());
   }
 }
 
 void QmitkUltrasoundCalibration::OnReset()
 {
   this->ClearTemporaryMembers();
 
   if (m_Transformation.IsNull())
   {
     m_Transformation = mitk::AffineTransform3D::New();
   }
   m_Transformation->SetIdentity();
 
   if (m_Node.IsNotNull() && (m_Node->GetData() != nullptr) && (m_Node->GetData()->GetGeometry() != nullptr))
   {
     mitk::SlicedGeometry3D::Pointer sliced3d = dynamic_cast<mitk::SlicedGeometry3D *>(m_Node->GetData()->GetGeometry());
     mitk::PlaneGeometry::Pointer plane = const_cast<mitk::PlaneGeometry *>(sliced3d->GetPlaneGeometry(0));
     plane->SetIndexToWorldTransform(m_Transformation);
   }
 
   QString text1 = text1.number(this->m_EvalPointsTool->GetSize());
   this->m_Controls.m_EvalLblNumTargetPoints->setText(text1);
   QString text2 = text2.number(this->m_EvalPointsProjected->GetSize());
   this->m_Controls.m_EvalLblNumProjectionPoints->setText(text2);
 }
 
 void QmitkUltrasoundCalibration::Update()
 {
   // Update Tracking Data
   std::vector<mitk::NavigationData::Pointer> *datas = new std::vector<mitk::NavigationData::Pointer>();
   datas->push_back(m_Tracker->GetOutput());
   m_Controls.m_CalibTrackingStatus->SetNavigationDatas(datas);
   m_Controls.m_CalibTrackingStatus->Refresh();
   m_Controls.m_EvalTrackingStatus->SetNavigationDatas(datas);
   m_Controls.m_EvalTrackingStatus->Refresh();
 
   m_CombinedModality->Modified();
   m_CombinedModality->Update();
 
   // Update US Image
   mitk::Image::Pointer image = m_CombinedModality->GetOutput();
   // make sure that always the current image is set to the data node
   if (image.IsNotNull() && m_Node->GetData() != image.GetPointer() && image->IsInitialized())
   {
     m_Node->SetData(image);
   }
 
   // Update Needle Projection
   m_NeedleProjectionFilter->Update();
 
   // only update 2d window because it is faster
   this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
 }
 
 void QmitkUltrasoundCalibration::SwitchFreeze()
 {
   m_Controls.m_CalibBtnAddPoint->setEnabled(false); // generally deactivate
   // We use the activity state of the timer to determine whether we are currently viewing images
   if (!m_Timer->isActive()) // Activate Imaging
   {
     // if (m_Node) m_Node->ReleaseData();
     if (m_CombinedModality.IsNull())
     {
       m_Timer->stop();
       return;
     }
 
     m_CombinedModality->Update();
     m_Image = m_CombinedModality->GetOutput();
     if (m_Image.IsNotNull() && m_Image->IsInitialized())
     {
       m_Node->SetData(m_Image);
     }
 
     std::vector<mitk::NavigationData::Pointer> datas;
     datas.push_back(m_Tracker->GetOutput());
     m_Controls.m_CalibTrackingStatus->SetNavigationDatas(&datas);
     m_Controls.m_CalibTrackingStatus->ShowStatusLabels();
     m_Controls.m_CalibTrackingStatus->Refresh();
 
     m_Controls.m_EvalTrackingStatus->SetNavigationDatas(&datas);
     m_Controls.m_EvalTrackingStatus->ShowStatusLabels();
     m_Controls.m_EvalTrackingStatus->Refresh();
 
     int interval = 40;
     m_Timer->setInterval(interval);
     m_Timer->start();
 
     m_CombinedModality->SetIsFreezed(false);
   }
   else if (this->m_Tracker->GetOutput(0)->IsDataValid())
   {
     // deactivate Imaging
     m_Timer->stop();
     // Remember last tracking coordinates
     m_FreezePoint = this->m_Tracker->GetOutput(0)->GetPosition();
     m_Controls.m_CalibBtnAddPoint->setEnabled(true); // activate only, if valid point is set
 
     m_CombinedModality->SetIsFreezed(true);
   }
 }
 
 void QmitkUltrasoundCalibration::ShowNeedlePath()
 {
   // Init Filter
   this->m_NeedleProjectionFilter->SelectInput(0);
 
   // Create Node for Pointset
   mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode("Needle Path");
   if (node.IsNull())
   {
     node = mitk::DataNode::New();
     node->SetName("Needle Path");
     node->SetData(m_NeedleProjectionFilter->GetProjection());
     node->SetBoolProperty("show contour", true);
     this->GetDataStorage()->Add(node);
   }
 }
 
 void QmitkUltrasoundCalibration::ClearTemporaryMembers()
 {
   m_CalibPointsTool->Clear();
   m_CalibPointsImage->Clear();
   m_CalibPointsCount = 0;
 
   m_EvalPointsImage->Clear();
   m_EvalPointsTool->Clear();
   m_EvalPointsProjected->Clear();
 
   this->m_Controls.m_CalibPointList->clear();
 
   m_SpacingPoints->Clear();
   m_Controls.m_SpacingPointsList->clear();
   m_SpacingPointsCount = 0;
 }
 
 vtkSmartPointer<vtkPolyData> QmitkUltrasoundCalibration::ConvertPointSetToVtkPolyData(mitk::PointSet::Pointer PointSet)
 {
   vtkSmartPointer<vtkPolyData> returnValue = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   for (int i = 0; i < PointSet->GetSize(); i++)
   {
     double point[3] = {PointSet->GetPoint(i)[0], PointSet->GetPoint(i)[1], PointSet->GetPoint(i)[2]};
     points->InsertNextPoint(point);
   }
   vtkSmartPointer<vtkPolyData> temp = vtkSmartPointer<vtkPolyData>::New();
   temp->SetPoints(points);
 
   vtkSmartPointer<vtkVertexGlyphFilter> vertexFilter = vtkSmartPointer<vtkVertexGlyphFilter>::New();
   vertexFilter->SetInputData(temp);
   vertexFilter->Update();
 
   returnValue->ShallowCopy(vertexFilter->GetOutput());
 
   return returnValue;
 }
 
 double QmitkUltrasoundCalibration::ComputeFRE(mitk::PointSet::Pointer imageFiducials,
                                               mitk::PointSet::Pointer realWorldFiducials,
                                               vtkSmartPointer<vtkLandmarkTransform> transform)
 {
   if (imageFiducials->GetSize() != realWorldFiducials->GetSize())
     return -1;
   double FRE = 0;
   for (int i = 0; i < imageFiducials->GetSize(); ++i)
   {
     itk::Point<double> current_image_fiducial_point = imageFiducials->GetPoint(i);
     if (transform != nullptr)
     {
       current_image_fiducial_point = transform->TransformPoint(
         imageFiducials->GetPoint(i)[0], imageFiducials->GetPoint(i)[1], imageFiducials->GetPoint(i)[2]);
     }
     double cur_error_squared = current_image_fiducial_point.SquaredEuclideanDistanceTo(realWorldFiducials->GetPoint(i));
     FRE += cur_error_squared;
   }
 
   FRE = sqrt(FRE / (double)imageFiducials->GetSize());
 
   return FRE;
 }
 
 void QmitkUltrasoundCalibration::ApplyTransformToPointSet(mitk::PointSet::Pointer pointSet,
                                                           vtkSmartPointer<vtkAbstractTransform> transform)
 {
   for (int i = 0; i < pointSet->GetSize(); ++i)
   {
     itk::Point<double> current_point_transformed = itk::Point<double>();
     current_point_transformed =
       transform->TransformPoint(pointSet->GetPoint(i)[0], pointSet->GetPoint(i)[1], pointSet->GetPoint(i)[2]);
     pointSet->SetPoint(i, current_point_transformed);
   }
 }
 
 void QmitkUltrasoundCalibration::OnFreezeClicked()
 {
   if (m_CombinedModality.IsNull())
   {
     return;
   }
 
   if (m_CombinedModality->GetIsFreezed())
   {
     // device was already frozen so we need to delete all spacing points because they need to be collected all at once
     // no need to check if all four points are already collected, because if that's the case you can no longer click the
     // Freeze button
     m_SpacingPoints->Clear();
     m_Controls.m_SpacingPointsList->clear();
     m_SpacingPointsCount = 0;
     m_Controls.m_SpacingAddPoint->setEnabled(false);
   }
   else
   {
     m_Controls.m_SpacingAddPoint->setEnabled(true);
   }
   SwitchFreeze();
 }
 
 void QmitkUltrasoundCalibration::OnAddSpacingPoint()
 {
   mitk::Point3D point = this->GetRenderWindowPart()->GetSelectedPosition();
 
   this->m_SpacingPoints->InsertPoint(m_SpacingPointsCount, point);
 
   QString text = text.number(m_SpacingPointsCount + 1);
   text = "Point " + text;
 
   this->m_Controls.m_SpacingPointsList->addItem(text);
 
   m_SpacingPointsCount++;
 
   if (m_SpacingPointsCount == 4) // now we have all 4 points needed
   {
     m_Controls.m_SpacingAddPoint->setEnabled(false);
     m_Controls.m_CalculateSpacing->setEnabled(true);
     m_Controls.m_SpacingBtnFreeze->setEnabled(false);
   }
 }
 
 void QmitkUltrasoundCalibration::OnCalculateSpacing()
 {
   mitk::Point3D horizontalOne = m_SpacingPoints->GetPoint(0);
   mitk::Point3D horizontalTwo = m_SpacingPoints->GetPoint(1);
   mitk::Point3D verticalOne = m_SpacingPoints->GetPoint(2);
   mitk::Point3D verticalTwo = m_SpacingPoints->GetPoint(3);
 
   // Get the distances between the points in the image
   double xDistance = horizontalOne.EuclideanDistanceTo(horizontalTwo);
   double yDistance = verticalOne.EuclideanDistanceTo(verticalTwo);
 
   // Calculate the spacing of the image and fill a vector with it
   double xSpacing = 30 / xDistance;
   double ySpacing = 20 / yDistance;
 
   m_CombinedModality->GetUltrasoundDevice()->SetSpacing(xSpacing, ySpacing);
 
   // Now that the spacing is set clear all stuff and return to Calibration
   m_SpacingPoints->Clear();
   m_Controls.m_SpacingPointsList->clear();
   m_SpacingPointsCount = 0;
   m_CombinedModality->SetIsFreezed(false);
 }
 
 void QmitkUltrasoundCalibration::OnUSDepthChanged(const std::string &key, const std::string &)
 {
   // whenever depth of USImage is changed the spacing should no longer be overwritten
   if (key == mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH)
   {
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/SettingsWidgets/QmitkUSNavigationAbstractSettingsWidget.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/SettingsWidgets/QmitkUSNavigationAbstractSettingsWidget.h
index 63f3df9739..c4b899882c 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/SettingsWidgets/QmitkUSNavigationAbstractSettingsWidget.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/SettingsWidgets/QmitkUSNavigationAbstractSettingsWidget.h
@@ -1,103 +1,103 @@
 /*===================================================================
 
 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 QMITKUSNAVIGATIONABSTRACTSETTINGSWIDGET_H
 #define QMITKUSNAVIGATIONABSTRACTSETTINGSWIDGET_H
 
 #include <QWidget>
 
 #include "mitkDataNode.h"
 
 /**
  * \brief Abstract class of settings widgets used by the QmitkUSNavigationProcessWidget.
  * This class handles the emitting of Saved(), Canceled() and SettingsChanged()
  * signals and provides slots for save and cancel buttons.
  *
  * The actual saving and loading of settings is delegated to concrete subclasses
  * which should therefore implement OnSetSettingsNode(), OnSaveProcessing(),
  * OnCancelProcessing(), OnLoadSettingsProcessing().
  */
 class QmitkUSNavigationAbstractSettingsWidget : public QWidget
 {
   Q_OBJECT
 
 signals:
   void Saved();
   void Canceled();
   void SettingsChanged(itk::SmartPointer<mitk::DataNode>);
 
 protected slots:
   /**
    * \brief Triggers the saving of the current settings.
    * OnSaveProcessing() is called and the Saved() signal is emitted afterwards.
    */
   void OnSave();
 
   /**
    * \brief Ends the settings changing process without saving the changes.
    * OnCancelProcessing() is called and the Canceled() signal is emitted
    * afterwards.
    */
   void OnCancel();
 
 public:
-  explicit QmitkUSNavigationAbstractSettingsWidget(QWidget *parent = 0);
+  explicit QmitkUSNavigationAbstractSettingsWidget(QWidget *parent = nullptr);
   ~QmitkUSNavigationAbstractSettingsWidget() override;
 
   /**
    * \brief Loads the settings.
    * The actual loading is done by calling the OnLoadSettingsProcessing()
    * method.
    */
   void LoadSettings();
 
   /**
    * \brief Setter for the data node in which the settings are loaded.
    * The settings are made available as properties of this data node.
    */
   void SetSettingsNode(itk::SmartPointer<mitk::DataNode> settingsNode, bool overwriteValues = false);
   itk::SmartPointer<mitk::DataNode> GetSettingsNode();
 
 protected:
   /**
    * \brief Method for handling the setting of a new settings node.
    * This method has to be implemented by a concrete subclass.
    */
   virtual void OnSetSettingsNode(itk::SmartPointer<mitk::DataNode> settingsNode, bool overwriteValues) = 0;
 
   /**
    * \brief Method for actually saving the settings.
    * This method has to be implemented by a concrete subclass.
    */
   virtual void OnSaveProcessing() = 0;
 
   /**
    * \brief Method for handling the cancel process.
    * This method can be implemented by a concrete subclass. An empty default
    * implementation exists.
    */
   virtual void OnCancelProcessing() {}
 
   /**
    * \brief Method for acutally loading the settings.
    * This method has to be implemented by a concrete subclass.
    */
   virtual void OnLoadSettingsProcessing() = 0;
 
 private:
   mitk::DataNode::Pointer m_SettingsNode;
 };
 
 #endif // QMITKUSNAVIGATIONABSTRACTSETTINGSWIDGET_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.h
index 32692345c0..0422d73748 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.h
@@ -1,53 +1,53 @@
 /*===================================================================
 
 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 QMITKUSNAVIGATIONCOMBINEDSETTINGSWIDGET_H
 #define QMITKUSNAVIGATIONCOMBINEDSETTINGSWIDGET_H
 
 #include "QmitkUSNavigationAbstractSettingsWidget.h"
 #include "mitkDataNode.h"
 
 namespace Ui {
 class QmitkUSNavigationCombinedSettingsWidget;
 }
 
 /**
  * \brief Settings widget for the USNavigationMarkerPlacement.
  * This widgets allows for configuring the experiment mode and for changing the
  * application between marker placement and punctuation.
  */
 class QmitkUSNavigationCombinedSettingsWidget : public QmitkUSNavigationAbstractSettingsWidget
 {
   Q_OBJECT
 
 protected slots:
   void OnApplicationChanged(int);
 
 public:
-  explicit QmitkUSNavigationCombinedSettingsWidget(QWidget *parent = 0);
+  explicit QmitkUSNavigationCombinedSettingsWidget(QWidget *parent = nullptr);
   ~QmitkUSNavigationCombinedSettingsWidget() override;
   void OnSetSettingsNode(itk::SmartPointer<mitk::DataNode> settingsNode, bool overwriteValues) override;
 
 protected:
   void OnSaveProcessing() override;
   void OnLoadSettingsProcessing() override;
 
   QString InteractionNameToFile(const QString& name) const;
 
 private:
   Ui::QmitkUSNavigationCombinedSettingsWidget *ui;
 };
 
 #endif // QMITKUSNAVIGATIONCOMBINEDSETTINGSWIDGET_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSCombinedModalityCreationWidget.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSCombinedModalityCreationWidget.h
index 8ff71a5178..29e223c124 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSCombinedModalityCreationWidget.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSCombinedModalityCreationWidget.h
@@ -1,64 +1,64 @@
 /*===================================================================
 
 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 QMITKUSCOMBINEDMODALITYCREATIONWIDGET_H
 #define QMITKUSCOMBINEDMODALITYCREATIONWIDGET_H
 
 #include <QWidget>
 
 #include "mitkUSCombinedModality.h"
 
 namespace Ui {
 class QmitkUSCombinedModalityCreationWidget;
 }
 
 /**
  * \brief Widget that enables the user to create a mitk::USCombinedModality of a mitk::NavigationDataSource and a mitk::USDevice.
  * A mitk::NavigationDataSource and a mitk::USDevice can be picked from two lists, showing
  * the corresponding micro service objects. The combined modality is registered as a micro
  * service as well during the creation process.
  */
 class QmitkUSCombinedModalityCreationWidget : public QWidget
 {
   Q_OBJECT
 
 signals:
   /** \brief Emmited when the user clicks the "Cancel" button. */
   void SignalAborted();
 
   /** \brief Emmited when the user clicked the "Create" button and the creation is successfull. */
   void SignalCreated(mitk::USCombinedModality::Pointer combinedModality);
 
   /** \brief Emmited when the user clicked the "Create" button and the creation is successfull. */
   void SignalCreated();
 
 protected slots:
   /** \brief Creates a combined modility of the selected mitk::NavigationDataSource and mitk::USDevice. **/
   void OnCreation();
 
   /** \brief Handles the enabled state of the "Create" button. **/
   void OnSelectedUltrasoundOrTrackingDevice();
 
 public:
-  explicit QmitkUSCombinedModalityCreationWidget(QWidget *parent = 0);
+  explicit QmitkUSCombinedModalityCreationWidget(QWidget *parent = nullptr);
   ~QmitkUSCombinedModalityCreationWidget() override;
 
 private:
   Ui::QmitkUSCombinedModalityCreationWidget *ui;
 
   itk::SmartPointer<mitk::AbstractUltrasoundTrackerDevice> m_CombinedModality;
 };
 
 #endif // QMITKUSCOMBINEDMODALITYCREATIONWIDGET_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSCombinedModalityEditWidget.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSCombinedModalityEditWidget.h
index a17dfbe7a3..b0f9afcef8 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSCombinedModalityEditWidget.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSCombinedModalityEditWidget.h
@@ -1,61 +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 QMITKUSCOMBINEDMODALITYEDITWIDGET_H
 #define QMITKUSCOMBINEDMODALITYEDITWIDGET_H
 
 #include <QWidget>
 
 #include "mitkUSCombinedModality.h"
 
 namespace Ui {
 class QmitkUSCombinedModalityEditWidget;
 }
 
 class QmitkUSNavigationCalibrationsDataModel;
 class QmitkUSNavigationCalibrationUpdateDepthDelegate;
 
 class QmitkUSCombinedModalityEditWidget : public QWidget
 {
   Q_OBJECT
 
 signals:
   void SignalSaved();
   void SignalAborted();
 
 protected slots:
   void OnSaveButtonClicked();
   void OnCancelButtonClicked();
   void OnCalibrationsSaveButtonClicked();
   void OnCalibrationsLoadButtonClicked();
 
 public:
-  explicit QmitkUSCombinedModalityEditWidget(QWidget *parent = 0);
+  explicit QmitkUSCombinedModalityEditWidget(QWidget *parent = nullptr);
   ~QmitkUSCombinedModalityEditWidget() override;
 
   void SetCombinedModality(mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality);
 
 private:
   mitk::AbstractUltrasoundTrackerDevice::Pointer                m_CombinedModality;
 
   std::string                                      m_LastCalibrations;
 
   QmitkUSNavigationCalibrationsDataModel*          m_CalibrationsDataModel;
   QmitkUSNavigationCalibrationUpdateDepthDelegate* m_CalibrationUpdateDepthDelegate;
 
   Ui::QmitkUSCombinedModalityEditWidget*           ui;
 };
 
 #endif // QMITKUSCOMBINEDMODALITYEDITWIDGET_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSNavigationFreezeButton.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSNavigationFreezeButton.h
index 75195ba02b..2e225956e4 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSNavigationFreezeButton.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSNavigationFreezeButton.h
@@ -1,81 +1,81 @@
 /*===================================================================
 
 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 QMITKUSNAVIGATIONFREEZEBUTTON_H
 #define QMITKUSNAVIGATIONFREEZEBUTTON_H
 
 #include <QPushButton>
 
 #include "mitkUSCombinedModality.h"
 
 /**
  * \brief QPushButton for freezing and unfreezing a combined modality.
  * The button already has an icon and a text. On every successfull
  * freeze or unfreeze the signal SignalFrezzed() is emitted. One should
  * listen to this signal rather than to the clicked() signal of the
  * QPushButton as the combined modality may not be freezed after
  * clicked() was emitted.
  */
 class QmitkUSNavigationFreezeButton : public QPushButton
 {
   Q_OBJECT
 
 signals:
   /**
    * \brief Emitted every time the freeze state of the combined modality changed.
    * True if the combined modality is freezed now, false if it isn't.
    */
   void SignalFreezed(bool);
 
 protected slots:
   void OnButtonClicked(bool checked);
   void OnFreezeButtonToggle();
 
 public:
-  explicit QmitkUSNavigationFreezeButton(QWidget* parent = 0);
+  explicit QmitkUSNavigationFreezeButton(QWidget* parent = nullptr);
   ~QmitkUSNavigationFreezeButton() override;
 
   /**
    * \brief Setter for the combined modality to be freezed by this button.
    * An index may be specified for a tracking data output. The combined
    * modality will only be freezed then, if the current tracking data of
    * this output is valid.
    */
   void SetCombinedModality(mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality, int outputIndex = -1);
 
   /**
    * \brief Try to freeze the combined modality.
    * This does the same as clicking the button while the combined
    * modality isn't freezed. If the combined modality is already
    * freezed this method does nothing.
    */
   void Freeze();
 
   /**
    * \brief Unfreeze the combined modality.
    * This does the same as clicking the button while the combined
    * modality is freezed. If the combined modality isn't freezed
    * this method does nothing.
    */
   void Unfreeze();
 
 private:
   mitk::AbstractUltrasoundTrackerDevice::Pointer m_CombinedModality;
   int                               m_OutputIndex;
   bool m_FreezeButtonToggle;
 };
 
 #endif // QMITKUSNAVIGATIONFREEZEBUTTON_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSNavigationZoneDistancesWidget.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSNavigationZoneDistancesWidget.h
index 38f69aa988..73da36eca2 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSNavigationZoneDistancesWidget.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSNavigationZoneDistancesWidget.h
@@ -1,77 +1,77 @@
 /*===================================================================
 
 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 QMITKUSNAVIGATIONZONEDISTANCESWIDGET_H
 #define QMITKUSNAVIGATIONZONEDISTANCESWIDGET_H
 
 #include <QWidget>
 
 #include "mitkNumericTypes.h"
 
 namespace itk {
   template<class T> class SmartPointer;
 }
 
 namespace mitk {
   class NavigationData;
   class DataNode;
 }
 
 class QmitkZoneProgressBar;
 
 /**
  * \brief Widget for showing distances to given zones using instances of QmitkZoneProgressBar.
  * The zones can be added by AddZone() and removed by ClearZones(). To update
  * the progress bars, UpdateDistancesToNeedlePosition() has to be called with
  * a navigation data.
  */
 class QmitkUSNavigationZoneDistancesWidget : public QWidget
 {
   Q_OBJECT
 
 signals:
   /** \brief Emmited whenever a the distance to a zone falls below zero. */
   void SignalZoneViolated(const mitk::DataNode*, mitk::Point3D);
 
 public:
-  explicit QmitkUSNavigationZoneDistancesWidget(QWidget *parent = 0);
+  explicit QmitkUSNavigationZoneDistancesWidget(QWidget *parent = nullptr);
   ~QmitkUSNavigationZoneDistancesWidget() override;
 
   /**
    * \brief Set the key for the data node float property holding the radius of a zone.
    * The default value of this attribute is "zone.size".
    */
   void SetSizePropertyKey(const std::string& sizePropertyKey);
 
   /** \brief Get the key for the data node float property holding the radius of a zone. */
   const std::string& GetSizePropertyKey() const;
 
   /** \brief Adds a zone to the widget. */
   void AddZone(itk::SmartPointer<mitk::DataNode> zoneNode);
 
   /** \brief Removes all zones from the widget. */
   void ClearZones();
 
   /** \brief Updates color and label of each zone distance bar according to the given needle position. */
   void UpdateDistancesToNeedlePosition(itk::SmartPointer<mitk::NavigationData> needle);
 
 protected:
   std::string                                     m_SizePropertyKey;
   QVector<itk::SmartPointer<mitk::DataNode> >     m_ZoneNodes;
   QVector<QmitkZoneProgressBar*>                  m_ZoneProgressBars;
 };
 
 #endif // QMITKUSNAVIGATIONZONEDISTANCESWIDGET_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSZoneManagementWidget.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSZoneManagementWidget.h
index 4b09d35960..891ee27cbc 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSZoneManagementWidget.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkUSZoneManagementWidget.h
@@ -1,154 +1,154 @@
 /*===================================================================
 
 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 QMITKUSZONEMANAGEMENTWIDGET_H
 #define QMITKUSZONEMANAGEMENTWIDGET_H
 
 #include <QWidget>
 #include "mitkDataStorage.h"
 
 namespace itk {
 template<class T> class SmartPointer;
 }
 
 namespace mitk {
 class USZonesInteractor;
 }
 
 namespace Ui {
 class QmitkUSZoneManagementWidget;
 }
 
 class QmitkUSZonesDataModel;
 class QItemSelection;
 class QModelIndex;
 
 /**
  * \brief Shows a table of the zone nodes and allows to change properties and add and delete zone nodes.
  *
  * A data node interactor (mitk::USZonesInteractor) is used for creating new zone nodes and a QTableModel
  * (QmitkUSZonesDataModel) is used for handling the zones data.
  *
  * When using the widget, one has to call OnStartAddingZone() every time he wants the interaction for adding
  * new zone nodes to be active.
  */
 class QmitkUSZoneManagementWidget : public QWidget
 {
   Q_OBJECT
 
 signals:
   /**
    * \brief Emmited whenever a new zone was added to the data model.
    */
   void ZoneAdded();
 
   /**
    * \brief Emmited whenever a new zone was removed from the data mode.
    */
   void ZoneRemoved();
 
 public slots:
   /**
    * \brief Removes all rows from the data model which are selected in the table.
    */
   void RemoveSelectedRows();
 
   /**
    * \brief Creates a new zone node and activates the data interactor on this node.
    * This slot has to be called whenever a new zone should be added. Interactions are active
    * then, so the user can create the zone.
    */
   void OnStartAddingZone();
 
   /**
    * \brief Aborts the creation of a new zone and deletes the corresponding node.
    */
   void OnAbortAddingZone();
 
   /**
    * \brief Removes all nodes from the data model.
    */
   void OnResetZones();
 
 protected slots:
   void OnSelectionChanged(const QItemSelection& selected, const QItemSelection & deselected);
 
   /**
    * \brief Updates zone radius according to the value of the zone size slider.
    * \param value new radius of the zone
    */
   void OnZoneSizeSliderValueChanged(int value);
 
   /**
    * \brief Updates maximum number of added zones and selects the last row of the table.
    * It is called every time a row was added to the data model.
    */
   void OnRowInsertion(const QModelIndex& parent, int start, int end);
 
   /**
    * \brief Updates the zone size slider when data was changed.
    * It is called every time a row was changed in the data model.
    */
   void OnDataChanged(const QModelIndex& topLeft, const QModelIndex& /*bottomRight*/);
 
 public:
-  explicit QmitkUSZoneManagementWidget(QWidget* parent = 0);
+  explicit QmitkUSZoneManagementWidget(QWidget* parent = nullptr);
   ~QmitkUSZoneManagementWidget() override;
 
   /**
    * \brief Sets the state machine file for being used by the mitk::USZonesInteractor
    * \param filename name of the state machine file
    */
   void SetStateMachineFilename(const std::string& filename);
 
   /**
    * \brief Setter for the DataStorage where the zone nodes will be stored.
    * The nodes will be derivates of the node specified by the base node name.
    *
    * \param dataStorage data storage where the zone nodes will be stored
    * \param baseNodeName optional name of the node which will be the source node of all zone nodes (defaults "Zones")
    */
   void SetDataStorage(mitk::DataStorage::Pointer dataStorage, const char* baseNodeName = "Zones");
 
   /**
    * \brief Setter for the DataStorage where the zone nodes will be stored.
    * The nodes will be derivates of the base nodes.
    *
    * \param dataStorage data storage where the zone nodes will be strored
    * \param baseNode data node which will be the source node of all zone nodes
    */
   void SetDataStorage(mitk::DataStorage::Pointer dataStorage, itk::SmartPointer<mitk::DataNode> baseNode);
 
   /**
    * \brief Get all zone nodes from the data storage.
    */
   mitk::DataStorage::SetOfObjects::ConstPointer GetZoneNodes();
 
 protected:
   QmitkUSZonesDataModel*                      m_ZonesDataModel;
 
   itk::SmartPointer<mitk::USZonesInteractor>  m_Interactor;
   mitk::DataStorage::Pointer                  m_DataStorage;
   mitk::DataNode::Pointer                     m_BaseNode;
 
   std::string                                 m_StateMachineFileName;
 
 private:
   Ui::QmitkUSZoneManagementWidget* ui;
 
   unsigned int m_CurMaxNumOfZones;
 };
 
 #endif // QMITKUSZONEMANAGEMENTWIDGET_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkZoneProgressBar.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkZoneProgressBar.h
index 2e1e0fc4ee..271a3f234d 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkZoneProgressBar.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/Widgets/QmitkZoneProgressBar.h
@@ -1,102 +1,102 @@
 /*===================================================================
 
 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 QMITKZONEPROGRESSBAR_H
 #define QMITKZONEPROGRESSBAR_H
 
 #include <QProgressBar>
 
 /**
  * \brief QProgressBar for displaying distances to zones.
  * Colors are changed according to the distance to the zone and and the
  * progress will be filled more the smaller the distance to the zone
  * becomes.
  */
 class QmitkZoneProgressBar : public QProgressBar
 {
   Q_OBJECT
 public:
   /**
    * \brief Initializes the progress bar with the given name, max range and warn range.
    * The colors are set to default values (color: red, warn color: red, border
    * color: gray).
    *
    * \param name will be shown on the progress bar
    * \param maxRange the progress bar will be empty for distances greater or equal to this distance
    * \param warnRange the progess bar will change its color for distances smaller than this distance
    */
-  explicit QmitkZoneProgressBar(QString name, int maxRange, int warnRange, QWidget *parent = 0);
+  explicit QmitkZoneProgressBar(QString name, int maxRange, int warnRange, QWidget *parent = nullptr);
 
   /**
    * @param value the current distance to the zone
    */
   void setValue(int value);
 
   /**
    * \brief Can be called to indicate that there is currently no valid distance value available.
    * E.g. if tracking data is not available at the moment. If there is a valid
    * value again, the method setValue() can be called.
    */
   void setValueInvalid();
 
   /**
    * \brief Setter for the text on the progress bar.
    * Defaults to the string given as name to the constructor. The format string
    * can contain '%1' which will be replaced by the current distance value.
    *
    * \param format the text to be displayed on the progress bar
    */
   void SetTextFormatValid(QString format);
 
   /**
    * \param format the text to be displayed when setValueInvalid() was called
    */
   void SetTextFormatInvalid(QString format);
 
   /**
    * \param color the color for the progress bar fill
    */
   void SetColor(float color[3]);
 
   /**
    * \param color the color, the progress bar fill changes to if the distance falls below the warn range
    */
   void SetWarnColor(float color[3]);
 
   /**
    * @param color the color for the border of the progress bar
    */
   void SetBorderColor(float color[3]);
 
 protected:
   void UpdateStyleSheet(QString startColor, QString stopColor);
 
   QString ColorToString(float color[3]);
 
   QString m_TextFormatValid;
   QString m_TextFormatInvalid;
 
   int     m_MaxRange;
   int     m_WarnRange;
 
   QString m_ColorString;
   QString m_WarnColorString;
   QString m_BorderColorString;
 
   QString m_StyleSheet;
 };
 
 #endif // QMITKZONEPROGRESSBAR_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/org_mbi_gui_qt_usnavigation_Activator.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/org_mbi_gui_qt_usnavigation_Activator.cpp
index 9bdb0186f7..0c45033a50 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/org_mbi_gui_qt_usnavigation_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/org_mbi_gui_qt_usnavigation_Activator.cpp
@@ -1,57 +1,57 @@
 /*===================================================================
 
 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 "org_mbi_gui_qt_usnavigation_Activator.h"
 
 #include <usModuleInitialization.h>
 
 #include "QmitkUltrasoundCalibration.h"
 #include "QmitkUSNavigationMarkerPlacement.h"
 #include "QmitkUSNavigationPerspective.h"
 
 #include "mitkVirtualTrackingDevice.h"
 
 namespace mitk {
-  ctkPluginContext* org_mbi_gui_qt_usnavigation_Activator::m_Context = 0;
+  ctkPluginContext* org_mbi_gui_qt_usnavigation_Activator::m_Context = nullptr;
 
   void org_mbi_gui_qt_usnavigation_Activator::start(ctkPluginContext* context)
   {
     m_Context = context;
 
     BERRY_REGISTER_EXTENSION_CLASS(QmitkUltrasoundCalibration, context)
     BERRY_REGISTER_EXTENSION_CLASS(QmitkUSNavigationMarkerPlacement, context)
     BERRY_REGISTER_EXTENSION_CLASS(QmitkUSNavigationPerspective, context)
 
     // create a combined modality persistence object for loading and storing
     // combined modality objects persistently
     m_USCombinedModalityPersistence = mitk::USNavigationCombinedModalityPersistence::New();
   }
 
   void org_mbi_gui_qt_usnavigation_Activator::stop(ctkPluginContext*)
   {
-    m_USCombinedModalityPersistence = 0;
-    m_Context = 0;
+    m_USCombinedModalityPersistence = nullptr;
+    m_Context = nullptr;
   }
 
   ctkPluginContext *org_mbi_gui_qt_usnavigation_Activator::GetContext()
   {
     return m_Context;
   }
 }
 
 // necessary for us::GetModuleContext() in USNavigationCombinedModalityPersistence
 // (see: https://www.mail-archive.com/mitk-users@lists.sourceforge.net/msg04421.html)
 US_INITIALIZE_MODULE
diff --git a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/OpenIGTLinkProviderExample.cpp b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/OpenIGTLinkProviderExample.cpp
index d41c6c4429..4d06d3c69d 100644
--- a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/OpenIGTLinkProviderExample.cpp
+++ b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/OpenIGTLinkProviderExample.cpp
@@ -1,282 +1,282 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkRenderWindow.h"
 
 // Qt
 #include <QMessageBox>
 #include <QFileDialog>
 
 // mitk
 #include <mitkImage.h>
 #include <mitkSurface.h>
 //#include <mitkIGTLMessageToNavigationDataFilter.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkIOUtil.h>
 
 // vtk
 #include <vtkSphereSource.h>
 
 //
 #include "OpenIGTLinkProviderExample.h"
 
 //igtl
 #include "igtlStringMessage.h"
 
 
 const std::string OpenIGTLinkProviderExample::VIEW_ID =
     "org.mitk.views.OpenIGTLinkProviderExample";
 
 OpenIGTLinkProviderExample::~OpenIGTLinkProviderExample()
 {
    this->DestroyPipeline();
    if (m_IGTLMessageProvider.IsNotNull())
    {
       m_IGTLMessageProvider->UnRegisterMicroservice();
    }
    if (m_NavDataToIGTLMsgFilter.IsNotNull())
    {
       m_NavDataToIGTLMsgFilter->UnRegisterMicroservice();
    }
 }
 
 void OpenIGTLinkProviderExample::SetFocus()
 {
 }
 
 void OpenIGTLinkProviderExample::CreateQtPartControl( QWidget *parent )
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
 
   // connect the widget items with the methods
   connect( m_Controls.butStart, SIGNAL(clicked()),
            this, SLOT(Start()) );
   connect( m_Controls.butOpenNavData, SIGNAL(clicked()),
            this, SLOT(OnOpenFile()) );
   connect( &m_VisualizerTimer, SIGNAL(timeout()),
            this, SLOT(UpdateVisualization()));
 
 
   //create a new OpenIGTLink Client
   m_IGTLServer = mitk::IGTLServer::New(false);
   m_IGTLServer->SetName("OIGTL Provider Example Device");
 
   //create a new OpenIGTLink Device source
   m_IGTLMessageProvider = mitk::IGTLMessageProvider::New();
 
   //set the OpenIGTLink server as the source for the device source
   m_IGTLMessageProvider->SetIGTLDevice(m_IGTLServer);
 
   //register the provider so that it can be configured with the IGTL manager
   //plugin. This could be hardcoded but now I already have the fancy plugin.
   m_IGTLMessageProvider->RegisterAsMicroservice();
 }
 
 void OpenIGTLinkProviderExample::CreatePipeline()
 {
   //create a navigation data player object that will play nav data from a
   //recorded file
   m_NavDataPlayer = mitk::NavigationDataSequentialPlayer::New();
 
   //set the currently read navigation data set
   m_NavDataPlayer->SetNavigationDataSet(m_NavDataSet);
 
   //create a filter that converts navigation data into IGTL messages
   m_NavDataToIGTLMsgFilter = mitk::NavigationDataToIGTLMessageFilter::New();
 
   //connect the filters with each other
   //the navigation data player reads a file with recorded navigation data,
   //passes this data to a filter that converts it into a IGTLMessage.
   //The provider is not connected because it will search for fitting services.
   //Once it found the filter it will automatically connect to it.
   m_NavDataToIGTLMsgFilter->ConnectTo(m_NavDataPlayer);
 
   //define the operation mode for this filter, we want to send tracking data
   //messages
   m_NavDataToIGTLMsgFilter->SetOperationMode(
     mitk::NavigationDataToIGTLMessageFilter::ModeSendTDataMsg);
   //       mitk::NavigationDataToIGTLMessageFilter::ModeSendTransMsg);
 
   //set the name of this filter to identify it easier
   m_NavDataToIGTLMsgFilter->SetName("Tracking Data Source From Example");
 
   //register this filter as micro service. The message provider looks for
   //provided IGTLMessageSources, once it found this microservice and someone
   //requested this data type then the provider will connect with this filter
   //automatically.
   m_NavDataToIGTLMsgFilter->RegisterAsMicroservice();
 
   //also create a visualize filter to visualize the data
   m_NavDataVisualizer = mitk::NavigationDataObjectVisualizationFilter::New();
 
   //create an object that will be moved respectively to the navigation data
   for (size_t i = 0; i < m_NavDataPlayer->GetNumberOfIndexedOutputs(); i++)
   {
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     QString name("DemoNode IGTLProviderExmpl T");
     name.append(QString::number(i));
     newNode->SetName(name.toStdString());
 
     //create small sphere and use it as surface
     mitk::Surface::Pointer mySphere = mitk::Surface::New();
     vtkSmartPointer<vtkSphereSource> vtkData = vtkSmartPointer<vtkSphereSource>::New();
     vtkData->SetRadius(2.0f);
     vtkData->SetCenter(0.0, 0.0, 0.0);
     vtkData->Update();
     mySphere->SetVtkPolyData(vtkData->GetOutput());
     newNode->SetData(mySphere);
 
     this->GetDataStorage()->Add(newNode);
 
     m_NavDataVisualizer->SetRepresentationObject(i, mySphere);
 
     m_DemoNodes.append(newNode);
   }
 
   //connect the visualization with the navigation data player
   m_NavDataVisualizer->ConnectTo(m_NavDataPlayer);
 
   //start the player
   this->Start();
 
   //resize the boundaries
   this->m_NavDataVisualizer->Update();
   this->ResizeBoundingBox();
 }
 
 void OpenIGTLinkProviderExample::DestroyPipeline()
 {
    if (m_NavDataPlayer.IsNotNull())
    {
       //m_NavDataPlayer->StopPlaying();
    }
    foreach(mitk::DataNode::Pointer node, m_DemoNodes)
    {
       this->GetDataStorage()->Remove(node);
    }
    this->m_DemoNodes.clear();
 }
 
 void OpenIGTLinkProviderExample::Start()
 {
   if ( this->m_Controls.butStart->text().contains("Start") )
   {
     m_NavDataPlayer->SetRepeat(true);
     //m_NavDataPlayer->StartPlaying();
     this->m_Controls.butStart->setText("Stop Playing Recorded Navigation Data ");
 
     //start the visualization
     double fps = m_Controls.m_updateRate->value();
     double millisecondsPerFrame = 1 / fps * 1000;
 
     this->m_VisualizerTimer.start(millisecondsPerFrame);
   }
   else
   {
     //m_NavDataPlayer->StopPlaying();
     this->m_Controls.butStart->setText("Start Playing Recorded Navigation Data ");
 
     //stop the visualization
     this->m_VisualizerTimer.stop();
   }
 }
 
 void OpenIGTLinkProviderExample::OnOpenFile(){
 
   // FIXME Filter for correct files and use correct Reader
   QString filter = tr("NavigationData File (*.csv *.xml)");
   QString fileName = QFileDialog::getOpenFileName(nullptr, tr("Open NavigationData Set"), "", filter);
 
   if ( fileName.isNull() ) { return; } // user pressed cancel
 
   try
   {
     m_NavDataSet = dynamic_cast<mitk::NavigationDataSet*> (mitk::IOUtil::Load(fileName.toStdString())[0].GetPointer());
   }
   catch ( const mitk::Exception &e )
   {
     MITK_WARN("NavigationDataPlayerView") << "could not open file " << fileName.toStdString();
-    QMessageBox::critical(0, "Error Reading File", "The file '" + fileName
+    QMessageBox::critical(nullptr, "Error Reading File", "The file '" + fileName
                           +"' could not be read.\n" + e.GetDescription() );
     return;
   }
 
   this->m_Controls.butStart->setEnabled(true);
 
   //Setup the pipeline
   this->CreatePipeline();
 
   // Update Labels
 //  m_Controls->m_LblFilePath->setText(fileName);
 //  m_Controls->m_LblTools->setText(QString::number(m_NavDataSet->GetNumberOfTools()));
 }
 
 void OpenIGTLinkProviderExample::UpdateVisualization()
 {
   this->m_NavDataPlayer->GoToNextSnapshot();
   if (this->m_Controls.visualizeCheckBox->isChecked())
   {
     //update the filter
     this->m_NavDataVisualizer->Update();
 
     ////update the bounds
     //mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
 
     //update rendering
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 /**
 * \brief To initialize the scene to the bounding box of all visible objects
 */
 void OpenIGTLinkProviderExample::ResizeBoundingBox()
 {
   // get all nodes
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetAll();
   auto bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs)->Clone();
 
   if (bounds.IsNull())
   {
     return;
   }
 
   //expand the bounding box in case the instruments are all at one position
   mitk::Point3D center = bounds->GetCenterInWorld();
   mitk::Geometry3D::BoundsArrayType extended_bounds = bounds->GetGeometryForTimeStep(0)->GetBounds();
   for (unsigned int i = 0; i < 3; ++i)
   {
     if (bounds->GetExtentInWorld(i) < 500)
     {
       // extend the bounding box
       extended_bounds[i * 2] = center[i] - 500 / 2.0;
       extended_bounds[i * 2 + 1] = center[i] + 500 / 2.0;
     }
   }
   //set the extended bounds
   bounds->GetGeometryForTimeStep(0)->SetBounds(extended_bounds);
 
   // initialize the views to the bounding geometry
   mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 }
diff --git a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp
index 0c651095d4..134c0d9677 100644
--- a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp
+++ b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp
@@ -1,731 +1,731 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkIGTTrackingLabView.h"
 
 #include <QmitkNDIConfigurationWidget.h>
 #include <QmitkFiducialRegistrationWidget.h>
 #include <QmitkUpdateTimerWidget.h>
 #include <QmitkToolSelectionWidget.h>
 #include <QmitkToolTrackingStatusWidget.h>
 #include <mitkStaticIGTHelperFunctions.h>
 
 #include <mitkIGTException.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateDataType.h>
 #include <itkVector.h>
 
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkAppendPolyData.h>
 #include <vtkPoints.h>
 
 // Qt
 #include <QMessageBox>
 #include <QIcon>
 #include <QPushButton>
 
 // vtk
 #include <mitkVtkResliceInterpolationProperty.h>
 
 
 const std::string QmitkIGTTrackingLabView::VIEW_ID = "org.mitk.views.igttrackinglab";
 
 QmitkIGTTrackingLabView::QmitkIGTTrackingLabView()
 : QmitkAbstractView()
 ,m_Source(nullptr)
 ,m_PermanentRegistrationFilter(nullptr)
 ,m_Visualizer(nullptr)
 ,m_VirtualView(nullptr)
 ,m_PSRecordingPointSet(nullptr)
 ,m_PointSetRecording(false)
 ,m_PermanentRegistration(false)
 ,m_CameraView(false)
 ,m_ImageFiducialsDataNode(nullptr)
 ,m_TrackerFiducialsDataNode(nullptr)
 ,m_PermanentRegistrationSourcePoints(nullptr)
 {
 }
 
 //###############################################################################################
 //###############################################################################################
 //############################## Timer method for IGT pipeline updating #########################
 //###############################################################################################
 //###############################################################################################
 
 void QmitkIGTTrackingLabView::UpdateTimer()
 {
   if (m_PermanentRegistration && m_PermanentRegistrationFilter.IsNotNull())
   {
     if(IsTransformDifferenceHigh(m_ObjectmarkerNavigationData, m_ObjectmarkerNavigationDataLastUpdate))
     {
       m_ObjectmarkerNavigationDataLastUpdate->Graft(m_ObjectmarkerNavigationData);
       m_PermanentRegistrationFilter->Update();
     }
   }
 
   if (m_CameraView && m_VirtualView.IsNotNull()) {m_VirtualView->Update();}
 
   if(m_PointSetRecording && m_PSRecordingPointSet.IsNotNull())
     {
       int size = m_PSRecordingPointSet->GetSize();
       mitk::NavigationData::Pointer nd = m_PointSetRecordingNavigationData;
 
       if(size > 0)
       {
         mitk::Point3D p = m_PSRecordingPointSet->GetPoint(size-1);
         if(p.EuclideanDistanceTo(nd->GetPosition()) > (double) m_Controls.m_PSRecordingSpinBox->value())
           m_PSRecordingPointSet->InsertPoint(size, nd->GetPosition());
       }
       else
         m_PSRecordingPointSet->InsertPoint(size, nd->GetPosition());
     }
   }
 
 //###############################################################################################
 //###############################################################################################
 //############################## Slots of CONFIGURATION step ####################################
 //###############################################################################################
 //###############################################################################################
 
 void QmitkIGTTrackingLabView::OnSetupNavigation()
 {
   if(m_Source.IsNotNull())
     if(m_Source->IsTracking())
       return;
 
   mitk::DataStorage* ds = this->GetDataStorage();
 
   if(ds == nullptr)
   {
     MITK_WARN << "IGTSurfaceTracker: Error. Cannot access DataStorage. Navigation not possible";
     return;
   }
 
   //Building up the filter pipeline
   try
   {
     this->InitializeRegistration();
   }
   catch(mitk::IGTException& e)
   {
     MITK_WARN << "Error while building the IGT-Pipeline: " << e.GetDescription();
     this->DestroyIGTPipeline(); // destroy the pipeline if building is incomplete
     return;
   }
   catch(...)
   {
     MITK_WARN << "Unexpected error while building the IGT-Pipeline";
     this->DestroyIGTPipeline();
     return;
   }
 }
 
 void QmitkIGTTrackingLabView::OnInstrumentSelected()
 {
   if (m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedNavigationDataSource().IsNotNull())
     {
     m_InstrumentNavigationData = m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedToolID());
     }
   else
     {
     m_Controls.m_PointerNameLabel->setText("<not available>");
     return;
     }
 
   if (m_InstrumentNavigationData.IsNotNull())
     {
     m_Controls.m_PointerNameLabel->setText(m_InstrumentNavigationData->GetName());
     }
   else
     {
     m_Controls.m_PointerNameLabel->setText("<not available>");
     }
 }
 
 void QmitkIGTTrackingLabView::OnObjectmarkerSelected()
 {
   if (m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedNavigationDataSource().IsNotNull())
     {
     m_ObjectmarkerNavigationData = m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedToolID());
     MITK_INFO << "Objectmarker rotation: " << m_ObjectmarkerNavigationData->GetOrientation();
     }
   else
     {
     m_Controls.m_ObjectmarkerNameLabel->setText("<not available>");
     return;
     }
 
   if (m_ObjectmarkerNavigationData.IsNotNull())
     {
     m_Controls.m_ObjectmarkerNameLabel->setText(m_ObjectmarkerNavigationData->GetName());
     }
   else
     {
     m_Controls.m_ObjectmarkerNameLabel->setText("<not available>");
     }
 }
 
 //###############################################################################################
 //###############################################################################################
 //####################### Slots of INITIAL REGISTRATION step ####################################
 //###############################################################################################
 //###############################################################################################
 
 void QmitkIGTTrackingLabView::OnInitialRegistration()
 {
   //Check for initialization
   if (!CheckRegistrationInitialization()) return;
 
   mitk::PointSet::Pointer imageFiducials = dynamic_cast<mitk::PointSet*>(m_ImageFiducialsDataNode->GetData());
   mitk::PointSet::Pointer trackerFiducials = dynamic_cast<mitk::PointSet*>(m_TrackerFiducialsDataNode->GetData());
 
   //############### conversion to vtk data types (we will use the vtk landmark based transform) ##########################
   //convert point sets to vtk poly data
   vtkSmartPointer<vtkPoints> sourcePoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkPoints> targetPoints = vtkSmartPointer<vtkPoints>::New();
   for (int i=0; i<imageFiducials->GetSize(); i++)
     {
     double point[3] = {imageFiducials->GetPoint(i)[0],imageFiducials->GetPoint(i)[1],imageFiducials->GetPoint(i)[2]};
     sourcePoints->InsertNextPoint(point);
     double point_targets[3] = {trackerFiducials->GetPoint(i)[0],trackerFiducials->GetPoint(i)[1],trackerFiducials->GetPoint(i)[2]};
     targetPoints->InsertNextPoint(point_targets);
     }
 
   //########################### here, the actual transform is computed ##########################
   //compute transform
   vtkSmartPointer<vtkLandmarkTransform> transform = vtkSmartPointer<vtkLandmarkTransform>::New();
   transform->SetSourceLandmarks(sourcePoints);
   transform->SetTargetLandmarks(targetPoints);
   transform->SetModeToRigidBody();
   transform->Modified();
   transform->Update();
   //compute FRE of transform
   double FRE = mitk::StaticIGTHelperFunctions::ComputeFRE(imageFiducials, trackerFiducials, transform);
   m_Controls.m_RegistrationWidget->SetQualityDisplayText("FRE: " + QString::number(FRE) + " mm");
   //#############################################################################################
 
   //############### conversion back to itk/mitk data types ##########################
   //convert from vtk to itk data types
   itk::Matrix<float,3,3> rotationFloat = itk::Matrix<float,3,3>();
   itk::Vector<float,3> translationFloat = itk::Vector<float,3>();
   itk::Matrix<double,3,3> rotationDouble = itk::Matrix<double,3,3>();
   itk::Vector<double,3> translationDouble = itk::Vector<double,3>();
 
   vtkSmartPointer<vtkMatrix4x4> m = transform->GetMatrix();
   for(int k=0; k<3; k++) for(int l=0; l<3; l++)
   {
     rotationFloat[k][l] = m->GetElement(k,l);
     rotationDouble[k][l] = m->GetElement(k,l);
 
   }
   for(int k=0; k<3; k++)
   {
     translationFloat[k] = m->GetElement(k,3);
     translationDouble[k] = m->GetElement(k,3);
   }
   //create affine transform 3D surface
   mitk::AffineTransform3D::Pointer mitkTransform = mitk::AffineTransform3D::New();
   mitkTransform->SetMatrix(rotationDouble);
   mitkTransform->SetOffset(translationDouble);
   //#############################################################################################
 
   //############### object is transformed ##########################
   //save transform
   m_T_ObjectReg = mitk::NavigationData::New(mitkTransform); // this is stored in a member because it is needed for permanent registration later on
 
   //transform surface
   if(m_Controls.m_SurfaceActive->isChecked() && m_Controls.m_ObjectComboBox->GetSelectedNode().IsNotNull())
   {
     m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(mitkTransform);
   }
   //################################################################
 
   //############### if activated: ct image is also transformed ##########################
   //transform ct image
   //todo: Erklären, dass hier AffineTransform3D verwendet wird, weil NavigationData kein Spacing unterstützt!
   if(m_Controls.m_ImageActive->isChecked() && m_Controls.m_ImageComboBox->GetSelectedNode().IsNotNull())
   {
     //first we have to store the original ct image transform to compose it with the new transform later
     mitk::AffineTransform3D::Pointer imageTransform = m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->GetIndexToWorldTransform();
     m_T_ImageGeo = mitk::AffineTransform3D::New(); // this is also stored in a member because it is needed for permanent registration later on
     //now the new transform of the ct image is computed
     m_T_ImageGeo->Compose(imageTransform);
     imageTransform->Compose(mitkTransform);
     mitk::AffineTransform3D::Pointer newImageTransform = mitk::AffineTransform3D::New(); //create new image transform... setting the composed directly leads to an error
     itk::Matrix<mitk::ScalarType,3,3> rotationFloatNew = imageTransform->GetMatrix();
     itk::Vector<mitk::ScalarType,3> translationFloatNew = imageTransform->GetOffset();
     newImageTransform->SetMatrix(rotationFloatNew);
     newImageTransform->SetOffset(translationFloatNew);
     m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(newImageTransform);
     m_T_ImageReg = m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->GetIndexToWorldTransform();
   }
   //################################################################
 
 }
 
 
 void QmitkIGTTrackingLabView::OnAddRegistrationTrackingFiducial()
 {
   mitk::NavigationData::Pointer nd = m_InstrumentNavigationData;
 
   if( nd.IsNull() || !nd->IsDataValid())
   {
-    QMessageBox::warning( 0, "Invalid tracking data", "Navigation data is not available or invalid!", QMessageBox::Ok );
+    QMessageBox::warning( nullptr, "Invalid tracking data", "Navigation data is not available or invalid!", QMessageBox::Ok );
     return;
   }
 
   if(m_TrackerFiducialsDataNode.IsNotNull() && m_TrackerFiducialsDataNode->GetData() != nullptr)
   {
     mitk::PointSet::Pointer ps = dynamic_cast<mitk::PointSet*>(m_TrackerFiducialsDataNode->GetData());
     ps->InsertPoint(ps->GetSize(), nd->GetPosition());
   }
   else
     QMessageBox::warning(nullptr, "IGTSurfaceTracker: Error", "Can not access Tracker Fiducials. Adding fiducial not possible!");
 }
 
 
 void QmitkIGTTrackingLabView::InitializeRegistration()
 {
   mitk::DataStorage* ds = this->GetDataStorage();
   if( ds == nullptr )
     return;
 
   // let the registration widget know about the slice navigation controllers
   // in the active render window part (crosshair updates)
   foreach(QmitkRenderWindow* renderWindow, this->GetRenderWindowPart()->GetQmitkRenderWindows().values())
   {
     m_Controls.m_RegistrationWidget->AddSliceNavigationController(renderWindow->GetSliceNavigationController());
   }
 
   if(m_ImageFiducialsDataNode.IsNull())
   {
     m_ImageFiducialsDataNode = mitk::DataNode::New();
     mitk::PointSet::Pointer ifPS = mitk::PointSet::New();
 
     m_ImageFiducialsDataNode->SetData(ifPS);
 
     mitk::Color color;
     color.Set(1.0f, 0.0f, 0.0f);
     m_ImageFiducialsDataNode->SetName("Image Fiducials");
     m_ImageFiducialsDataNode->SetColor(color);
     m_ImageFiducialsDataNode->SetBoolProperty( "updateDataOnRender", false );
 
     ds->Add(m_ImageFiducialsDataNode);
   }
   m_Controls.m_RegistrationWidget->SetImageFiducialsNode(m_ImageFiducialsDataNode);
 
   if(m_TrackerFiducialsDataNode.IsNull())
   {
     m_TrackerFiducialsDataNode = mitk::DataNode::New();
     mitk::PointSet::Pointer tfPS = mitk::PointSet::New();
     m_TrackerFiducialsDataNode->SetData(tfPS);
 
     mitk::Color color;
     color.Set(0.0f, 1.0f, 0.0f);
     m_TrackerFiducialsDataNode->SetName("Tracking Fiducials");
     m_TrackerFiducialsDataNode->SetColor(color);
     m_TrackerFiducialsDataNode->SetBoolProperty( "updateDataOnRender", false );
 
     ds->Add(m_TrackerFiducialsDataNode);
   }
 
   m_Controls.m_RegistrationWidget->SetTrackerFiducialsNode(m_TrackerFiducialsDataNode);
 }
 
 //###############################################################################################
 //###############################################################################################
 //####################### Slots of PERMANENT REGISTRATION step ##################################
 //###############################################################################################
 //###############################################################################################
 
 void QmitkIGTTrackingLabView::OnPermanentRegistration(bool on)
 {
   if(on)
     {
     //######################################################################
     //######################## inititalization #############################
     //######################################################################
 
     //some initial checks
     if(!CheckRegistrationInitialization())
     {
       m_Controls.m_UsePermanentRegistrationToggle->setChecked(false);
       return;
     }
 
     //remember initial object transform to calculate the object to marker transform later on and convert it to navigation data
     mitk::AffineTransform3D::Pointer transform = this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->GetIndexToWorldTransform();
     mitk::NavigationData::Pointer T_Object = mitk::NavigationData::New(transform,false); //TODO: catch exception during conversion?
 
     //then reset the transform because we will now start to calculate the permanent registration
     this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIdentity();
     if(m_Controls.m_ImageActive->isChecked()) {this->m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(m_T_ImageGeo);}
 
     //create the permanent registration filter
     m_PermanentRegistrationFilter = mitk::NavigationDataObjectVisualizationFilter::New();
 
     //######################################################################
     //first: initialize permanent registration of surface (always activated)
     //######################################################################
 
     //connect filter to source
     m_PermanentRegistrationFilter->SetInput(0,this->m_ObjectmarkerNavigationData);
 
     //set representation object
     m_PermanentRegistrationFilter->SetRepresentationObject(0,this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData());
 
     //get the marker transform out of the navigation data
     mitk::NavigationData::Pointer T_Marker = m_ObjectmarkerNavigationData;
 
     //compute transform from object to marker (T_MarkerRel = T_Object * T_Marker^-1)
     mitk::NavigationData::Pointer T_MarkerRel = mitk::NavigationData::New();
     T_MarkerRel->Compose(T_Object);
     T_MarkerRel->Compose(T_Marker->GetInverse());
     m_T_MarkerRel = T_MarkerRel;
     m_PermanentRegistrationFilter->SetOffset(0,m_T_MarkerRel->GetAffineTransform3D());
 
     //######################################################################
     //second: initialize permanent registration of image (if activated)
     //######################################################################
     if (m_Controls.m_ImageActive->isChecked() && (m_Controls.m_ImageComboBox->GetSelectedNode().IsNotNull()))
       {
       mitk::DataNode::Pointer imageNode = this->m_Controls.m_ImageComboBox->GetSelectedNode();
       imageNode->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_LINEAR) );
       m_PermanentRegistrationFilter->SetInput(1,this->m_ObjectmarkerNavigationData);
       m_PermanentRegistrationFilter->SetRepresentationObject(1,imageNode->GetData());
 
       //for the image we can't use NavigationData objects as transforms because an image needs additional geometry information, e.g., spacing
       //thus we use mitk::AffineTransform3D objects
 
       //computer transform from image to marker (T_ImageRel = T_ImageGeo * T_MarkerRel)
       mitk::AffineTransform3D::Pointer T_ImageRel = mitk::AffineTransform3D::New();
       T_ImageRel->SetIdentity();
       T_ImageRel->Compose(m_T_ImageGeo);
       T_ImageRel->Compose(m_T_MarkerRel->GetAffineTransform3D());
       m_PermanentRegistrationFilter->SetOffset(1,T_ImageRel);
       }
 
     //some general stuff
     m_PermanentRegistration = true;
     m_ObjectmarkerNavigationDataLastUpdate = mitk::NavigationData::New();
     }
   else //if off = disable the permanent registration
     {
     //stop permanent registration
     m_PermanentRegistration = false;
 
     //restore old registration
     if(m_T_ObjectReg.IsNotNull()) {this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(m_T_ObjectReg->GetAffineTransform3D());}
     if(m_T_ImageReg.IsNotNull()) {this->m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(m_T_ImageReg);}
 
     //delete filter
     m_PermanentRegistrationFilter = nullptr;
     }
 }
 
 //###############################################################################################
 //###############################################################################################
 //####################### Slots of POINT SET RECORDING step #####################################
 //###############################################################################################
 //###############################################################################################
 
 void QmitkIGTTrackingLabView::OnPointSetRecording(bool record)
 {
   mitk::DataStorage* ds = this->GetDataStorage();
 
   if(record)
   {
     if (m_Controls.m_PointSetRecordingToolSelectionWidget->GetSelectedToolID() == -1)
       {
       QMessageBox::warning(nullptr, "Error", "No tool selected for point set recording!");
       m_Controls.m_PointSetRecordCheckBox->setChecked(false);
       return;
       }
     m_PointSetRecordingNavigationData = m_Controls.m_PointSetRecordingToolSelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_Controls.m_PointSetRecordingToolSelectionWidget->GetSelectedToolID());
 
     //initialize point set
     mitk::DataNode::Pointer psRecND = ds->GetNamedNode("Recorded Points");
     if(m_PSRecordingPointSet.IsNull() || psRecND.IsNull())
     {
       m_PSRecordingPointSet = nullptr;
       m_PSRecordingPointSet = mitk::PointSet::New();
       mitk::DataNode::Pointer dn = mitk::DataNode::New();
       dn->SetName("Recorded Points");
       dn->SetColor(0.,1.,0.);
       dn->SetData(m_PSRecordingPointSet);
       ds->Add(dn);
     }
     else
     {
       m_PSRecordingPointSet->Clear();
     }
     m_PointSetRecording = true;
   }
 
   else
   {
     m_PointSetRecording = false;
   }
 }
 
 //###############################################################################################
 //###############################################################################################
 //####################### Slots of VIRTUAL CAMERA VIEW step #####################################
 //###############################################################################################
 //###############################################################################################
 
 void QmitkIGTTrackingLabView::OnVirtualCamera(bool on)
 {
 if (m_Controls.m_CameraViewSelection->GetSelectedToolID() == -1)
     {
     m_Controls.m_ActivateNeedleView->setChecked(false);
     QMessageBox::warning(nullptr, "Error", "No tool selected for camera view!");
     return;
     }
 
 if(on)
   {
   m_VirtualView = mitk::CameraVisualization::New();
   m_VirtualView->SetInput(m_Controls.m_CameraViewSelection->GetSelectedNavigationDataSource()->GetOutput(m_Controls.m_CameraViewSelection->GetSelectedToolID()));
 
   mitk::Vector3D viewDirection;
   viewDirection[0] = (int)(m_Controls.m_NeedleViewX->isChecked());
   viewDirection[1] = (int)(m_Controls.m_NeedleViewY->isChecked());
   viewDirection[2] = (int)(m_Controls.m_NeedleViewZ->isChecked());
   if (m_Controls.m_NeedleViewInvert->isChecked()) viewDirection *= -1;
   m_VirtualView->SetDirectionOfProjectionInToolCoordinates(viewDirection);
 
   mitk::Vector3D viewUpVector;
   viewUpVector[0] = (int)(m_Controls.m_NeedleUpX->isChecked());
   viewUpVector[1] = (int)(m_Controls.m_NeedleUpY->isChecked());
   viewUpVector[2] = (int)(m_Controls.m_NeedleUpZ->isChecked());
   if (m_Controls.m_NeedleUpInvert->isChecked()) viewUpVector *= -1;
   m_VirtualView->SetViewUpInToolCoordinates(viewUpVector);
 
   m_VirtualView->SetRenderer(this->GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderer());
   //next line: better code when this plugin is migrated to mitk::abstractview
   //m_VirtualView->SetRenderer(mitk::BaseRenderer::GetInstance(this->GetRenderWindowPart()->GetRenderWindow("3d")->GetRenderWindow()));
   m_CameraView = true;
 
   //make pointer itself invisible
   m_Controls.m_CameraViewSelection->GetSelectedNavigationTool()->GetDataNode()->SetBoolProperty("visible",false);
 
   //disable UI elements
   m_Controls.m_ViewDirectionBox->setEnabled(false);
   m_Controls.m_ViewUpBox->setEnabled(false);
   }
 else
   {
   m_VirtualView = nullptr;
   m_CameraView = false;
   m_Controls.m_CameraViewSelection->GetSelectedNavigationTool()->GetDataNode()->SetBoolProperty("visible",true);
 
   m_Controls.m_ViewDirectionBox->setEnabled(true);
   m_Controls.m_ViewUpBox->setEnabled(true);
   }
 
 }
 
 //###############################################################################################
 //###############################################################################################
 //############################## some general UI methods, always needed #########################
 //###############################################################################################
 //###############################################################################################
 
 QmitkIGTTrackingLabView::~QmitkIGTTrackingLabView()
 {
   if (m_Timer->isActive()) m_Timer->stop();
 }
 
 void QmitkIGTTrackingLabView::CreateQtPartControl( QWidget *parent )
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
   this->CreateBundleWidgets();
   this->CreateConnections();
 }
 
 
 void QmitkIGTTrackingLabView::CreateBundleWidgets()
 {
   //initialize registration widget
   m_Controls.m_RegistrationWidget->HideStaticRegistrationRadioButton(true);
   m_Controls.m_RegistrationWidget->HideContinousRegistrationRadioButton(true);
   m_Controls.m_RegistrationWidget->HideUseICPRegistrationCheckbox(true);
 }
 
 
 void QmitkIGTTrackingLabView::CreateConnections()
 {
   //initialize timer
   m_Timer = new QTimer(this);
 
   //create connections
   connect(m_Timer, SIGNAL(timeout()), this, SLOT(UpdateTimer()));
   connect( m_Controls.m_UsePermanentRegistrationToggle, SIGNAL(toggled(bool)), this, SLOT(OnPermanentRegistration(bool)) );
   connect( m_Controls.m_TrackingDeviceSelectionWidget, SIGNAL(NavigationDataSourceSelected(mitk::NavigationDataSource::Pointer)), this, SLOT(OnSetupNavigation()) );
   connect( m_Controls.m_UseAsPointerButton, SIGNAL(clicked()), this, SLOT(OnInstrumentSelected()) );
   connect( m_Controls.m_UseAsObjectmarkerButton, SIGNAL(clicked()), this, SLOT(OnObjectmarkerSelected()) );
   connect( m_Controls.m_RegistrationWidget, SIGNAL(AddedTrackingFiducial()), this, SLOT(OnAddRegistrationTrackingFiducial()) );
   connect( m_Controls.m_RegistrationWidget, SIGNAL(PerformFiducialRegistration()), this, SLOT(OnInitialRegistration()) );
   connect( m_Controls.m_PointSetRecordCheckBox, SIGNAL(toggled(bool)), this, SLOT(OnPointSetRecording(bool)) );
   connect( m_Controls.m_ActivateNeedleView, SIGNAL(toggled(bool)), this, SLOT(OnVirtualCamera(bool)) );
 
   //start timer
   m_Timer->start(30);
 
   //initialize Combo Boxes
   m_Controls.m_ObjectComboBox->SetDataStorage(this->GetDataStorage());
   m_Controls.m_ObjectComboBox->SetAutoSelectNewItems(false);
   m_Controls.m_ObjectComboBox->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
 
   m_Controls.m_ImageComboBox->SetDataStorage(this->GetDataStorage());
   m_Controls.m_ImageComboBox->SetAutoSelectNewItems(false);
   m_Controls.m_ImageComboBox->SetPredicate(mitk::NodePredicateDataType::New("Image"));
 }
 
 void QmitkIGTTrackingLabView::SetFocus()
 {
   m_Controls.m_UseAsPointerButton->setFocus();
 }
 
 //###############################################################################################
 //###############################################################################################
 //####################### some additional slots and help methods ################################
 //####################### for cleaner code - not that important  ################################
 //####################### to understand the basic functions      ################################
 //###############################################################################################
 //###############################################################################################
 
 void QmitkIGTTrackingLabView::DestroyIGTPipeline()
 {
   if(m_Source.IsNotNull())
   {
     m_Source->StopTracking();
     m_Source->Disconnect();
     m_Source = nullptr;
   }
   m_PermanentRegistrationFilter = nullptr;
   m_Visualizer = nullptr;
   m_VirtualView = nullptr;
 }
 
 bool QmitkIGTTrackingLabView::CheckRegistrationInitialization()
 {
   // a couple of variables which we need in this method
   std::string warningMessage = "";
   bool initializationErrorDetected = false;
   mitk::PointSet::Pointer imageFiducials,trackerFiducials;
 
   // check some initialization stuff
   if (m_ImageFiducialsDataNode.IsNull() || m_TrackerFiducialsDataNode.IsNull())
   {
     warningMessage = "Initialization not finished!";
     MITK_WARN << warningMessage;
     QMessageBox::warning(nullptr, "Registration not possible", warningMessage.c_str());
     return false;
   }
   else
   {
     imageFiducials = dynamic_cast<mitk::PointSet*>(m_ImageFiducialsDataNode->GetData());
     trackerFiducials = dynamic_cast<mitk::PointSet*>(m_TrackerFiducialsDataNode->GetData());
   }
 
   // now, do a lot of other checks...
   if (m_Controls.m_SurfaceActive->isChecked() && m_Controls.m_ObjectComboBox->GetSelectedNode().IsNull())
   {
     warningMessage = "No surface selected for registration.\nRegistration is not possible";
     initializationErrorDetected = true;
   }
   else if (m_Controls.m_ImageActive->isChecked() && m_Controls.m_ImageComboBox->GetSelectedNode().IsNull())
   {
     warningMessage = "No image selected for registration.\nRegistration is not possible";
     initializationErrorDetected = true;
   }
   else if (imageFiducials.IsNull() || trackerFiducials.IsNull())
   {
    warningMessage = "Fiducial data objects not found. \n"
       "Please set 3 or more fiducials in the image and with the tracking system.\n\n"
       "Registration is not possible";
     initializationErrorDetected = true;
   }
   else if ((imageFiducials->GetSize() < 3) || (trackerFiducials->GetSize() < 3) || (imageFiducials->GetSize() != trackerFiducials->GetSize()))
   {
     warningMessage = "Not enough fiducial pairs found. At least 3 fiducial must exist for the image and the tracking system respectively.";
     initializationErrorDetected = true;
   }
 
   // finaly: if an err was detected, give a warning and an error popup, then return false
   if(initializationErrorDetected)
   {
     MITK_WARN << warningMessage;
     QMessageBox::warning(nullptr, "Registration not possible", warningMessage.c_str());
     return false;
   }
   //if no error was detected simply return true
   else {return true;}
 
 }
 
 bool QmitkIGTTrackingLabView::IsTransformDifferenceHigh(mitk::NavigationData::Pointer transformA, mitk::NavigationData::Pointer transformB, double euclideanDistanceThreshold, double angularDifferenceThreshold)
 {
   if(transformA.IsNull() || transformA.IsNull())
     {return false;}
   mitk::Point3D posA,posB;
   posA = transformA->GetPosition();
   posB = transformB->GetPosition();
 
 
   if(posA.EuclideanDistanceTo(posB) > euclideanDistanceThreshold)
     {return true;}
 
   double returnValue;
   mitk::Quaternion rotA,rotB;
   rotA = transformA->GetOrientation();
   rotB = transformB->GetOrientation();
 
   itk::Vector<double,3> point; //caution 5D-Tools: Vector must lie in the YZ-plane for a correct result.
   point[0] = 0.0;
   point[1] = 0.0;
   point[2] = 100000.0;
 
   rotA.normalize();
   rotB.normalize();
 
   itk::Matrix<double,3,3> rotMatrixA;
   for(int i=0; i<3; i++) for(int j=0; j<3; j++) rotMatrixA[i][j] = rotA.rotation_matrix_transpose().transpose()[i][j];
 
   itk::Matrix<double,3,3> rotMatrixB;
   for(int i=0; i<3; i++) for(int j=0; j<3; j++) rotMatrixB[i][j] = rotB.rotation_matrix_transpose().transpose()[i][j];
 
   itk::Vector<double,3> pt1 = rotMatrixA * point;
   itk::Vector<double,3> pt2 = rotMatrixB * point;
 
   returnValue = (pt1[0]*pt2[0]+pt1[1]*pt2[1]+pt1[2]*pt2[2]) / ( sqrt(pow(pt1[0],2.0)+pow(pt1[1],2.0)+pow(pt1[2],2.0)) * sqrt(pow(pt2[0],2.0)+pow(pt2[1],2.0)+pow(pt2[2],2.0)));
   returnValue = acos(returnValue);
 
   if(returnValue*57.3 > angularDifferenceThreshold){return true;}
 
   return false;
 }
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkIGTNavigationToolCalibration.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkIGTNavigationToolCalibration.cpp
index 961cca9285..f5f8e9e6c5 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkIGTNavigationToolCalibration.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkIGTNavigationToolCalibration.cpp
@@ -1,760 +1,760 @@
 /*===================================================================
 
 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 <numeric>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkIGTNavigationToolCalibration.h"
 
 // mitk
 #include <mitkNavigationToolWriter.h>
 #include <mitkTrackingDeviceSource.h>
 #include <mitkTrackingDevice.h>
 #include <mitkTrackingTool.h>
 #include <mitkQuaternionAveraging.h>
 #include <mitkPivotCalibration.h>
 #include <mitkNavigationData.h>
 
 // Qt
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QFileInfo>
 
 // vtk
 #include <vtkSphereSource.h>
 
 const std::string QmitkIGTNavigationToolCalibration::VIEW_ID = "org.mitk.views.igtnavigationtoolcalibration";
 
 QmitkIGTNavigationToolCalibration::QmitkIGTNavigationToolCalibration()
 {
   m_ToolTransformationWidget = new QmitkInteractiveTransformationWidget();
 }
 
 QmitkIGTNavigationToolCalibration::~QmitkIGTNavigationToolCalibration()
 {
   //The following code is required due to a bug in the point list widget.
   //If this is removed, MITK crashes when closing the view:
   m_Controls.m_RegistrationLandmarkWidget->SetPointSetNode(nullptr);
   m_Controls.m_CalibrationLandmarkWidget->SetPointSetNode(nullptr);
 
   //clean up data storage
   this->GetDataStorage()->Remove(m_ToolTipPointPreview);
 
 
   delete m_ToolTransformationWidget;
 }
 
 void QmitkIGTNavigationToolCalibration::SetFocus()
 {
 
 }
 
 void QmitkIGTNavigationToolCalibration::OnToolCalibrationMethodChanged(int index)
 {
   //if pivot calibration (3) or manual(0) is chosen only calibration pointer is needed
   if (index == 0 || index == 3) {
 
     if (!CheckInitialization(false)) {
       return;
     }
   }
   else{
     if (!CheckInitialization()) { return; }
   }
 
   UpdateManualToolTipCalibrationView();
   m_Controls.m_CalibrationMethodsWidget->setCurrentIndex(index);
   m_IndexCurrentCalibrationMethod = index;
 }
 
 void QmitkIGTNavigationToolCalibration::CreateQtPartControl(QWidget *parent)
 {
   m_TrackingTimer = new QTimer(this);
 
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   connect(m_Controls.m_SetToolToCalibrate, SIGNAL(clicked()), this, SLOT(SetToolToCalibrate()));
   connect(m_Controls.m_SetPointer, SIGNAL(clicked()), this, SLOT(SetCalibrationPointer()));
   connect(m_TrackingTimer, SIGNAL(timeout()), this, SLOT(UpdateTrackingTimer()));
   connect(m_Controls.m_AddLandmark, SIGNAL(clicked()), this, SLOT(AddLandmark()));
   connect(m_Controls.m_SaveCalibratedTool, SIGNAL(clicked()), this, SLOT(SaveCalibratedTool()));
   connect(m_Controls.m_AddPivotPose, SIGNAL(clicked()), this, SLOT(OnAddPivotPose()));
   connect(m_Controls.m_ComputePivot, SIGNAL(clicked()), this, SLOT(OnComputePivot()));
   connect(m_Controls.m_UseComputedPivotPoint, SIGNAL(clicked()), this, SLOT(OnUseComputedPivotPoint()));
   connect(m_Controls.m_StartEditTooltipManually, SIGNAL(clicked()), this, SLOT(OnStartManualToolTipCalibration()));
   connect(m_Controls.m_GetPositions, SIGNAL(clicked()), this, SLOT(OnGetPositions()));
   connect(m_Controls.m_ToolAxis_X, SIGNAL(valueChanged(double)), this, SLOT(OnToolAxisSpinboxChanged()));
   connect(m_Controls.m_ToolAxis_Y, SIGNAL(valueChanged(double)), this, SLOT(OnToolAxisSpinboxChanged()));
   connect(m_Controls.m_ToolAxis_Z, SIGNAL(valueChanged(double)), this, SLOT(OnToolAxisSpinboxChanged()));
   connect(m_Controls.m_CalibrateToolAxis, SIGNAL(clicked()), this, SLOT(OnCalibrateToolAxis()));
   connect((QObject*)(m_ToolTransformationWidget), SIGNAL(EditToolTipFinished(mitk::AffineTransform3D::Pointer)), this,
     SLOT(OnManualEditToolTipFinished(mitk::AffineTransform3D::Pointer)));
   connect(m_Controls.m_CalibrationMethodComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnToolCalibrationMethodChanged(int)));
 
   connect((QObject*)(m_Controls.m_RunCalibrationButton), SIGNAL(clicked()), (QObject*) this, SLOT(OnRunSingleRefToolCalibrationClicked()));
   connect((QObject*)(m_Controls.m_CollectNavigationDataButton), SIGNAL(clicked()), (QObject*) this, SLOT(OnLoginSingleRefToolNavigationDataClicked()));
   connect((QObject*)(m_Controls.m_SetNewToolTipPosButton), SIGNAL(clicked()), (QObject*) this, SLOT(OnSetNewToolTipPosButtonClicked()));
 
   m_IDToolToCalibrate = -1;
   m_IDCalibrationPointer = -1;
   m_IndexCurrentCalibrationMethod = -1;
   m_OnLoginSingleRefToolNavigationDataClicked = false;
   m_NumberOfNavigationDataCounter = 0;
   m_NumberOfNavigationData = -1;
 
   //for pivot calibration
   m_OnAddPivotPoseClicked = false;
   PivotCount = 0;
   m_PivotPoses = std::vector<mitk::NavigationData::Pointer>();
 
   m_CalibrationLandmarks = mitk::PointSet::New();
   m_CalibrationLandmarksNode = mitk::DataNode::New();
   m_CalibrationLandmarksNode->SetData(m_CalibrationLandmarks);
   m_Controls.m_CalibrationLandmarkWidget->SetPointSetNode(m_CalibrationLandmarksNode);
 
   m_RegistrationLandmarks = mitk::PointSet::New();
   m_RegistrationLandmarksNode = mitk::DataNode::New();
   m_RegistrationLandmarksNode->SetData(m_RegistrationLandmarks);
   m_Controls.m_RegistrationLandmarkWidget->SetPointSetNode(m_RegistrationLandmarksNode);
 
   m_ToolSurfaceInToolCoordinatesDataNode = mitk::DataNode::New();
   m_ToolSurfaceInToolCoordinatesDataNode->SetName("ToolSurface(ToolCoordinates)");
 
   m_LoggedNavigationDataDifferences = std::vector< mitk::NavigationData::Pointer >();
 }
 
 
 void QmitkIGTNavigationToolCalibration::OnRunSingleRefToolCalibrationClicked()
 {
   if (!CheckInitialization()) { return; }
 
   mitk::NavigationData::Pointer ToolTipTransform = mitk::NavigationData::New();
 
   if (m_Controls.m_CalibratePosition->isChecked())
   {
     //1: Compute mean translational offset vector
     m_ResultOffsetVector.Fill(0);
     for (std::vector<mitk::Point3D>::iterator vecIter = m_LoggedNavigationDataOffsets.begin(); vecIter != m_LoggedNavigationDataOffsets.end(); vecIter++)
     {
       m_ResultOffsetVector[0] = m_ResultOffsetVector[0] + (*vecIter)[0];
       m_ResultOffsetVector[1] = m_ResultOffsetVector[1] + (*vecIter)[1];
       m_ResultOffsetVector[2] = m_ResultOffsetVector[2] + (*vecIter)[2];
     }
     m_ResultOffsetVector[0] = m_ResultOffsetVector[0] / m_LoggedNavigationDataOffsets.size();
     m_ResultOffsetVector[1] = m_ResultOffsetVector[1] / m_LoggedNavigationDataOffsets.size();
     m_ResultOffsetVector[2] = m_ResultOffsetVector[2] / m_LoggedNavigationDataOffsets.size();
 
     this->m_Controls.m_ResultOfCalibration->setText(
       QString("x: ") + QString(QString::number(m_ResultOffsetVector[0], 103, 3)) +
       QString("; y: ") + (QString::number(m_ResultOffsetVector[1], 103, 3)) +
       QString("; z: ") + (QString::number(m_ResultOffsetVector[2], 103, 3)));
 
     ToolTipTransform->SetPosition(m_ResultOffsetVector);
   }
 
 
   if (m_Controls.m_CalibrateOrientation->isChecked())
   {
     //2: Compute mean orientation
     mitk::Quaternion meanOrientation;
     std::vector <mitk::Quaternion> allOrientations = std::vector <mitk::Quaternion>();
     for (std::size_t i = 0; i < m_LoggedNavigationDataDifferences.size(); i++) { allOrientations.push_back(m_LoggedNavigationDataDifferences.at(i)->GetOrientation()); }
     meanOrientation = mitk::QuaternionAveraging::CalcAverage(allOrientations);
     this->m_Controls.m_ResultOfCalibrationOrientation->setText(
       QString("qx: ") + QString(QString::number(meanOrientation.x(), 103, 3)) +
       QString("; qy: ") + (QString::number(meanOrientation.y(), 103, 3)) +
       QString("; qz: ") + (QString::number(meanOrientation.z(), 103, 3)) +
       QString("; qr: ") + (QString::number(meanOrientation.r(), 103, 3)));
 
     ToolTipTransform->SetOrientation(meanOrientation);
   }
 
   MITK_INFO << "Computed calibration: ";
   MITK_INFO << "Translation Vector: " << ToolTipTransform->GetPosition();
   MITK_INFO << "Quaternion: (" << ToolTipTransform->GetOrientation() << ")";
   MITK_INFO << "Euler Angles [rad]: (" << ToolTipTransform->GetOrientation().rotation_euler_angles() << ")";
   MITK_INFO << "Matrix:";
   vnl_matrix_fixed<double, 3, 3> rotMatrix = ToolTipTransform->GetOrientation().rotation_matrix_transpose();
   MITK_INFO << rotMatrix[0][0] << " " << rotMatrix[0][1] << " " << rotMatrix[0][2] << std::endl;
   MITK_INFO << rotMatrix[1][0] << " " << rotMatrix[1][1] << " " << rotMatrix[1][2] << std::endl;
   MITK_INFO << rotMatrix[2][0] << " " << rotMatrix[2][1] << " " << rotMatrix[2][2] << std::endl;
 
   //3: write everything into the final tool tip transform and save it as member (it will be written to the tool later on)
   mitk::NavigationData::Pointer ToolTipInTrackingCoordinates = mitk::NavigationData::New();
   ToolTipInTrackingCoordinates->Compose(ToolTipTransform);
   ToolTipInTrackingCoordinates->Compose(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate));
   ShowToolTipPreview(ToolTipInTrackingCoordinates);
   m_Controls.m_SetNewToolTipPosButton->setEnabled(true);
   m_ComputedToolTipTransformation = ToolTipTransform;
 
 }
 
 void QmitkIGTNavigationToolCalibration::OnLoginSingleRefToolNavigationDataClicked()
 {
 
   if (!CheckInitialization()) { return; }
 
   //reset old data
   m_LoggedNavigationDataOffsets.clear();
   m_LoggedNavigationDataDifferences.clear();
 
   m_OnLoginSingleRefToolNavigationDataClicked = true;
   m_Controls.m_CollectNavigationDataButton->setEnabled(false);
   m_NumberOfNavigationData = m_Controls.m_NumberOfNavigationDataToCollect->value();
   MITK_INFO << "Collecting " << m_NumberOfNavigationData << " NavigationData ... " << endl;
 }
 
 void QmitkIGTNavigationToolCalibration::LoginSingleRefToolNavigationData()
 {
   if (!CheckInitialization()) { return; }
 
   if (m_NumberOfNavigationDataCounter < m_NumberOfNavigationData)
   {
     //update label text
     QString labelText = "Collecting Data: " + QString::number(m_NumberOfNavigationDataCounter);
     m_Controls.m_CollectionStatus->setText(labelText);
 
     mitk::NavigationData::Pointer referenceTool = m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer);
     mitk::NavigationData::Pointer toolToCalibrate = m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate);
 
     //compute difference:
     // differenceND = toolToCalibrate^-1 * referenceTool
     mitk::NavigationData::Pointer differenceND = mitk::NavigationData::New();
     differenceND->Compose(referenceTool);
     differenceND->Compose(toolToCalibrate->GetInverse());
 
     //inverse mode...
     if (m_Controls.m_InvertQuaternions->isChecked())
     {
       // negate identity matrix to directly show parameters that will set up in NDI 6D Software Architect
       differenceND = differenceND->GetInverse();
     }
 
     //save difference in member
     m_LoggedNavigationDataOffsets.push_back(differenceND->GetPosition());
     m_LoggedNavigationDataDifferences.push_back(differenceND);
     m_NumberOfNavigationDataCounter++;
   }
 
   if (m_NumberOfNavigationDataCounter == m_NumberOfNavigationData)
   {
     m_NumberOfNavigationDataCounter = 0;
     m_OnLoginSingleRefToolNavigationDataClicked = false;
     m_Controls.m_CollectNavigationDataButton->setEnabled(true);
     m_Controls.m_RunCalibrationButton->setEnabled(true);
     MITK_INFO << "Collecting " << m_NumberOfNavigationData << " NavigationData ... Finished" << endl;
     QString labelText = "Collected " + QString::number(m_NumberOfNavigationData) + " data samples!";
     m_Controls.m_CollectionStatus->setText(labelText);
   }
 }
 
 void QmitkIGTNavigationToolCalibration::OnSetNewToolTipPosButtonClicked()
 {
   ApplyToolTipTransform(m_ComputedToolTipTransformation);
   RemoveToolTipPreview();
 }
 
 void QmitkIGTNavigationToolCalibration::ClearOldPivot()
 {
   mitk::NavigationData::Pointer tempND = mitk::NavigationData::New();
   this->ApplyToolTipTransform(tempND);
   UpdateManualToolTipCalibrationView();
   //m_ManualToolTipEditWidget->hide(); //TODO
   this->GetDataStorage()->Remove(m_ToolSurfaceInToolCoordinatesDataNode);
 }
 void QmitkIGTNavigationToolCalibration::OnAddPivotPose()
 {
   ClearOldPivot();
   //When the collect Poses Button is Clicked
   m_OnAddPivotPoseClicked = true;
   m_NumberOfNavigationData = m_Controls.m_PosesToCollect->value();
 
 }
 
 void QmitkIGTNavigationToolCalibration::AddPivotPose()
 {
   //Save the poses to be used in computation
   if (PivotCount < m_NumberOfNavigationData)
   {
     mitk::NavigationData::Pointer currentPose = mitk::NavigationData::New();
     currentPose->Graft(m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_IDToolToCalibrate));
     m_PivotPoses.push_back(currentPose);
     m_Controls.m_PoseNumber->setText(QString::number(m_PivotPoses.size()));
     PivotCount++;
   }
   if (PivotCount == m_NumberOfNavigationData)
   {
     m_OnAddPivotPoseClicked = false;
   }
 }
 
 void QmitkIGTNavigationToolCalibration::OnComputePivot()
 {
 
   mitk::PivotCalibration::Pointer myPivotCalibration = mitk::PivotCalibration::New();
   for (std::size_t i = 0; i < this->m_PivotPoses.size(); i++)
   {
     myPivotCalibration->AddNavigationData(m_PivotPoses.at(i));
   }
   QString resultString;
   if (myPivotCalibration->ComputePivotResult())
   {
     mitk::NavigationData::Pointer markerTransformationTrackingCoordinates = m_PivotPoses.at(0);
 
     //Get computed pivot transfromation in tool coordinates
 
     mitk::NavigationData::Pointer ToolTipToTool = mitk::NavigationData::New();
     ToolTipToTool->SetPosition(myPivotCalibration->GetResultPivotPoint());
     ToolTipToTool->SetOrientation(mitk::Quaternion(0,0,0,1));
     mitk::NavigationData::Pointer TrackerToTool = mitk::NavigationData::New();
     TrackerToTool->SetOrientation(markerTransformationTrackingCoordinates->GetOrientation());
     TrackerToTool->SetPosition(markerTransformationTrackingCoordinates->GetPosition());
     TrackerToTool->Compose(ToolTipToTool);
 
     // Compute pivot point in relation to marker transformation for preview
     mitk::NavigationData::Pointer ToolTipToTracker = mitk::NavigationData::New();
     ToolTipToTracker->Compose(ToolTipToTool);
     ToolTipToTracker->Compose(markerTransformationTrackingCoordinates);
 
     //add the preview node to the data storage
     ShowToolTipPreview(ToolTipToTracker);
 
     //parse result string
     resultString = QString("Pivot computation succeeded!\n")
       + QString("RMS Error: ") + QString::number(myPivotCalibration->GetResultRMSError()) + QString("\n")
       + QString("Pivot Point: ") + QString::number(myPivotCalibration->GetResultPivotPoint()[0]) + ";" + QString::number(myPivotCalibration->GetResultPivotPoint()[1]) + ";" + QString::number(myPivotCalibration->GetResultPivotPoint()[2]) + QString("\n");
 
     //finally: save results to member variable
     m_ComputedToolTipTransformation = ToolTipToTool;
 
 
     //enable button to use the computed point with the tool
     m_Controls.m_UseComputedPivotPoint->setEnabled(true);
   }
   else
   {
     resultString = "Pivot computation failed!";
   }
   MITK_INFO << resultString.toStdString().c_str();
   m_Controls.m_ResultText->setText(resultString);
 
 }
 void QmitkIGTNavigationToolCalibration::UpdatePivotCount()
 {
   PivotCount = 0;
   while (!m_PivotPoses.empty())
   {
     m_PivotPoses.pop_back();
   }
   m_Controls.m_PoseNumber->setText(QString::number(PivotCount));
 }
 
 void QmitkIGTNavigationToolCalibration::OnUseComputedPivotPoint()
 {
   RemoveToolTipPreview();
   QString resultString = QString("Pivoted tool tip transformation was written to the tool ") + m_ToolToCalibrate->GetToolName().c_str();
   ApplyToolTipTransform(m_ComputedToolTipTransformation, resultString.toStdString());
   m_Controls.m_ResultText->setText(resultString);
   UpdatePivotCount();
 }
 
 void QmitkIGTNavigationToolCalibration::ApplyToolTipTransform(mitk::NavigationData::Pointer ToolTipTransformInToolCoordinates, std::string message)
 {
   if (!CheckInitialization(false)) { return; }
 
   //Update tool in tool storage
   m_ToolToCalibrate->SetToolTipPosition(ToolTipTransformInToolCoordinates->GetPosition());
   m_ToolToCalibrate->SetToolAxisOrientation(ToolTipTransformInToolCoordinates->GetOrientation());
 
   //And also update tracking device, so the transform is directly used
   mitk::TrackingDeviceSource::Pointer trackingDeviceSource;
   try
   {
     trackingDeviceSource = dynamic_cast<mitk::TrackingDeviceSource*>(m_NavigationDataSourceOfToolToCalibrate.GetPointer());
     mitk::TrackingTool::Pointer TrackingToolToCalibrate = trackingDeviceSource->GetTrackingDevice()->GetTool(m_IDToolToCalibrate);
     TrackingToolToCalibrate->SetToolTipPosition(ToolTipTransformInToolCoordinates->GetPosition(), ToolTipTransformInToolCoordinates->GetOrientation());
   }
   catch (std::exception& e)
   {
     MITK_ERROR << "Error while trying to set the tool tip to the running tracking device. Aborting! (" << e.what() << ")";
   }
   MITK_INFO << message;
 }
 
 void QmitkIGTNavigationToolCalibration::ShowToolTipPreview(mitk::NavigationData::Pointer ToolTipInTrackingCoordinates)
 {
   if(m_ToolTipPointPreview.IsNull())
   {
     m_ToolTipPointPreview = mitk::DataNode::New();
     m_ToolTipPointPreview->SetName("Modified Tool Tip Preview");
     mitk::Color blue;
     blue.SetBlue(1);
     m_ToolTipPointPreview->SetColor(blue);
     mitk::Surface::Pointer mySphere = mitk::Surface::New();
     vtkSmartPointer<vtkSphereSource> vtkData = vtkSmartPointer<vtkSphereSource>::New();
     vtkData->SetRadius(3.0f);
     vtkData->SetCenter(0.0, 0.0, 0.0);
     vtkData->Update();
     mySphere->SetVtkPolyData(vtkData->GetOutput());
     m_ToolTipPointPreview->SetData(mySphere);
 
     this->GetDataStorage()->Add(m_ToolTipPointPreview);
   }
   m_ToolTipPointPreview->GetData()->GetGeometry()->SetIndexToWorldTransform(ToolTipInTrackingCoordinates->GetAffineTransform3D());
 }
 
 void QmitkIGTNavigationToolCalibration::RemoveToolTipPreview()
 {
   this->GetDataStorage()->Remove(m_ToolTipPointPreview.GetPointer());
 }
 void QmitkIGTNavigationToolCalibration::UpdateManualToolTipCalibrationView()
 {
   if (m_ToolToCalibrate.IsNull()) { return; }
   //parse human readable transformation data and display it
   std::stringstream translation;
   std::stringstream orientation;
   translation << m_ToolToCalibrate->GetToolTipPosition();
   orientation << "Quaternion: (" << m_ToolToCalibrate->GetToolAxisOrientation() << ")" << std::endl;
   orientation << std::endl;
   orientation << "Euler Angles [rad]: (" << m_ToolToCalibrate->GetToolAxisOrientation().rotation_euler_angles() << ")" << std::endl;
   orientation << std::endl;
   orientation << "Matrix:" << std::endl;
   vnl_matrix_fixed<double, 3, 3> rotMatrix = m_ToolToCalibrate->GetToolAxisOrientation().rotation_matrix_transpose();
   orientation << rotMatrix[0][0] << " " << rotMatrix[0][1] << " " << rotMatrix[0][2] << std::endl;
   orientation << rotMatrix[1][0] << " " << rotMatrix[1][1] << " " << rotMatrix[1][2] << std::endl;
   orientation << rotMatrix[2][0] << " " << rotMatrix[2][1] << " " << rotMatrix[2][2] << std::endl;
   m_Controls.m_ManualCurrentTranslation->setText(translation.str().c_str());
   m_Controls.m_ManualCurrentOrientation->setPlainText(orientation.str().c_str());
 }
 
 void QmitkIGTNavigationToolCalibration::OnStartManualToolTipCalibration()
 {
   if (!CheckInitialization(false)) { return; }
 
   m_ToolTransformationWidget->SetToolToEdit(m_ToolToCalibrate);
   m_ToolTransformationWidget->SetDefaultOffset(m_ToolToCalibrate->GetToolTipPosition());
   m_ToolTransformationWidget->SetDefaultRotation(m_ToolToCalibrate->GetToolAxisOrientation());
 
   m_ToolTransformationWidget->open();
 }
 
 void QmitkIGTNavigationToolCalibration::OnManualEditToolTipFinished(mitk::AffineTransform3D::Pointer toolTip)
 {
   //This function is called, when the toolTipEdit view is closed.
   //if user pressed cancle, nullptr is returned. Do nothing. Else, set values.
   if (toolTip)
   {
     mitk::NavigationData::Pointer tempND = mitk::NavigationData::New(toolTip);//Convert to Navigation data for simple transversion to quaternion
     QString resultString = QString("Manual edited values are written to ") + m_ToolToCalibrate->GetToolName().c_str();
     ApplyToolTipTransform(tempND, resultString.toStdString());
     m_Controls.m_ResultText->setText(resultString);
     m_ComputedToolTipTransformation = tempND;
   }
 
   UpdateManualToolTipCalibrationView();
 }
 
 void QmitkIGTNavigationToolCalibration::OnGetPositions()
 {
   if (!CheckInitialization(true)) { return; }
 
   //Navigation Data from Tool which should be calibrated
   if (!m_AxisCalibration_ToolToCalibrate)
     m_AxisCalibration_ToolToCalibrate = mitk::NavigationData::New();
   m_AxisCalibration_ToolToCalibrate->Graft(m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_IDToolToCalibrate));
 
   //Navigation Data from calibration pointer tool
   if (!m_AxisCalibration_NavDataCalibratingTool)
     m_AxisCalibration_NavDataCalibratingTool = mitk::NavigationData::New();
   m_AxisCalibration_NavDataCalibratingTool->Graft(m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_IDCalibrationPointer));
 
   MITK_DEBUG << "Positions for tool axis calibration:";
   MITK_DEBUG << "    ToolTip: " << m_AxisCalibration_ToolToCalibrate->GetPosition() << ",";
   MITK_DEBUG << "    Rotation: \n" << m_AxisCalibration_ToolToCalibrate->GetRotationMatrix();
   MITK_DEBUG << "    End of the tool: " << m_AxisCalibration_NavDataCalibratingTool->GetPosition();
 
   QString _label = "Position recorded: " + QString::number(m_AxisCalibration_NavDataCalibratingTool->GetPosition()[0], 'f', 1) + ", "
     + QString::number(m_AxisCalibration_NavDataCalibratingTool->GetPosition()[1], 'f', 1) + ", "
     + QString::number(m_AxisCalibration_NavDataCalibratingTool->GetPosition()[2], 'f', 1);
   m_Controls.m_ToolAxisPositionLabel->setText(_label);
 }
 
 void QmitkIGTNavigationToolCalibration::OnCalibrateToolAxis()
 {
   if (!m_ComputedToolTipTransformation)
   {
     MITK_ERROR << "Please compute tool tip first.";
-    QMessageBox::information(NULL, "Error", "Please compute / specifiy tool tip first");
+    QMessageBox::information(nullptr, "Error", "Please compute / specifiy tool tip first");
     return;
   }
   if (!m_AxisCalibration_ToolToCalibrate || !m_AxisCalibration_NavDataCalibratingTool)
   {
     MITK_ERROR << "Please record position first.";
-    QMessageBox::information(NULL, "Error", "Please record position first");
+    QMessageBox::information(nullptr, "Error", "Please record position first");
     return;
   }
 
   //Calculate the tool tip
   //here is an explanation, what is happening here:
   /*
   The axis is equal to the (tool tip) minus the (end of the tool) in tool coordinates of the tool which should be calibrated.
   The tool tip is defined as the origin of the tool coordinate system.
   The end of the tool is recorded by the calibration pointer's position and is transformed into the coordinate system of the tool to be calibrated
   Normalize it.
   */
   //m_CalibratedToolAxis = -m_AxisCalibration_ToolToCalibrate->TransformPoint(m_AxisCalibration_NavDataCalibratingTool->GetPosition()).GetVectorFromOrigin();
   m_CalibratedToolAxis = -m_AxisCalibration_ToolToCalibrate->GetInverse()->TransformPoint(m_AxisCalibration_NavDataCalibratingTool->GetPosition()).GetVectorFromOrigin();
   MITK_DEBUG << "Tool Endpoint in Tool coordinates: " << m_CalibratedToolAxis;
   m_CalibratedToolAxis.Normalize();
   MITK_DEBUG << "Tool Axis: " << m_CalibratedToolAxis;
 
   m_ToolToCalibrate->SetToolAxis(m_CalibratedToolAxis);
 
   // Update TrackingTool
   m_ComputedToolTipTransformation->SetPosition(m_ToolToCalibrate->GetToolTipPosition());
   m_ComputedToolTipTransformation->SetOrientation(m_ToolToCalibrate->GetToolAxisOrientation());
   ApplyToolTipTransform(m_ComputedToolTipTransformation);
 
   //Update GUI
   QString calibratedToolAxisString = "Tool Axis: " + QString::number(m_CalibratedToolAxis.GetElement(0), 'f', 3) + ", " +
     QString::number(m_CalibratedToolAxis.GetElement(1), 'f', 3) + ", " + QString::number(m_CalibratedToolAxis.GetElement(2), 'f', 3);
   m_Controls.m_ToolAxisCalibrationLabel->setText(calibratedToolAxisString);
 
   //Block QT signals, we don't want to emit SpinboxChanged on the first value to overwrite the next ones
   m_Controls.m_ToolAxis_X->blockSignals(true); m_Controls.m_ToolAxis_Y->blockSignals(true); m_Controls.m_ToolAxis_Z->blockSignals(true);
   m_Controls.m_ToolAxis_X->setValue(m_CalibratedToolAxis[0]);
   m_Controls.m_ToolAxis_Y->setValue(m_CalibratedToolAxis[1]);
   m_Controls.m_ToolAxis_Z->setValue(m_CalibratedToolAxis[2]);
   m_Controls.m_ToolAxis_X->blockSignals(false); m_Controls.m_ToolAxis_Y->blockSignals(false); m_Controls.m_ToolAxis_Z->blockSignals(false);
 }
 
 void QmitkIGTNavigationToolCalibration::OnToolAxisSpinboxChanged()
 {
   m_CalibratedToolAxis.SetElement(0, m_Controls.m_ToolAxis_X->value());
   m_CalibratedToolAxis.SetElement(1, m_Controls.m_ToolAxis_Y->value());
   m_CalibratedToolAxis.SetElement(2, m_Controls.m_ToolAxis_Z->value());
   m_ToolToCalibrate->SetToolAxis(m_CalibratedToolAxis);
   // Update TrackingTool
   if (m_ComputedToolTipTransformation.IsNull())
   {
     m_ComputedToolTipTransformation = mitk::NavigationData::New();
   }
   m_ComputedToolTipTransformation->SetPosition(m_ToolToCalibrate->GetToolTipPosition());
   m_ComputedToolTipTransformation->SetOrientation(m_ToolToCalibrate->GetToolAxisOrientation());
   ApplyToolTipTransform(m_ComputedToolTipTransformation);
 
   MITK_INFO << "Tool axis changed to " << m_CalibratedToolAxis;
 }
 
 void QmitkIGTNavigationToolCalibration::SetToolToCalibrate()
 {
   m_IDToolToCalibrate = m_Controls.m_SelectionWidget->GetSelectedToolID();
   if (m_IDToolToCalibrate == -1) //no valid tool to calibrate
   {
     m_Controls.m_CalToolLabel->setText("<none>");
     m_Controls.m_StatusWidgetToolToCalibrate->RemoveStatusLabels();
     m_TrackingTimer->stop();
   }
   else
   {
     m_ToolToCalibrate = m_Controls.m_SelectionWidget->GetSelectedNavigationTool();
     m_NavigationDataSourceOfToolToCalibrate = m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource();
     m_Controls.m_CalToolLabel->setText(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate)->GetName());
     //initialize widget
     m_Controls.m_StatusWidgetToolToCalibrate->RemoveStatusLabels();
     m_Controls.m_StatusWidgetToolToCalibrate->SetShowPositions(true);
     m_Controls.m_StatusWidgetToolToCalibrate->SetTextAlignment(Qt::AlignLeft);
     m_Controls.m_StatusWidgetToolToCalibrate->AddNavigationData(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate));
     m_Controls.m_StatusWidgetToolToCalibrate->ShowStatusLabels();
     //initialize manual tool tip calibration view
     UpdateManualToolTipCalibrationView();
     //save tool surface in tool coordinates for further editing
     mitk::Surface::Pointer ToolSurface = dynamic_cast<mitk::Surface*>(m_ToolToCalibrate->GetDataNode()->GetData())->Clone();
     m_ToolSurfaceInToolCoordinatesDataNode->SetData(ToolSurface);
     m_ToolSurfaceInToolCoordinatesDataNode->GetData()->GetGeometry()->SetIdentity();
     // update tool tip and rotation information for tool tip calibration tab
     UpdateManualToolTipCalibrationView();
     // update tool axis information for tool axis calibration tab
     mitk::Point3D toolAxis = m_ToolToCalibrate->GetToolAxis();
     m_CalibratedToolAxis[0] = toolAxis[0];
     m_CalibratedToolAxis[1] = toolAxis[1];
     m_CalibratedToolAxis[2] = toolAxis[2];
     m_Controls.m_ToolAxis_X->blockSignals(true); m_Controls.m_ToolAxis_Y->blockSignals(true); m_Controls.m_ToolAxis_Z->blockSignals(true);
     m_Controls.m_ToolAxis_X->setValue(m_CalibratedToolAxis[0]);
     m_Controls.m_ToolAxis_Y->setValue(m_CalibratedToolAxis[1]);
     m_Controls.m_ToolAxis_Z->setValue(m_CalibratedToolAxis[2]);
     m_Controls.m_ToolAxis_X->blockSignals(false); m_Controls.m_ToolAxis_Y->blockSignals(false); m_Controls.m_ToolAxis_Z->blockSignals(false);
 
     //start updating timer for status widgets, etc.
     if (!m_TrackingTimer->isActive()) m_TrackingTimer->start(100);
   }
 }
 
 void QmitkIGTNavigationToolCalibration::SetCalibrationPointer()
 {
   m_IDCalibrationPointer = m_Controls.m_SelectionWidget->GetSelectedToolID();
   if (m_IDCalibrationPointer == -1)
   {
     m_Controls.m_PointerLabel->setText("<none>");
     m_Controls.m_StatusWidgetCalibrationPointer->RemoveStatusLabels();
     m_TrackingTimer->stop();
   }
   else
   {
     m_NavigationDataSourceOfCalibrationPointer = m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource();
     m_Controls.m_PointerLabel->setText(m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer)->GetName());
     //initialize widget
     m_Controls.m_StatusWidgetCalibrationPointer->RemoveStatusLabels();
     m_Controls.m_StatusWidgetCalibrationPointer->SetShowPositions(true);
     m_Controls.m_StatusWidgetCalibrationPointer->SetTextAlignment(Qt::AlignLeft);
     m_Controls.m_StatusWidgetCalibrationPointer->AddNavigationData(m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer));
     m_Controls.m_StatusWidgetCalibrationPointer->ShowStatusLabels();
     if (!m_TrackingTimer->isActive()) m_TrackingTimer->start(100);
   }
 }
 
 void QmitkIGTNavigationToolCalibration::UpdateOffsetCoordinates()
 {
   if (m_NavigationDataSourceOfCalibrationPointer.IsNull() || m_NavigationDataSourceOfToolToCalibrate.IsNull())
   {
     return;
   }
 
   mitk::NavigationData::Pointer referenceToolND = m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer);
   mitk::NavigationData::Pointer toolToCalibrateND = m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate);
 
   if (referenceToolND->IsDataValid() && toolToCalibrateND->IsDataValid())
   {
     //computation: difference between both tools (in tool coordinates)
     //differenceND = toolToCalibrateND^-1 * referenceToolND
     mitk::NavigationData::Pointer differenceND = mitk::NavigationData::New();
     differenceND->Compose(referenceToolND);
     differenceND->Compose(toolToCalibrateND->GetInverse());
 
     //display this orientation in the UI
     m_Controls.m_OffsetCoordinates->setText(
       QString("x: ") + QString(QString::number(differenceND->GetPosition()[0], 103, 3)) +
       QString("; y: ") + (QString::number(differenceND->GetPosition()[1], 103, 3)) +
       QString("; z: ") + (QString::number(differenceND->GetPosition()[2], 103, 3)));
 
     m_Controls.m_OrientationOffsetCoordinates->setText(
       QString("qx: ") + QString(QString::number(differenceND->GetOrientation().x(), 103, 3)) +
       QString("; qy: ") + (QString::number(differenceND->GetOrientation().y(), 103, 3)) +
       QString("; qz: ") + (QString::number(differenceND->GetOrientation().z(), 103, 3)) +
       QString("; qr: ") + (QString::number(differenceND->GetOrientation().r(), 103, 3)));
 
     //also update preview if active
     if (m_ToolTipPointPreview.IsNotNull()) //NOT WORKING! TODO: fix or remove!
     {
       mitk::NavigationData::Pointer ToolTipTransform = mitk::NavigationData::New();
       ToolTipTransform->SetPosition(m_ResultOffsetVector);
       mitk::NavigationData::Pointer ToolTipInTrackingCoordinates = mitk::NavigationData::New(); //maybe store as for better peformance...
       ToolTipInTrackingCoordinates->Compose(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate));
       ToolTipInTrackingCoordinates->Compose(ToolTipTransform);
       m_ToolTipPointPreview->GetData()->GetGeometry()->SetIndexToWorldTransform(ToolTipInTrackingCoordinates->GetAffineTransform3D());
     }
   }
 }
 
 void QmitkIGTNavigationToolCalibration::UpdateTrackingTimer()
 {
   m_Controls.m_StatusWidgetToolToCalibrate->Refresh();
   m_Controls.m_StatusWidgetCalibrationPointer->Refresh();
 
   if (m_OnLoginSingleRefToolNavigationDataClicked) LoginSingleRefToolNavigationData();
 
   if (m_OnAddPivotPoseClicked) AddPivotPose();
 
   // 1 == Single Reference Calibration Method
   if (m_IndexCurrentCalibrationMethod == 1) UpdateOffsetCoordinates();
 
 }
 
 void QmitkIGTNavigationToolCalibration::AddLandmark()
 {
   if (!CheckInitialization()) { return; }
   mitk::NavigationData::Pointer navDataTool = m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate);
   mitk::Point3D landmark = m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer)->GetPosition();
 
   //convert to itk transform
   itk::Vector<double, 3> translation;
   for (int k = 0; k < 3; k++) translation[k] = navDataTool->GetPosition()[k];
   itk::Matrix<double, 3, 3> rotation;
   for (int k = 0; k < 3; k++) for (int l = 0; l < 3; l++) rotation[k][l] = navDataTool->GetOrientation().rotation_matrix_transpose()[k][l];
   rotation = rotation.GetTranspose();
   itk::Vector<double> landmarkItk;
   landmarkItk[0] = landmark[0];
   landmarkItk[1] = landmark[1];
   landmarkItk[2] = landmark[2];
 
   //compute landmark in tool coordinates
   itk::Matrix<double, 3, 3> rotationInverse;
   for (int k = 0; k < 3; k++) for (int l = 0; l < 3; l++) rotationInverse[k][l] = rotation.GetInverse()[k][l];
   landmarkItk = rotationInverse * (landmarkItk - translation);
 
   //convert back and add landmark to pointset
   landmark[0] = landmarkItk[0];
   landmark[1] = landmarkItk[1];
   landmark[2] = landmarkItk[2];
   m_RegistrationLandmarks->InsertPoint(m_RegistrationLandmarks->GetSize(), landmark);
 }
 
 void QmitkIGTNavigationToolCalibration::SaveCalibratedTool()
 {
   if (m_ToolToCalibrate.IsNotNull())
   {
     mitk::NavigationTool::Pointer calibratedTool = m_ToolToCalibrate;
     calibratedTool->SetToolControlPoints(this->m_CalibrationLandmarks);
     calibratedTool->SetToolLandmarks(this->m_RegistrationLandmarks);
     mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
     QString filename = QFileDialog::getSaveFileName(nullptr,tr("Save Navigation Tool"), "/", "*.IGTTool");
     if (filename.isEmpty()) return;
 
     // ensure that file suffix is set
     QFileInfo file(filename);
     if (file.suffix().isEmpty())
     {
       filename += ".IGTTool";
     }
 
     if (myWriter->DoWrite(filename.toStdString(), calibratedTool)) MITK_INFO << "Saved calibrated tool to file " << filename;
     else MITK_WARN << "Can't write tool to file " << filename;
   }
   else
   {
     MITK_ERROR << "Did not find navigation tool storage of calibrated tool, aborting!";
   }
 }
 
 bool QmitkIGTNavigationToolCalibration::CheckInitialization(bool CalibrationPointerRequired)
 {
   if ((m_IDToolToCalibrate == -1) ||
     ((CalibrationPointerRequired) &&
     (m_IDCalibrationPointer == -1)
     )
     )
   {
     QMessageBox msgBox;
     msgBox.setText("Tool to calibrate and/or calibration pointer not initialized, cannot proceed!");
     msgBox.exec();
     return false;
   }
   else { return true; }
 }
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp
index 667920d091..5a8f7b32ae 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp
@@ -1,78 +1,78 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkMITKIGTNavigationToolManagerView.h"
 
 // MITK
 #include <usGetModuleContext.h>
 
 // Qt
 #include <QMessageBox>
 
 const std::string QmitkMITKIGTNavigationToolManagerView::VIEW_ID = "org.mitk.views.mitkigtnavigationtoolmanager";
 
 QmitkMITKIGTNavigationToolManagerView::QmitkMITKIGTNavigationToolManagerView()
   : QmitkAbstractView()
-  , m_Controls(0)
+  , m_Controls(nullptr)
 {
 }
 
 QmitkMITKIGTNavigationToolManagerView::~QmitkMITKIGTNavigationToolManagerView()
 {
   for (auto storage : m_AllStoragesHandledByThisWidget)
     storage->UnRegisterMicroservice();
 }
 
 void QmitkMITKIGTNavigationToolManagerView::CreateQtPartControl(QWidget *parent)
 {
   // build up qt view, unless already done
   if (!m_Controls)
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkMITKIGTNavigationToolManagerViewControls;
     m_Controls->setupUi(parent);
     connect((QObject*)(m_Controls->m_toolManagerWidget), SIGNAL(NewStorageAdded(mitk::NavigationToolStorage::Pointer, std::string)), this, SLOT(NewStorageByWidget(mitk::NavigationToolStorage::Pointer)));
     connect((QObject*)(m_Controls->m_ToolStorageListWidget), SIGNAL(NavigationToolStorageSelected(mitk::NavigationToolStorage::Pointer)), this, SLOT(ToolStorageSelected(mitk::NavigationToolStorage::Pointer)));
   }
   m_Controls->m_toolManagerWidget->Initialize(this->GetDataStorage());
 }
 
 void QmitkMITKIGTNavigationToolManagerView::SetFocus()
 {
   m_Controls->m_ToolStorageListWidget->setFocus();
 }
 
 void QmitkMITKIGTNavigationToolManagerView::NewStorageByWidget(mitk::NavigationToolStorage::Pointer storage)
 {
   storage->RegisterAsMicroservice();
   m_AllStoragesHandledByThisWidget.push_back(storage);
 }
 
 void QmitkMITKIGTNavigationToolManagerView::ToolStorageSelected(mitk::NavigationToolStorage::Pointer storage)
 {
   if (storage.IsNull()) //no storage selected
   {
     //reset everything
     return;
   }
 
   this->m_Controls->m_toolManagerWidget->LoadStorage(storage);
 }
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp
index e50832db81..63fc082a38 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp
@@ -1,240 +1,240 @@
 /*===================================================================
 
 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 "QmitkNavigationDataPlayerView.h"
 
 // QT
 #include <QFileDialog>
 #include <QMessageBox>
 
 //mitk
 #include <mitkNavigationDataSet.h>
 #include <mitkNavigationDataReaderInterface.h>
 #include <mitkNavigationDataSequentialPlayer.h>
 #include <mitkNavigationDataPlayer.h>
 #include <mitkVirtualTrackingTool.h>
 #include <mitkIOUtil.h>
 
 // VTK
 #include <vtkSphereSource.h>
 
 const std::string QmitkNavigationDataPlayerView::VIEW_ID = "org.mitk.views.navigationdataplayer";
 
 QmitkNavigationDataPlayerView::QmitkNavigationDataPlayerView()
-  : m_Controls( 0 )
+  : m_Controls( nullptr )
 {
 }
 
 QmitkNavigationDataPlayerView::~QmitkNavigationDataPlayerView()
 {
 }
 
 void QmitkNavigationDataPlayerView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkNavigationDataPlayerViewControls;
     m_Controls->setupUi( parent );
 
     this->CreateConnections();
 
     // make deselected Player invisible
     m_Controls->m_TimedWidget->setVisible(false);
   }
 }
 
 void QmitkNavigationDataPlayerView::SetFocus()
 {
   if ( m_Controls )
   {
     m_Controls->m_grpbxControls->setFocus();
   }
 }
 
 void QmitkNavigationDataPlayerView::CreateConnections()
 {
   connect( m_Controls->m_RdbSequential, SIGNAL(released()), this, SLOT(OnSelectPlayer()) );
   connect( m_Controls->m_RdbTimeBased, SIGNAL(released()), this, SLOT(OnSelectPlayer()) );
   connect( m_Controls->m_BtnOpenFile, SIGNAL(released()), this, SLOT(OnOpenFile()) );
   connect( m_Controls->m_ChkDisplay, SIGNAL(released()), this, SLOT(OnSetDisplay()) );
   connect( m_Controls->m_chkRepeat, SIGNAL(stateChanged(int)), this, SLOT(OnSetRepeat(int)) );
   connect( m_Controls->m_ChkMicroservice, SIGNAL(released()), this, SLOT(OnSetMicroservice()) );
 
   connect( m_Controls->m_SequentialWidget, SIGNAL(SignalUpdate()), this, SLOT(OnUpdate()) );
   connect( m_Controls->m_TimedWidget, SIGNAL(SignalUpdate()), this, SLOT(OnUpdate()) );
 
   this->SetInteractionComponentsEnabledState(false);
 }
 
 void QmitkNavigationDataPlayerView::OnOpenFile()
 {
   mitk::NavigationDataReaderInterface::Pointer reader = nullptr;
 
   QString filter = tr("NavigationData File (*.csv *.xml)");
 
   QString fileName = QFileDialog::getOpenFileName(nullptr, tr("Open NavigationData Set"), "", filter);
 
   if ( fileName.isNull() ) { return; } // user pressed cancel
 
   try
   {
     m_Data = dynamic_cast<mitk::NavigationDataSet*> (mitk::IOUtil::Load(fileName.toStdString())[0].GetPointer());
   }
   catch ( const mitk::Exception &e )
   {
     MITK_WARN("NavigationDataPlayerView") << "could not open file " << fileName.toStdString();
-    QMessageBox::critical(0, "Error Reading File", "The file '" + fileName
+    QMessageBox::critical(nullptr, "Error Reading File", "The file '" + fileName
                           +"' could not be read.\n" + e.GetDescription() );
     return;
   }
 
   if (m_Controls->m_ChkConvertToPointSet->isChecked())
     m_Data->ConvertNavigationDataToPointSet();
 
   // Update Labels
   m_Controls->m_LblFilePath->setText(fileName);
   m_Controls->m_LblFrames->setText(QString::number(m_Data->Size()));
   m_Controls->m_LblTools->setText(QString::number(m_Data->GetNumberOfTools()));
 
   // Initialize Widgets and create Player
   this->OnSelectPlayer();
   this->SetInteractionComponentsEnabledState(true);
 }
 
 void QmitkNavigationDataPlayerView::OnSelectPlayer()
 {
   if (m_Controls->m_RdbSequential->isChecked())
   {
     m_Controls->m_SequentialWidget->setVisible(true);
     m_Controls->m_TimedWidget->setVisible(false);
     mitk::NavigationDataSequentialPlayer::Pointer seqPlayer = mitk::NavigationDataSequentialPlayer::New();
     seqPlayer->SetNavigationDataSet(m_Data);
     m_Controls->m_SequentialWidget->SetPlayer(seqPlayer);
     m_Player = seqPlayer;
   } else {
     m_Controls->m_SequentialWidget->setVisible(false);
     m_Controls->m_TimedWidget->setVisible(true);
     mitk::NavigationDataPlayer::Pointer timedPlayer = mitk::NavigationDataPlayer::New();
     timedPlayer->SetNavigationDataSet(m_Data);
     m_Controls->m_TimedWidget->SetPlayer(timedPlayer);
     m_Player = timedPlayer;
   }
 
   this->ConfigurePlayer();
 
   // SetupRenderingPipeline
   this->OnSetDisplay();
 }
 
 void QmitkNavigationDataPlayerView::ConfigurePlayer()
 {
   // set repeat mode according to the checkbox
   m_Player->SetRepeat( m_Controls->m_chkRepeat->isChecked() );
 }
 
 void QmitkNavigationDataPlayerView::OnSetRepeat(int checkState)
 {
   m_Player->SetRepeat(checkState != 0);
 }
 
 void QmitkNavigationDataPlayerView::OnSetMicroservice(){
   if(m_Controls->m_ChkMicroservice->isChecked())
   {
     m_ToolStorage = mitk::NavigationToolStorage::New();
     for (itk::ProcessObject::DataObjectPointerArraySizeType i = 0;
          i < m_Player->GetNumberOfIndexedOutputs(); i++)
     {
       mitk::NavigationTool::Pointer currentDummyTool = mitk::NavigationTool::New();
       mitk::VirtualTrackingTool::Pointer dummyTool = mitk::VirtualTrackingTool::New();
       std::stringstream name;
       name << "Virtual Tool " << i;
       dummyTool->SetToolName(name.str());
       currentDummyTool->SetDataNode(m_RenderingNodes.at(i));
       currentDummyTool->SetIdentifier(name.str());
       m_ToolStorage->AddTool(currentDummyTool);
     }
     m_ToolStorage->SetName("NavigationDataPlayer Tool Storage");
     m_Player->SetToolMetaDataCollection(m_ToolStorage);
     m_Player->RegisterAsMicroservice();
     m_ToolStorage->SetSourceID(m_Player->GetMicroserviceID()); //DEPRECATED / not needed anymore because NavigationDataSource now holds a member of its tool storage. Only left for backward compatibility.
     m_ToolStorage->RegisterAsMicroservice();
   } else {
     if (m_ToolStorage.IsNotNull()) m_ToolStorage->UnRegisterMicroservice();
     m_ToolStorage = nullptr;
     m_Player->UnRegisterMicroservice();
   }
 }
 
 void QmitkNavigationDataPlayerView::OnUpdate(){
   if (m_VisFilter.IsNotNull())
   {
     m_VisFilter->Update();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkNavigationDataPlayerView::OnSetDisplay(){
   DestroyPipeline();
   if ( (m_Controls->m_ChkDisplay->isChecked()) && ( m_Player.IsNotNull() ))
   {
     CreatePipeline();
   }
 }
 
 void QmitkNavigationDataPlayerView::CreatePipeline(){
   m_VisFilter = mitk::NavigationDataObjectVisualizationFilter::New();
   m_VisFilter->ConnectTo(m_Player);
 
   for (unsigned int i = 0 ; i < m_Player->GetNumberOfIndexedOutputs(); i++ ) {
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     QString name = "Recorded Tool " + QString::number(i + 1);
     node->SetName(name.toStdString());
 
     //create small sphere and use it as surface
     mitk::Surface::Pointer mySphere = mitk::Surface::New();
     vtkSmartPointer<vtkSphereSource> vtkData = vtkSmartPointer<vtkSphereSource>::New();
     vtkData->SetRadius(5.0f);
     vtkData->SetCenter(0.0, 0.0, 0.0);
     vtkData->Update();
     mySphere->SetVtkPolyData(vtkData->GetOutput());
     node->SetData(mySphere);
     m_VisFilter->SetRepresentationObject(i, mySphere);
 
     // Add Node to DataStorageand to local list of Nodes
     GetDataStorage()->Add(node);
     m_RenderingNodes.push_back(node);
   }
   m_VisFilter->Update();
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(GetDataStorage());
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkNavigationDataPlayerView::DestroyPipeline(){
   m_VisFilter = nullptr;
   for (unsigned int i = 0; i < m_RenderingNodes.size(); i++){
     this->GetDataStorage()->Remove(m_RenderingNodes[i]);
   }
   m_RenderingNodes.clear();
 }
 
 void QmitkNavigationDataPlayerView::SetInteractionComponentsEnabledState(bool isActive){
   m_Controls->m_grpbxSettings->setEnabled(isActive);
   m_Controls->m_grpbxControls->setEnabled(isActive);
 }
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/mitkPluginActivator.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/mitkPluginActivator.cpp
index 8fd99a359c..f822d3dbb7 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/mitkPluginActivator.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/mitkPluginActivator.cpp
@@ -1,58 +1,58 @@
 /*===================================================================
 
 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 "mitkPluginActivator.h"
 #include "QmitkMITKIGTNavigationToolManagerView.h"
 #include "QmitkMITKIGTTrackingToolboxView.h"
 #include "QmitkNavigationDataPlayerView.h"
 #include "QmitkIGTNavigationToolCalibration.h"
 #include "QmitkIGTFiducialRegistration.h"
 
 //#include <mitkPersistenceService.h> //Workaround for bug in persistence module (see bug 16643 for details)
                                     //CAN BE REMOVED WHEN THE BUG IS FIXED
 
 namespace mitk {
 
-  ctkPluginContext* PluginActivator::m_Context = 0;
+  ctkPluginContext* PluginActivator::m_Context = nullptr;
 
 void PluginActivator::start(ctkPluginContext* context)
 {
  // mitk::PersistenceService::LoadModule(); //Workaround for bug in persistence module (see bug 16643 for details)
                                           //CAN BE REMOVED WHEN THE BUG IS FIXED
   m_Context = context;
 
   BERRY_REGISTER_EXTENSION_CLASS(QmitkMITKIGTNavigationToolManagerView, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkMITKIGTTrackingToolboxView , context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkNavigationDataPlayerView , context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkIGTNavigationToolCalibration , context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkIGTFiducialRegistration, context)
 
 
 }
 
 void PluginActivator::stop(ctkPluginContext* context)
 {
-  m_Context = 0;
+  m_Context = nullptr;
 
   Q_UNUSED(context)
 }
 
 ctkPluginContext *PluginActivator::GetContext()
 {
   return m_Context;
 }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
index 2280d46dba..ab4dbe86c8 100644
--- a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
+++ b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
@@ -1,579 +1,579 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "QmitkImageCropper.h"
 
 #include <QAction>
 #include <QCheckBox>
 #include <QColorDialog>
 #include <QInputDialog>
 #include <QMessageBox>
 #include <QSpinBox>
 #include <QSlider>
 #include <QApplication>
 
 #include <vtkCommand.h>
 #include <vtkCubeSource.h>
 #include <vtkObjectFactory.h>
 #include <vtkRenderWindow.h>
 #include <vtkPlaneWidget.h>
 #include <vtkProperty.h>
 #include <vtkSmartPointer.h>
 #include <vtkTransform.h>
 #include <vtkTransformFilter.h>
 
 #include <mitkBoundingShapeInteractor.h>
 #include <mitkBoundingShapeCropper.h>
 #include <mitkDisplayInteractor.h>
 #include <mitkIDataStorageService.h>
 #include <mitkImageCast.h> // Includes for image casting between ITK and MITK: added after using Plugin Generator
 #include <mitkImageAccessByItk.h>
 #include <mitkImageStatisticsHolder.h>
 #include <mitkInteractionConst.h>
 #include <mitkITKImageImport.h>
 #include <mitkLabelSetImage.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateFunction.h>
 #include <mitkRenderingManager.h>
 #include <mitkProperties.h>
 
 #include <itkBoundingBox.h>
 #include <itkCommand.h>
 
 #include <usModuleRegistry.h>
 #include <usGetModuleContext.h>
 
 const std::string QmitkImageCropper::VIEW_ID = "org.mitk.views.qmitkimagecropper";
 
 QmitkImageCropper::QmitkImageCropper(QObject *)
-  : m_ParentWidget(0),
+  : m_ParentWidget(nullptr),
   m_ImageNode(nullptr),
   m_CroppingObject(nullptr),
   m_CroppingObjectNode(nullptr),
   m_BoundingShapeInteractor(nullptr),
   m_CropOutsideValue(0),
   m_Advanced(0),
   m_Active(0),
   m_ScrollEnabled(true)
 {
   CreateBoundingShapeInteractor(false);
 }
 
 QmitkImageCropper::~QmitkImageCropper()
 {
   //delete pointer objects
   m_CroppingObjectNode = nullptr;
   m_CroppingObject = nullptr;
 
   //disable interactor
   if (m_BoundingShapeInteractor != nullptr)
   {
     m_BoundingShapeInteractor->SetDataNode(nullptr);
     m_BoundingShapeInteractor->EnableInteraction(false);
   }
 }
 
 void QmitkImageCropper::SetFocus()
 {
   m_Controls.buttonCreateNewBoundingBox->setFocus();
 }
 
 void QmitkImageCropper::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
 
   m_Controls.boundingShapeSelector->SetDataStorage(this->GetDataStorage());
   m_Controls.boundingShapeSelector->SetPredicate(mitk::NodePredicateAnd::New(
     mitk::TNodePredicateDataType<mitk::GeometryData>::New(),
     mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))));
   m_CroppingObjectNode = m_Controls.boundingShapeSelector->GetSelectedNode();
 
   connect(m_Controls.buttonCropping, SIGNAL(clicked()), this, SLOT(DoCropping()));
   connect(m_Controls.buttonMasking, SIGNAL(clicked()), this, SLOT(DoMasking()));
   connect(m_Controls.boundingShapeSelector, SIGNAL(OnSelectionChanged(const mitk::DataNode*)),
     this, SLOT(OnDataSelectionChanged(const mitk::DataNode*)));
   connect(m_Controls.buttonCreateNewBoundingBox, SIGNAL(clicked()), this, SLOT(DoCreateNewBoundingObject()));
   connect(m_Controls.buttonAdvancedSettings, SIGNAL(clicked()), this, SLOT(OnAdvancedSettingsButtonToggled()));
   connect(m_Controls.spinBoxOutsidePixelValue, SIGNAL(valueChanged(int)), this, SLOT(OnSliderValueChanged(int)));
 
   setDefaultGUI();
   m_Controls.labelWarningRotation->setVisible(false);
 
   m_Advanced = false;
   this->OnAdvancedSettingsButtonToggled();
   m_ParentWidget = parent;
 }
 
 void QmitkImageCropper::OnDataSelectionChanged(const mitk::DataNode*)
 {
   m_Controls.boundingShapeSelector->setEnabled(true);
   m_CroppingObjectNode = m_Controls.boundingShapeSelector->GetSelectedNode();
 
   if (m_CroppingObjectNode.IsNotNull() && dynamic_cast<mitk::GeometryData*>(this->m_CroppingObjectNode->GetData()))
   {
     m_Controls.buttonAdvancedSettings->setEnabled(true);
     m_Controls.groupImageSettings->setEnabled(true);
     m_Controls.labelWarningBB->setVisible(false);
     m_CroppingObject = dynamic_cast<mitk::GeometryData*>(m_CroppingObjectNode->GetData());
     m_Advanced = true;
 
     m_BoundingShapeInteractor->EnableInteraction(true);
     m_BoundingShapeInteractor->SetDataNode(m_CroppingObjectNode);
 
     mitk::RenderingManager::GetInstance()->InitializeViews();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else
   {
     setDefaultGUI();
     m_CroppingObject = nullptr;
     m_BoundingShapeInteractor->EnableInteraction(false);
     m_BoundingShapeInteractor->SetDataNode(nullptr);
     m_Advanced = false;
     this->OnAdvancedSettingsButtonToggled();
   }
 }
 
 void QmitkImageCropper::OnAdvancedSettingsButtonToggled()
 {
   m_Controls.groupImageSettings->setVisible(m_Advanced);
   m_Advanced = !m_Advanced;
 }
 
 void QmitkImageCropper::CreateBoundingShapeInteractor(bool rotationEnabled)
 {
   if (m_BoundingShapeInteractor.IsNull())
   {
     m_BoundingShapeInteractor = mitk::BoundingShapeInteractor::New();
     m_BoundingShapeInteractor->LoadStateMachine("BoundingShapeInteraction.xml", us::ModuleRegistry::GetModule("MitkBoundingShape"));
     m_BoundingShapeInteractor->SetEventConfig("BoundingShapeMouseConfig.xml", us::ModuleRegistry::GetModule("MitkBoundingShape"));
   }
   m_BoundingShapeInteractor->SetRotationEnabled(rotationEnabled);
 }
 
 mitk::Geometry3D::Pointer QmitkImageCropper::InitializeWithImageGeometry(mitk::BaseGeometry::Pointer geometry)
 {
   // convert a basegeometry into a Geometry3D (otherwise IO is not working properly)
   if (geometry == nullptr)
     mitkThrow() << "Geometry is not valid.";
 
   auto boundingGeometry = mitk::Geometry3D::New();
   boundingGeometry->SetBounds(geometry->GetBounds());
   boundingGeometry->SetImageGeometry(geometry->GetImageGeometry());
   boundingGeometry->SetOrigin(geometry->GetOrigin());
   boundingGeometry->SetSpacing(geometry->GetSpacing());
   boundingGeometry->SetIndexToWorldTransform(geometry->GetIndexToWorldTransform());
   boundingGeometry->Modified();
   return boundingGeometry;
 }
 
 QString QmitkImageCropper::AdaptBoundingObjectName(const QString& name) const
 {
   unsigned int counter = 2;
   QString newName = QString("%1 %2").arg(name).arg(counter);
 
   while (nullptr != this->GetDataStorage()->GetNode(mitk::NodePredicateFunction::New([&newName](const mitk::DataNode *node)
   {
     return 0 == node->GetName().compare(newName.toStdString());
   })))
   {
     newName = QString("%1 %2").arg(name).arg(++counter);
   }
 
   return newName;
 }
 
 void QmitkImageCropper::DoCreateNewBoundingObject()
 {
   if (!m_ImageNode.IsExpired())
   {
     auto imageNode = m_ImageNode.Lock();
     QString name = QString::fromStdString(imageNode->GetName() + " Bounding Shape");
 
     auto boundingShape = this->GetDataStorage()->GetNode(mitk::NodePredicateFunction::New([&name](const mitk::DataNode *node)
     {
       return 0 == node->GetName().compare(name.toStdString());
     }));
 
     if (nullptr != boundingShape)
       name = this->AdaptBoundingObjectName(name);
 
     m_Controls.buttonCropping->setEnabled(true);
     m_Controls.buttonMasking->setEnabled(true);
     m_Controls.boundingShapeSelector->setEnabled(true);
     m_Controls.groupImageSettings->setEnabled(true);
 
     // get current timestep to support 3d+t images
     auto renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN);
     int timeStep = renderWindowPart->GetTimeNavigationController()->GetTime()->GetPos();
     mitk::BaseGeometry::Pointer imageGeometry = static_cast<mitk::BaseGeometry*>(imageNode->GetData()->GetGeometry(timeStep));
 
     m_CroppingObject = mitk::GeometryData::New();
     m_CroppingObject->SetGeometry(static_cast<mitk::Geometry3D*>(this->InitializeWithImageGeometry(imageGeometry)));
     m_CroppingObjectNode = mitk::DataNode::New();
     m_CroppingObjectNode->SetData(m_CroppingObject);
     m_CroppingObjectNode->SetProperty("name", mitk::StringProperty::New(name.toStdString()));
     m_CroppingObjectNode->SetProperty("color", mitk::ColorProperty::New(1.0, 1.0, 1.0));
     m_CroppingObjectNode->SetProperty("opacity", mitk::FloatProperty::New(0.6));
     m_CroppingObjectNode->SetProperty("layer", mitk::IntProperty::New(99));
     m_CroppingObjectNode->AddProperty("handle size factor", mitk::DoubleProperty::New(1.0 / 40.0));
     m_CroppingObjectNode->SetBoolProperty("pickable", true);
 
     if (!this->GetDataStorage()->Exists(m_CroppingObjectNode))
     {
       GetDataStorage()->Add(m_CroppingObjectNode, imageNode);
       m_Controls.boundingShapeSelector->SetSelectedNode(m_CroppingObjectNode);
       m_CroppingObjectNode->SetVisibility(true);
       m_BoundingShapeInteractor->EnableInteraction(true);
       m_BoundingShapeInteractor->SetDataNode(this->m_CroppingObjectNode);
       this->OnDataSelectionChanged(m_CroppingObjectNode);
     }
   }
   // Adjust coordinate system by doing a reinit on
   auto tempDataStorage = mitk::DataStorage::SetOfObjects::New();
   tempDataStorage->InsertElement(0, m_CroppingObjectNode);
 
   //// initialize the views to the bounding geometry
   //mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(tempDataStorage);
   //mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
   //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 void QmitkImageCropper::setDefaultGUI()
 {
   m_Controls.labelWarningImage->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
   m_Controls.labelWarningImage->setText(QString::fromStdString("Select an image."));
   m_Controls.labelWarningImage->setVisible(true);
   m_Controls.labelWarningBB->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
   m_Controls.labelWarningBB->setText(QString::fromStdString("Create a bounding shape below."));
   m_Controls.labelWarningBB->setVisible(true);
   m_Controls.buttonCreateNewBoundingBox->setEnabled(false);
   m_Controls.labelWarningRotation->setVisible(false);
   m_Controls.buttonCropping->setEnabled(false);
   m_Controls.buttonMasking->setEnabled(false);
   m_Controls.boundingShapeSelector->setEnabled(false);
   m_Controls.buttonAdvancedSettings->setEnabled(false);
   m_Controls.groupImageSettings->setEnabled(false);
   m_Controls.checkOverwriteImage->setChecked(false);
   m_Controls.checkBoxCropTimeStepOnly->setChecked(false);
 }
 
 void QmitkImageCropper::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/,
   const QList<mitk::DataNode::Pointer>& nodes)
 {
   bool rotationEnabled = false;
   if (nodes.empty())
   {
     setDefaultGUI();
     return;
   }
   m_ParentWidget->setEnabled(true);
 
   foreach(mitk::DataNode::Pointer node, nodes)
   {
     if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
     {
       m_ImageNode = nodes[0];
       m_Controls.groupBoundingObject->setEnabled(true);
       m_Controls.labelWarningImage->setStyleSheet("");
       m_Controls.labelWarningImage->setText(QString::fromStdString("Selected image: " + nodes[0]->GetName()));
       m_Controls.buttonCreateNewBoundingBox->setEnabled(true);
 
       mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(nodes[0]->GetData());
       if (image != nullptr)
       {
         if (image->GetDimension() < 3) {
           QMessageBox::warning(nullptr,
             tr("Invalid image selected"),
             tr("ImageCropper only works with 3 or more dimensions."),
             QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
           setDefaultGUI();
           return;
         }
 
         vtkSmartPointer<vtkMatrix4x4> imageMat = image->GetGeometry()->GetVtkMatrix();
         // check whether the image geometry is rotated, if so, no pixel aligned cropping or masking can be performed
         if ((imageMat->GetElement(1, 0) == 0.0) && (imageMat->GetElement(0, 1) == 0.0) &&
           (imageMat->GetElement(1, 2) == 0.0) && (imageMat->GetElement(2, 1) == 0.0) &&
           (imageMat->GetElement(2, 0) == 0.0) && (imageMat->GetElement(0, 2) == 0.0))
         {
           rotationEnabled = false;
           m_Controls.labelWarningRotation->setVisible(false);
         }
         else
         {
           rotationEnabled = true;
           m_Controls.labelWarningRotation->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
           m_Controls.labelWarningRotation->setVisible(true);
         }
 
         this->CreateBoundingShapeInteractor(rotationEnabled);
         m_CroppingObjectNode = m_Controls.boundingShapeSelector->GetSelectedNode();
         if (m_CroppingObjectNode != nullptr)
         {
           this->OnDataSelectionChanged(m_CroppingObjectNode);
           m_BoundingShapeInteractor->EnableInteraction(true);
           m_BoundingShapeInteractor->SetDataNode(this->m_CroppingObjectNode);
           m_Controls.boundingShapeSelector->setEnabled(true);
         }
 
         if (image->GetPixelType().GetPixelType() == itk::ImageIOBase::SCALAR)
         {
           // Might be changed with the upcoming new image statistics plugin
           //(recomputation might be very expensive for large images ;) )
           auto statistics = image->GetStatistics();
           auto minPixelValue = statistics->GetScalarValueMin();
           auto maxPixelValue = statistics->GetScalarValueMax();
 
           if (minPixelValue < std::numeric_limits<int>::min()) {
             minPixelValue = std::numeric_limits<int>::min();
           }
           if (maxPixelValue > std::numeric_limits<int>::max()) {
             maxPixelValue = std::numeric_limits<int>::max();
           }
 
           m_Controls.spinBoxOutsidePixelValue->setEnabled(true);
           m_Controls.spinBoxOutsidePixelValue->setMaximum(static_cast<int>(maxPixelValue));
           m_Controls.spinBoxOutsidePixelValue->setMinimum(static_cast<int>(minPixelValue));
           m_Controls.spinBoxOutsidePixelValue->setValue(static_cast<int>(minPixelValue));
         }
         else
         {
           m_Controls.spinBoxOutsidePixelValue->setEnabled(false);
         }
 
         unsigned int dim = image->GetDimension();
         if (dim < 2 || dim > 4)
         {
           m_Controls.labelWarningImage->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
           m_Controls.labelWarningImage->setText(QString::fromStdString("Select an image."));
           m_ParentWidget->setEnabled(false);
         }
         if (m_CroppingObjectNode != nullptr)
         {
           m_Controls.buttonCropping->setEnabled(true);
           m_Controls.buttonMasking->setEnabled(true);
           m_Controls.boundingShapeSelector->setEnabled(true);
           m_Controls.labelWarningBB->setVisible(false);
         }
         else
         {
           m_Controls.buttonCropping->setEnabled(false);
           m_Controls.buttonMasking->setEnabled(false);
           m_Controls.boundingShapeSelector->setEnabled(false);
           m_Controls.labelWarningBB->setVisible(true);
         }
         return;
       }
       //  iterate all selected objects, adjust warning visibility
       setDefaultGUI();
       m_ParentWidget->setEnabled(true);
       m_Controls.labelWarningRotation->setVisible(false);
     }
   }
 }
 
 void QmitkImageCropper::OnComboBoxSelectionChanged(const mitk::DataNode* node)
 {
   mitk::DataNode* selectedNode = const_cast<mitk::DataNode*>(node);
   if (selectedNode != nullptr)
   {
     if (!m_ImageNode.IsExpired())
       selectedNode->SetDataInteractor(m_ImageNode.Lock()->GetDataInteractor());
     // m_ImageNode->GetDataInteractor()->SetDataNode(selectedNode);
     m_ImageNode = selectedNode;
   }
 }
 
 void QmitkImageCropper::OnSliderValueChanged(int slidervalue)
 {
   m_CropOutsideValue = slidervalue;
 }
 
 void QmitkImageCropper::DoMasking()
 {
   this->ProcessImage(true);
 }
 
 void QmitkImageCropper::DoCropping()
 {
   this->ProcessImage(false);
 }
 
 void QmitkImageCropper::ProcessImage(bool mask)
 {
   // cropping only possible if valid bounding shape as well as a valid image are loaded
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
 
   auto renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN);
   int timeStep = renderWindowPart->GetTimeNavigationController()->GetTime()->GetPos();
 
   if (nodes.empty()) return;
 
   mitk::DataNode* node = nodes[0];
 
   if (node == nullptr)
   {
     QMessageBox::information(nullptr, "Warning", "Please load and select an image before starting image processing.");
     return;
   }
   if (m_CroppingObject == nullptr)
   {
     QMessageBox::information(nullptr, "Warning", "Please load and select a cropping object before starting image processing.");
     return;
   }
 
   mitk::BaseData* data = node->GetData(); //get data from node
   if (data != nullptr)
   {
     QString imageName;
     if (mask)
     {
       imageName = QString::fromStdString(node->GetName() + "_" + m_CroppingObjectNode->GetName() + "_masked");
     }
     else
     {
       imageName = QString::fromStdString(node->GetName() + "_" + m_CroppingObjectNode->GetName() + "_cropped");
     }
 
     if (m_Controls.checkBoxCropTimeStepOnly->isChecked())
     {
       imageName = imageName + "_T" + QString::number(timeStep);
     }
 
     // image and bounding shape ok, set as input
     auto croppedImageNode = mitk::DataNode::New();
     auto cutter = mitk::BoundingShapeCropper::New();
     cutter->SetGeometry(m_CroppingObject);
 
     // adjustable in advanced settings
     cutter->SetUseWholeInputRegion(mask); //either mask (mask=true) or crop (mask=false)
     cutter->SetOutsideValue(m_CropOutsideValue);
     cutter->SetUseCropTimeStepOnly(m_Controls.checkBoxCropTimeStepOnly->isChecked());
     cutter->SetCurrentTimeStep(timeStep);
 
     // TODO: Add support for MultiLayer (right now only Mulitlabel support)
     mitk::LabelSetImage* labelsetImageInput = dynamic_cast<mitk::LabelSetImage*>(data);
     if (labelsetImageInput != nullptr)
     {
       cutter->SetInput(labelsetImageInput);
       // do the actual cutting
       try
       {
         cutter->Update();
       }
       catch (const itk::ExceptionObject& e)
       {
         std::string message = std::string("The Cropping filter could not process because of: \n ") + e.GetDescription();
         QMessageBox::warning(nullptr,
           tr("Cropping not possible!"),
           tr(message.c_str()),
           QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
         return;
       }
 
       auto labelSetImage = mitk::LabelSetImage::New();
       labelSetImage->InitializeByLabeledImage(cutter->GetOutput());
 
       for (unsigned int i = 0; i < labelsetImageInput->GetNumberOfLayers(); i++)
       {
         labelSetImage->AddLabelSetToLayer(i, labelsetImageInput->GetLabelSet(i));
       }
 
       croppedImageNode->SetData(labelSetImage);
       croppedImageNode->SetProperty("name", mitk::StringProperty::New(imageName.toStdString()));
 
       //add cropping result to the current data storage as child node to the image node
       if (!m_Controls.checkOverwriteImage->isChecked())
       {
         if (!this->GetDataStorage()->Exists(croppedImageNode))
         {
           this->GetDataStorage()->Add(croppedImageNode, m_ImageNode.Lock());
         }
       }
       else // original image will be overwritten by the result image and the bounding box of the result is adjusted
       {
         node->SetData(labelSetImage);
         node->Modified();
         // Adjust coordinate system by doing a reinit on
         auto tempDataStorage = mitk::DataStorage::SetOfObjects::New();
         tempDataStorage->InsertElement(0, node);
 
         // initialize the views to the bounding geometry
         auto bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(tempDataStorage);
         mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       }
     }
     else
     {
       mitk::Image::Pointer imageInput = dynamic_cast<mitk::Image*>(data);
       if (imageInput != nullptr)
       {
         cutter->SetInput(imageInput);
         // do the actual cutting
         try
         {
           cutter->Update();
         }
         catch (const itk::ExceptionObject& e)
         {
           std::string message = std::string("The Cropping filter could not process because of: \n ") + e.GetDescription();
 
           QMessageBox::warning(nullptr,
             tr("Cropping not possible!"),
             tr(message.c_str()),
             QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
           return;
         }
 
         //add cropping result to the current data storage as child node to the image node
         if (!m_Controls.checkOverwriteImage->isChecked())
         {
           croppedImageNode->SetData(cutter->GetOutput());
           croppedImageNode->SetProperty("name", mitk::StringProperty::New(imageName.toStdString()));
           croppedImageNode->SetProperty("color", mitk::ColorProperty::New(1.0, 1.0, 1.0));
           croppedImageNode->SetProperty("layer", mitk::IntProperty::New(99)); // arbitrary, copied from segmentation functionality
           if (!this->GetDataStorage()->Exists(croppedImageNode))
           {
             this->GetDataStorage()->Add(croppedImageNode, m_ImageNode.Lock());
           }
         }
         else // original image will be overwritten by the result image and the bounding box of the result is adjusted
         {
           node->SetData(cutter->GetOutput());
           node->Modified();
           // Adjust coordinate system by doing a reinit on
           auto tempDataStorage = mitk::DataStorage::SetOfObjects::New();
           tempDataStorage->InsertElement(0, node);
 
           // initialize the views to the bounding geometry
           auto bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(tempDataStorage);
           mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
           mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
       }
     }
   }
   else
   {
     QMessageBox::information(nullptr, "Warning", "Please load and select an image before starting image processing.");
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.h b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.h
index d406c64715..13cee73a78 100644
--- a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.h
+++ b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.h
@@ -1,173 +1,173 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef QmitkImageCropper_h
 #define QmitkImageCropper_h
 
 #include <QmitkAbstractView.h>
 
 #ifdef WIN32
 #pragma warning( disable : 4250 )
 #endif
 
 #include <QProgressDialog>
 #include "QmitkRegisterClasses.h"
 #include <QList>
 
 #include "itkCommand.h"
 #include <itkImage.h>
 #include <itksys/SystemTools.hxx>
 
 #include <vtkEventQtSlotConnect.h>
 #include <vtkObjectFactory.h>
 #include <vtkRenderWindow.h>
 #include <vtkSmartPointer.h>
 
 #include <mitkBoundingShapeInteractor.h>
 #include <mitkDataStorage.h>
 #include <mitkEventConfig.h>
 #include <mitkGeometryData.h>
 #include <mitkPointSet.h>
 #include <mitkWeakPointer.h>
 
 #include "ui_ImageCropperControls.h"
 
 #include "usServiceRegistration.h"
 
 /*!
 @brief QmitkImageCropperView
 \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
 \sa QmitkFunctionality
 \ingroup ${plugin_target}_internal
 */
 class QmitkImageCropper : public QmitkAbstractView
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
 private:
 
   Q_OBJECT
 
 public:
   /*!
   @brief Constructor. Called by SampleApp (or other apps that use functionalities)
   */
-  QmitkImageCropper(QObject *parent = 0);
+  QmitkImageCropper(QObject *parent = nullptr);
 
   ~QmitkImageCropper() override;
 
   static const std::string VIEW_ID;
 
   void CreateQtPartControl(QWidget *parent) override;
 
   void SetFocus() override;
 
   /*!
   @brief Creates the Qt connections needed
   */
 
   QWidget* GetControls();
 
   /// @brief Called when the user clicks the GUI button
   protected slots:
   /*!
   * @brief Creates a new bounding object
   */
   virtual void DoCreateNewBoundingObject();
   /*!
   * @brief Whenever Crop button is pressed, issue a cropping action
   */
   void DoCropping();
   /*!
   * @brief Whenever Mask button is pressed, issue a masking action
   */
   void DoMasking();
   /*!
   * @brief Dis- or enable the advanced setting section
   */
   void OnAdvancedSettingsButtonToggled();
   /*!
   * @brief Updates current selection of the bounding object
   */
   void OnDataSelectionChanged(const mitk::DataNode* node);
   /*!
   * @brief Sets the scalar value for outside pixels in case of masking
   */
   void OnSliderValueChanged(int slidervalue);
 
 protected:
 
   /*!
  @brief called by QmitkFunctionality when DataManager's selection has changed
   */
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
   /*!
   @brief Sets the selected bounding object as current bounding object and set up interactor
   */
   void OnComboBoxSelectionChanged(const mitk::DataNode* node);
   /*!
   * @brief Initializes a new bounding shape using the selected image geometry.
   */
   mitk::Geometry3D::Pointer InitializeWithImageGeometry(mitk::BaseGeometry::Pointer geometry);
 
   void CreateBoundingShapeInteractor(bool rotationEnabled);
 
 private:
 
   /*!
   * The parent QWidget
   */
   QWidget* m_ParentWidget;
   /*!
   * @brief A pointer to the node of the image to be cropped.
   */
   mitk::WeakPointer<mitk::DataNode> m_ImageNode;
   /*!
   * @brief The cuboid used for cropping.
   */
   mitk::GeometryData::Pointer m_CroppingObject;
 
   /*!
   * @brief Tree node of the cuboid used for cropping.
   */
   mitk::DataNode::Pointer m_CroppingObjectNode;
 
   /*!
   * @brief Interactor for moving and scaling the cuboid
   */
   mitk::BoundingShapeInteractor::Pointer m_BoundingShapeInteractor;
 
   void ProcessImage(bool crop);
 
   /*!
   * @brief Resets GUI to default
   */
   void setDefaultGUI();
 
   QString AdaptBoundingObjectName(const QString& name) const;
 
   // cropping parameter
   mitk::ScalarType m_CropOutsideValue;
   bool m_Advanced;
   bool m_Active;
   bool m_ScrollEnabled;
 
   Ui::ImageCropperControls m_Controls;
 };
 
 #endif // QmitkImageCropper_h
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.batch/src/internal/org_mitk_gui_qt_matchpoint_algorithm_batch_Activator.cpp b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.batch/src/internal/org_mitk_gui_qt_matchpoint_algorithm_batch_Activator.cpp
index df5eb98816..dee5f11ade 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.batch/src/internal/org_mitk_gui_qt_matchpoint_algorithm_batch_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.batch/src/internal/org_mitk_gui_qt_matchpoint_algorithm_batch_Activator.cpp
@@ -1,43 +1,43 @@
 /*===================================================================
 
 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 "org_mitk_gui_qt_matchpoint_algorithm_batch_Activator.h"
 
 #include "QmitkMatchPointBatchProcessor.h"
 
-ctkPluginContext* org_mitk_gui_qt_matchpoint_algorithm_batchprocessing_Activator::m_Context = 0;
+ctkPluginContext* org_mitk_gui_qt_matchpoint_algorithm_batchprocessing_Activator::m_Context = nullptr;
 
 void org_mitk_gui_qt_matchpoint_algorithm_batchprocessing_Activator::start(
   ctkPluginContext* context)
 {
   BERRY_REGISTER_EXTENSION_CLASS(QmitkMatchPointBatchProcessor, context)
 
   m_Context = context;
 }
 
 void org_mitk_gui_qt_matchpoint_algorithm_batchprocessing_Activator::stop(
   ctkPluginContext* context)
 {
   Q_UNUSED(context)
 
-  m_Context = 0;
+  m_Context = nullptr;
 }
 
 ctkPluginContext* org_mitk_gui_qt_matchpoint_algorithm_batchprocessing_Activator::GetContext()
 {
   return m_Context;
 }
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/org_mitk_gui_qt_matchpoint_algorithm_browser_Activator.cpp b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/org_mitk_gui_qt_matchpoint_algorithm_browser_Activator.cpp
index 16c8aea7bf..16f88b6fb7 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/org_mitk_gui_qt_matchpoint_algorithm_browser_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/org_mitk_gui_qt_matchpoint_algorithm_browser_Activator.cpp
@@ -1,40 +1,40 @@
 /*===================================================================
 
 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 "org_mitk_gui_qt_matchpoint_algorithm_browser_Activator.h"
 
 #include "QmitkMatchPointBrowser.h"
 
-ctkPluginContext* org_mitk_gui_qt_matchpoint_algorithm_browser_Activator::m_Context = 0;
+ctkPluginContext* org_mitk_gui_qt_matchpoint_algorithm_browser_Activator::m_Context = nullptr;
 
 void org_mitk_gui_qt_matchpoint_algorithm_browser_Activator::start(ctkPluginContext* context)
 {
     BERRY_REGISTER_EXTENSION_CLASS(QmitkMatchPointBrowser, context)
 
         m_Context = context;
 }
 
 void org_mitk_gui_qt_matchpoint_algorithm_browser_Activator::stop(ctkPluginContext* context)
 {
     Q_UNUSED(context)
 
-        m_Context = 0;
+        m_Context = nullptr;
 }
 
 ctkPluginContext* org_mitk_gui_qt_matchpoint_algorithm_browser_Activator::GetContext()
 {
     return m_Context;
 }
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/src/internal/org_mitk_gui_qt_matchpoint_algorithmcontrol_Activator.cpp b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/src/internal/org_mitk_gui_qt_matchpoint_algorithmcontrol_Activator.cpp
index 0ada6ea8ee..d6d760bc1f 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/src/internal/org_mitk_gui_qt_matchpoint_algorithmcontrol_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/src/internal/org_mitk_gui_qt_matchpoint_algorithmcontrol_Activator.cpp
@@ -1,40 +1,40 @@
 /*===================================================================
 
 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 "org_mitk_gui_qt_matchpoint_algorithmcontrol_Activator.h"
 
 #include "QmitkMatchPoint.h"
 
-ctkPluginContext* org_mitk_gui_qt_matchpoint_algorithmcontrol_Activator::m_Context = 0;
+ctkPluginContext* org_mitk_gui_qt_matchpoint_algorithmcontrol_Activator::m_Context = nullptr;
 
 void org_mitk_gui_qt_matchpoint_algorithmcontrol_Activator::start(ctkPluginContext* context)
 {
     BERRY_REGISTER_EXTENSION_CLASS(QmitkMatchPoint, context)
 
     m_Context = context;
 }
 
 void org_mitk_gui_qt_matchpoint_algorithmcontrol_Activator::stop(ctkPluginContext* context)
 {
     Q_UNUSED(context)
 
-    m_Context = 0;
+    m_Context = nullptr;
 }
 
 ctkPluginContext* org_mitk_gui_qt_matchpoint_algorithmcontrol_Activator::GetContext()
 {
     return m_Context;
 }
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.evaluator/src/internal/org_mitk_gui_qt_matchpoint_evaluator_Activator.cpp b/Plugins/org.mitk.gui.qt.matchpoint.evaluator/src/internal/org_mitk_gui_qt_matchpoint_evaluator_Activator.cpp
index cf7305d1d7..bae68a3e46 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.evaluator/src/internal/org_mitk_gui_qt_matchpoint_evaluator_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.evaluator/src/internal/org_mitk_gui_qt_matchpoint_evaluator_Activator.cpp
@@ -1,43 +1,43 @@
 /*===================================================================
 
 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 "org_mitk_gui_qt_matchpoint_evaluator_Activator.h"
 
 #include "QmitkMatchPointRegistrationEvaluator.h"
 
-ctkPluginContext* org_mitk_gui_qt_matchpoint_evaluator_Activator::m_Context = 0;
+ctkPluginContext* org_mitk_gui_qt_matchpoint_evaluator_Activator::m_Context = nullptr;
 
 void org_mitk_gui_qt_matchpoint_evaluator_Activator::start(
     ctkPluginContext* context)
 {
 	BERRY_REGISTER_EXTENSION_CLASS(QmitkMatchPointRegistrationEvaluator, context)
 
 	m_Context = context;
 }
 
 void org_mitk_gui_qt_matchpoint_evaluator_Activator::stop(
     ctkPluginContext* context)
 {
 	Q_UNUSED(context)
 
-	m_Context = 0;
+	m_Context = nullptr;
 }
 
 ctkPluginContext* org_mitk_gui_qt_matchpoint_evaluator_Activator::GetContext()
 {
 	return m_Context;
 }
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/org_mitk_gui_qt_matchpoint_framereg_Activator.cpp b/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/org_mitk_gui_qt_matchpoint_framereg_Activator.cpp
index caeb744749..c9e0bf8aa2 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/org_mitk_gui_qt_matchpoint_framereg_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/org_mitk_gui_qt_matchpoint_framereg_Activator.cpp
@@ -1,40 +1,40 @@
 /*===================================================================
 
 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 "org_mitk_gui_qt_matchpoint_framereg_Activator.h"
 
 #include "QmitkMatchPointFrameCorrection.h"
 
-ctkPluginContext* org_mitk_gui_qt_matchpoint_framereg_Activator::m_Context = 0;
+ctkPluginContext* org_mitk_gui_qt_matchpoint_framereg_Activator::m_Context = nullptr;
 
 void org_mitk_gui_qt_matchpoint_framereg_Activator::start(ctkPluginContext* context)
 {
     BERRY_REGISTER_EXTENSION_CLASS(QmitkMatchPointFrameCorrection, context)
 
         m_Context = context;
 }
 
 void org_mitk_gui_qt_matchpoint_framereg_Activator::stop(ctkPluginContext* context)
 {
     Q_UNUSED(context)
 
-        m_Context = 0;
+        m_Context = nullptr;
 }
 
 ctkPluginContext* org_mitk_gui_qt_matchpoint_framereg_Activator::GetContext()
 {
     return m_Context;
 }
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/org_mitk_gui_qt_matchpoint_manipulator_Activator.cpp b/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/org_mitk_gui_qt_matchpoint_manipulator_Activator.cpp
index 864fe1d2f5..c7361252b6 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/org_mitk_gui_qt_matchpoint_manipulator_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/org_mitk_gui_qt_matchpoint_manipulator_Activator.cpp
@@ -1,43 +1,43 @@
 /*===================================================================
 
 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 "org_mitk_gui_qt_matchpoint_manipulator_Activator.h"
 
 #include "QmitkMatchPointRegistrationManipulator.h"
 
-ctkPluginContext* org_mitk_gui_qt_matchpoint_manipulator_Activator::m_Context = 0;
+ctkPluginContext* org_mitk_gui_qt_matchpoint_manipulator_Activator::m_Context = nullptr;
 
 void org_mitk_gui_qt_matchpoint_manipulator_Activator::start(
     ctkPluginContext* context)
 {
 	BERRY_REGISTER_EXTENSION_CLASS(QmitkMatchPointRegistrationManipulator, context)
 
 	m_Context = context;
 }
 
 void org_mitk_gui_qt_matchpoint_manipulator_Activator::stop(
     ctkPluginContext* context)
 {
 	Q_UNUSED(context)
 
-	m_Context = 0;
+	m_Context = nullptr;
 }
 
 ctkPluginContext* org_mitk_gui_qt_matchpoint_manipulator_Activator::GetContext()
 {
 	return m_Context;
 }
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.mapper/src/internal/org_mitk_gui_qt_matchpoint_mapper_Activator.cpp b/Plugins/org.mitk.gui.qt.matchpoint.mapper/src/internal/org_mitk_gui_qt_matchpoint_mapper_Activator.cpp
index 46f4a5770d..b8b3964109 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.mapper/src/internal/org_mitk_gui_qt_matchpoint_mapper_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.mapper/src/internal/org_mitk_gui_qt_matchpoint_mapper_Activator.cpp
@@ -1,41 +1,41 @@
 /*===================================================================
 
 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 "org_mitk_gui_qt_matchpoint_mapper_Activator.h"
 
 #include "QmitkMatchPointMapper.h"
 
-ctkPluginContext* org_mitk_gui_qt_matchpoint_mapper_Activator::m_Context = 0;
+ctkPluginContext* org_mitk_gui_qt_matchpoint_mapper_Activator::m_Context = nullptr;
 
 void org_mitk_gui_qt_matchpoint_mapper_Activator::start(ctkPluginContext* context)
 {
     BERRY_REGISTER_EXTENSION_CLASS(QmitkMatchPointMapper, context)
 
         m_Context = context;
 }
 
 void org_mitk_gui_qt_matchpoint_mapper_Activator::stop(ctkPluginContext* context)
 {
     Q_UNUSED(context)
 
-        m_Context = 0;
+        m_Context = nullptr;
 }
 
 ctkPluginContext* org_mitk_gui_qt_matchpoint_mapper_Activator::GetContext()
 {
     return m_Context;
 }
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/org_mitk_gui_qt_matchpoint_visualizer_Activator.cpp b/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/org_mitk_gui_qt_matchpoint_visualizer_Activator.cpp
index 9cb784fc7f..cc3aeada18 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/org_mitk_gui_qt_matchpoint_visualizer_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/org_mitk_gui_qt_matchpoint_visualizer_Activator.cpp
@@ -1,43 +1,43 @@
 /*===================================================================
 
 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 "org_mitk_gui_qt_matchpoint_visualizer_Activator.h"
 
 #include "QmitkMatchPointRegistrationVisualizer.h"
 
-ctkPluginContext* org_mitk_gui_qt_matchpoint_visualizer_Activator::m_Context = 0;
+ctkPluginContext* org_mitk_gui_qt_matchpoint_visualizer_Activator::m_Context = nullptr;
 
 void org_mitk_gui_qt_matchpoint_visualizer_Activator::start(
     ctkPluginContext* context)
 {
     BERRY_REGISTER_EXTENSION_CLASS(QmitkMatchPointRegistrationVisualizer, context)
 
         m_Context = context;
 }
 
 void org_mitk_gui_qt_matchpoint_visualizer_Activator::stop(
     ctkPluginContext* context)
 {
     Q_UNUSED(context)
 
-        m_Context = 0;
+        m_Context = nullptr;
 }
 
 ctkPluginContext* org_mitk_gui_qt_matchpoint_visualizer_Activator::GetContext()
 {
     return m_Context;
 }
diff --git a/Plugins/org.mitk.gui.qt.materialeditor/src/internal/QmitkMITKSurfaceMaterialEditorView.cpp b/Plugins/org.mitk.gui.qt.materialeditor/src/internal/QmitkMITKSurfaceMaterialEditorView.cpp
index 0ed3e54de0..dec5e3c1dc 100644
--- a/Plugins/org.mitk.gui.qt.materialeditor/src/internal/QmitkMITKSurfaceMaterialEditorView.cpp
+++ b/Plugins/org.mitk.gui.qt.materialeditor/src/internal/QmitkMITKSurfaceMaterialEditorView.cpp
@@ -1,244 +1,244 @@
 /*===================================================================
 
 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 "QmitkMITKSurfaceMaterialEditorView.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkProperties.h"
 #include "mitkIDataStorageService.h"
 #include "mitkDataNodeObject.h"
 
 #include "berryIEditorPart.h"
 #include "berryIWorkbenchPage.h"
 
 #include "QmitkDataStorageComboBox.h"
 
 #include <vtkSphereSource.h>
 #include <vtkPolyData.h>
 #include <vtkCamera.h>
 #include <vtkRenderer.h>
 #include <vtkTextActor.h>
 #include <vtkRenderer.h>
 #include <vtkTextProperty.h>
 #include <vtkCoordinate.h>
 #include <vtkActor.h>
 #include <vtkProperty.h>
 
 #include <mitkVtkPropRenderer.h>
 #include <mitkVtkLayerController.h>
 
 #include <qmessagebox.h>
 
 #include "mitkStandaloneDataStorage.h"
 
 
 
 const std::string QmitkMITKSurfaceMaterialEditorView::VIEW_ID = "org.mitk.views.mitksurfacematerialeditor";
 
 QmitkMITKSurfaceMaterialEditorView::QmitkMITKSurfaceMaterialEditorView()
 : QmitkAbstractView(),
   m_Controls(nullptr)
 {
   fixedProperties.push_back( "shader" );
   fixedProperties.push_back( "material.representation" );
   fixedProperties.push_back( "color" );
   fixedProperties.push_back( "opacity" );
   fixedProperties.push_back( "material.wireframeLineWidth" );
 
   fixedProperties.push_back( "material.ambientCoefficient" );
   fixedProperties.push_back( "material.diffuseCoefficient" );
   fixedProperties.push_back( "material.ambientColor" );
   fixedProperties.push_back( "material.diffuseColor" );
   fixedProperties.push_back( "material.specularColor" );
   fixedProperties.push_back( "material.specularCoefficient" );
   fixedProperties.push_back( "material.specularPower" );
   fixedProperties.push_back( "material.interpolation" );
 
   shaderProperties.push_back( "shader" );
   shaderProperties.push_back( "material.representation" );
   shaderProperties.push_back( "color" );
   shaderProperties.push_back( "opacity" );
   shaderProperties.push_back( "material.wireframeLineWidth" );
 
   observerAllocated = false;
 }
 
 QmitkMITKSurfaceMaterialEditorView::~QmitkMITKSurfaceMaterialEditorView()
 {
 }
 
 void QmitkMITKSurfaceMaterialEditorView::InitPreviewWindow()
 {
   usedTimer=0;
 
   vtkSphereSource* sphereSource = vtkSphereSource::New();
   sphereSource->SetThetaResolution(25);
   sphereSource->SetPhiResolution(25);
   sphereSource->Update();
 
   vtkPolyData* sphere = sphereSource->GetOutput();
 
   m_Surface = mitk::Surface::New();
   m_Surface->SetVtkPolyData( sphere );
 
   m_DataNode = mitk::DataNode::New();
   m_DataNode->SetData( m_Surface );
 
   m_DataTree = mitk::StandaloneDataStorage::New();
 
-  m_DataTree->Add( m_DataNode , (mitk::DataNode *)0 );
+  m_DataTree->Add( m_DataNode , (mitk::DataNode *)nullptr );
 
   m_Controls->m_PreviewRenderWindow->GetRenderer()->SetDataStorage( m_DataTree );
   m_Controls->m_PreviewRenderWindow->GetRenderer()->SetMapperID( mitk::BaseRenderer::Standard3D );
 
   sphereSource->Delete();
 }
 
 
 void QmitkMITKSurfaceMaterialEditorView::RefreshPropertiesList()
 {
   mitk::DataNode* SrcND = m_SelectedDataNode;
   mitk::DataNode* DstND = m_DataNode;
 
   mitk::PropertyList* DstPL = DstND->GetPropertyList();
 
 
-  m_Controls->m_ShaderPropertyList->SetPropertyList( 0 );
+  m_Controls->m_ShaderPropertyList->SetPropertyList( nullptr );
 
   DstPL->Clear();
 
   if(observerAllocated)
   {
     observerAllocated=false;
   }
 
   if(SrcND)
   {
     mitk::PropertyList* SrcPL = SrcND->GetPropertyList();
 
     std::string shaderState = "fixed";
 
 //    if(shaderEnum.IsNotNull())
 //    {
 //      shaderState = shaderEnum->GetValueAsString();
 
 //      itk::MemberCommand<QmitkMITKSurfaceMaterialEditorView>::Pointer propertyModifiedCommand = itk::MemberCommand<QmitkMITKSurfaceMaterialEditorView>::New();
 //      propertyModifiedCommand->SetCallbackFunction(this, &QmitkMITKSurfaceMaterialEditorView::shaderEnumChange);
 //      observerIndex = shaderEnum->AddObserver(itk::ModifiedEvent(), propertyModifiedCommand);
 //      observedProperty = shaderEnum;
 //      observerAllocated=true;
 //    }
 
     MITK_INFO << "PROPERTIES SCAN BEGIN";
 
     for(mitk::PropertyList::PropertyMap::const_iterator it=SrcPL->GetMap()->begin(); it!=SrcPL->GetMap()->end(); it++)
     {
       std::string name=it->first;
       mitk::BaseProperty *p=it->second;
 
       // MITK_INFO << "property '" << name << "' found";
 
       if(shaderState.compare("fixed")==0)
       {
         if(std::find(fixedProperties.begin(), fixedProperties.end(), name) != fixedProperties.end())
         {
           DstPL->SetProperty(name,p);
         }
       }
       else
       {
         //if(std::find(shaderProperties.begin(), shaderProperties.end(), name) != shaderProperties.end())
         {
           DstPL->SetProperty(name,p);
         }
       }
     }
 
     MITK_INFO << "PROPERTIES SCAN END";
   }
 
   m_Controls->m_ShaderPropertyList->SetPropertyList( DstPL );
   //m_Controls->m_PreviewRenderWindow->GetRenderer()->GetVtkRenderer()->ResetCameraClippingRange();
 }
 
 void QmitkMITKSurfaceMaterialEditorView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkMITKSurfaceMaterialEditorViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     InitPreviewWindow();
     RefreshPropertiesList();
 
   }
 }
 
 void QmitkMITKSurfaceMaterialEditorView::SetFocus()
 {
   m_Controls->m_ShaderPropertyList->setFocus();
 }
 
 void QmitkMITKSurfaceMaterialEditorView::CreateConnections()
 {
 }
 
 void QmitkMITKSurfaceMaterialEditorView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   if(!nodes.empty())
   {
     m_SelectedDataNode = nodes.at(0);
     MITK_INFO << "Node '" << m_SelectedDataNode->GetName() << "' selected";
     SurfaceSelected();
   }
 }
 
 void QmitkMITKSurfaceMaterialEditorView::SurfaceSelected()
 {
   postRefresh();
 }
 
 void QmitkMITKSurfaceMaterialEditorView::shaderEnumChange(const itk::Object * /*caller*/, const itk::EventObject & /*event*/)
 {
   postRefresh();
 }
 
 void QmitkMITKSurfaceMaterialEditorView::postRefresh()
 {
   if(usedTimer)
     return;
 
   usedTimer=startTimer(0);
 }
 
 void QmitkMITKSurfaceMaterialEditorView::timerEvent( QTimerEvent *e )
 {
   if(usedTimer!=e->timerId())
   {
     MITK_ERROR << "INTERNAL ERROR: usedTimer[" << usedTimer << "] != timerId[" << e->timerId() << "]";
   }
 
   if(usedTimer)
   {
     killTimer(usedTimer);
     usedTimer=0;
   }
 
   RefreshPropertiesList();
 }
diff --git a/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.cpp b/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.cpp
index f53d60f60d..882d3be16d 100644
--- a/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.cpp
+++ b/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.cpp
@@ -1,495 +1,495 @@
 /*===================================================================
 
 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 "QmitkScreenshotMaker.h"
 //#include "QmitkMovieMakerControls.h"
 #include "QmitkStepperAdapter.h"
 
 #include "mitkVtkPropRenderer.h"
 #include <QmitkRenderWindow.h>
 
 #include <iostream>
 
 #include <vtkRenderer.h>
 #include <vtkCamera.h>
 
 #include <qaction.h>
 #include <qfiledialog.h>
 #include <qtimer.h>
 #include <qdatetime.h>
 #include <qspinbox.h>
 #include <qcombobox.h>
 #include <qcolor.h>
 #include <qcolordialog.h>
 
 #include "qapplication.h"
 
 #include "vtkImageWriter.h"
 #include "vtkJPEGWriter.h"
 #include "vtkPNGWriter.h"
 #include "vtkRenderLargeImage.h"
 #include "vtkRenderWindowInteractor.h"
 #include "vtkRenderer.h"
 #include "vtkTestUtilities.h"
 
 #include <vtkActor.h>
 #include "vtkMitkRenderProp.h"
 
 #include <vtkRenderer.h>
 #include <vtkRenderWindow.h>
 #include "vtkRenderWindowInteractor.h"
 #include <qradiobutton.h>
 
 #include "mitkSliceNavigationController.h"
 #include "mitkPlanarFigure.h"
 #include <mitkWorkbenchUtil.h>
 #include <mitkImage.h>
 #include <itksys/SystemTools.hxx>
 
 QmitkScreenshotMaker::QmitkScreenshotMaker(QObject *parent, const char * /*name*/)
   : QmitkAbstractView(),
     m_Controls(nullptr),
     m_BackgroundColor(QColor(0,0,0)),
-    m_SelectedNode(0)
+    m_SelectedNode(nullptr)
 {
   parentWidget = parent;
 }
 
 QmitkScreenshotMaker::~QmitkScreenshotMaker()
 {
 }
 
 void QmitkScreenshotMaker::CreateConnections()
 {
   if (m_Controls)
   {
     connect((QObject*) m_Controls->m_AllViews, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateMultiplanar3DHighresScreenshot()));
     connect((QObject*) m_Controls->m_Shot, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateMultiplanarScreenshots()));
     connect((QObject*) m_Controls->m_BackgroundColor, SIGNAL(clicked()), (QObject*) this, SLOT(SelectBackgroundColor()));
     connect((QObject*) m_Controls->btnScreenshot, SIGNAL(clicked()), this, SLOT(GenerateScreenshot()));
     connect((QObject*) m_Controls->m_HRScreenshot, SIGNAL(clicked()), this, SLOT(Generate3DHighresScreenshot()));
 
     QString styleSheet = "background-color:rgb(0,0,0)";
     m_Controls->m_BackgroundColor->setStyleSheet(styleSheet);
   }
 }
 
 mitk::DataNode::Pointer QmitkScreenshotMaker::GetTopLayerNode()
 {
   mitk::DataNode::Pointer out = nullptr;
 
   int layer = -1;
   auto nodes = GetDataStorage()->GetAll();
   for (auto node = nodes->begin(); node!=nodes->end(); ++node)
   {
     if (!(*node)->IsVisible(nullptr))
       continue;
     int current_layer;
     (*node)->GetIntProperty("layer", current_layer);
     if (current_layer>layer)
     {
       out = (*node);
       layer = current_layer;
     }
   }
 
   return out;
 }
 
 void QmitkScreenshotMaker::MultichannelScreenshot(mitk::VtkPropRenderer* renderer, QString fileName, QString filter)
 {
   auto node = GetTopLayerNode();
   if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
   {
     auto image = dynamic_cast<mitk::Image*>(node->GetData());
 
     std::string fname = itksys::SystemTools::GetFilenamePath(fileName.toStdString()) + "/" + itksys::SystemTools::GetFilenameWithoutExtension(fileName.toStdString());
     std::string ext = itksys::SystemTools::GetFilenameExtension(fileName.toStdString());
 
     mitk::PixelType chPixelType = image->GetImageDescriptor()->GetChannelTypeById(0);
     if (image->GetDimension() == 4)
     {
       MITK_INFO << "LOOPING THROUGH FOURTH DIMESNION IS NOT IMPLEMENTED";
     }
     else if (chPixelType.GetNumberOfComponents()>1)
     {
       for(int unsigned c=0; c<chPixelType.GetNumberOfComponents(); ++c)
       {
         node->SetProperty("Image.Displayed Component", mitk::IntProperty::New(c));
         this->TakeScreenshot(renderer->GetVtkRenderer(), 1, QString(fname.c_str()) + "_" + QString::number(c) + QString(ext.c_str()), filter);
       }
     }
     else
       this->TakeScreenshot(renderer->GetVtkRenderer(), 1, fileName, filter);
   }
   else
     this->TakeScreenshot(renderer->GetVtkRenderer(), 1, fileName, filter);
 }
 
 void QmitkScreenshotMaker::GenerateScreenshot()
 {
   if (m_LastFile.size()==0)
     m_LastFile = QDir::currentPath()+"/screenshot.png";
 
   QString filter;
   QString fileName = QFileDialog::getSaveFileName(nullptr, "Save screenshot to...", m_LastFile, m_PNGExtension + ";;" + m_JPGExtension, &filter);
 
   if (fileName.size()>0)
     m_LastFile = fileName;
 
   auto renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN);
 
   auto renderer = renderWindowPart->GetQmitkRenderWindow(m_Controls->m_DirectionBox->currentText())->GetRenderer();
   if (renderer == nullptr)
     return;
 
   if (m_Controls->m_AllChannelsBox->isChecked())
     MultichannelScreenshot(renderer, fileName, filter);
   else
     this->TakeScreenshot(renderer->GetVtkRenderer(), 1, fileName, filter);
 }
 
 void QmitkScreenshotMaker::GenerateMultiplanarScreenshots()
 {
   if (m_LastPath.size()==0)
     m_LastPath = QDir::currentPath();
   QString filePath = QFileDialog::getExistingDirectory(nullptr, "Save screenshots to...", m_LastPath);
   if (filePath.size()>0)
     m_LastPath = filePath;
 
   if( filePath.isEmpty() )
   {
     return;
   }
 
   //emit StartBlockControls();
   auto renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN);
   renderWindowPart->EnableDecorations(false, QStringList{mitk::IRenderWindowPart::DECORATION_CORNER_ANNOTATION});
 
   QString fileName = "/axial.png";
   int c = 1;
   while (QFile::exists(filePath+fileName))
   {
     fileName = QString("/axial_");
     fileName += QString::number(c);
     fileName += ".png";
     c++;
   }
   vtkRenderer* renderer = renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer()->GetVtkRenderer();
   if (renderer != nullptr)
   {
     if (m_Controls->m_AllChannelsBox->isChecked())
       MultichannelScreenshot(renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer(), filePath+fileName, m_PNGExtension);
     else
       this->TakeScreenshot(renderer, 1, filePath+fileName);
   }
 
   fileName = "/sagittal.png";
   c = 1;
   while (QFile::exists(filePath+fileName))
   {
     fileName = QString("/sagittal_");
     fileName += QString::number(c);
     fileName += ".png";
     c++;
   }
   renderer = renderWindowPart->GetQmitkRenderWindow("sagittal")->GetRenderer()->GetVtkRenderer();
   if (renderer != nullptr)
   {
     if (m_Controls->m_AllChannelsBox->isChecked())
       MultichannelScreenshot(renderWindowPart->GetQmitkRenderWindow("sagittal")->GetRenderer(), filePath+fileName, m_PNGExtension);
     else
       this->TakeScreenshot(renderer, 1, filePath+fileName);
   }
 
   fileName = "/coronal.png";
   c = 1;
   while (QFile::exists(filePath+fileName))
   {
     fileName = QString("/coronal_");
     fileName += QString::number(c);
     fileName += ".png";
     c++;
   }
   renderer = renderWindowPart->GetQmitkRenderWindow("coronal")->GetRenderer()->GetVtkRenderer();
   if (renderer != nullptr)
   {
     if (m_Controls->m_AllChannelsBox->isChecked())
       MultichannelScreenshot(renderWindowPart->GetQmitkRenderWindow("coronal")->GetRenderer(), filePath+fileName, m_PNGExtension);
     else
       this->TakeScreenshot(renderer, 1, filePath+fileName);
   }
 
   /// TODO I do not find a simple way of doing this through the render window part API,
   /// however, I am also not convinced that this code is needed at all. The colour
   /// of the crosshair planes is never set to any colour other than these.
   /// I suggest a new 'mitk::DataNode* mitk::ILinkedRendererPart::GetSlicingPlane(const std::string& name) const'
   /// function to introduce that could return the individual ("axial", "sagittal" or
   /// "coronal" crosshair planes.
 
   //    mitk::DataNode* n = renderWindowPart->GetSlicingPlane("axial");
   //    if (n)
   //    {
   //        n->SetProperty( "color", mitk::ColorProperty::New( 1,0,0 ) );
   //    }
   //
   //    n = renderWindowPart->GetSlicingPlane("sagittal");
   //    if (n)
   //    {
   //        n->SetProperty( "color", mitk::ColorProperty::New( 0,1,0 ) );
   //    }
   //
   //    n = renderWindowPart->GetSlicingPlane("coronal");
   //    if (n)
   //    {
   //        n->SetProperty( "color", mitk::ColorProperty::New( 0,0,1 ) );
   //    }
 
   renderWindowPart->EnableDecorations(true, QStringList{mitk::IRenderWindowPart::DECORATION_CORNER_ANNOTATION});
 }
 
 void QmitkScreenshotMaker::Generate3DHighresScreenshot()
 {
   if (m_LastFile.size()==0)
     m_LastFile = QDir::currentPath()+"/3D_screenshot.png";
 
   QString filter;
   QString fileName = QFileDialog::getSaveFileName(nullptr, "Save screenshot to...", m_LastFile, m_PNGExtension + ";;" + m_JPGExtension, &filter);
 
   if (fileName.size()>0)
     m_LastFile = fileName;
   GenerateHR3DAtlasScreenshots(fileName, filter);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkScreenshotMaker::GenerateMultiplanar3DHighresScreenshot()
 {
   if (m_LastPath.size()==0)
     m_LastPath = QDir::currentPath();
   QString filePath = QFileDialog::getExistingDirectory( nullptr, "Save screenshots to...", m_LastPath);
   if (filePath.size()>0)
     m_LastPath = filePath;
 
   if( filePath.isEmpty() )
   {
     return;
   }
 
   QString fileName = "/3D_View1.png";
   int c = 1;
   while (QFile::exists(filePath+fileName))
   {
     fileName = QString("/3D_View1_");
     fileName += QString::number(c);
     fileName += ".png";
     c++;
   }
   GetCam()->Azimuth( -7.5 );
   GetCam()->Roll(-4);
   GenerateHR3DAtlasScreenshots(filePath+fileName);
   GetCam()->Roll(4);
 
   fileName = "/3D_View2.png";
   c = 1;
   while (QFile::exists(filePath+fileName))
   {
     fileName = QString("/3D_View2_");
     fileName += QString::number(c);
     fileName += ".png";
     c++;
   }
   GetCam()->Azimuth( 90 );
   GetCam()->Elevation( 4 );
   GenerateHR3DAtlasScreenshots(filePath+fileName);
 
   fileName = "/3D_View3.png";
   c = 1;
   while (QFile::exists(filePath+fileName))
   {
     fileName = QString("/3D_View3_");
     fileName += QString::number(c);
     fileName += ".png";
     c++;
   }
   GetCam()->Elevation( 90 );
   GetCam()->Roll( -2.5 );
   GenerateHR3DAtlasScreenshots(filePath+fileName);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkScreenshotMaker::GenerateHR3DAtlasScreenshots(QString fileName, QString filter)
 {
   // only works correctly for 3D RenderWindow
   this->GetRenderWindowPart()->EnableDecorations(false, QStringList{mitk::IRenderWindowPart::DECORATION_CORNER_ANNOTATION});
   vtkRenderer* renderer = this->GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderer()->GetVtkRenderer();
   if (renderer == nullptr)
     return;
   this->TakeScreenshot(renderer, this->m_Controls->m_MagFactor->text().toFloat(), fileName, filter);
   this->GetRenderWindowPart()->EnableDecorations(true, QStringList{mitk::IRenderWindowPart::DECORATION_CORNER_ANNOTATION});
 }
 
 vtkCamera* QmitkScreenshotMaker::GetCam()
 {
   mitk::BaseRenderer* renderer = this->GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN)->GetQmitkRenderWindow("3d")->GetRenderer();
-  vtkCamera* cam = 0;
+  vtkCamera* cam = nullptr;
   const mitk::VtkPropRenderer *propRenderer = dynamic_cast<const mitk::VtkPropRenderer * >( renderer );
   if (propRenderer)
   {
     // get vtk renderer
     vtkRenderer* vtkrenderer = propRenderer->GetVtkRenderer();
     if (vtkrenderer)
     {
       // get vtk camera
       vtkCamera* vtkcam = vtkrenderer->GetActiveCamera();
       if (vtkcam)
       {
         // vtk smart pointer handling
         cam = vtkcam;
         cam->Register( nullptr );
       }
     }
   }
   return cam;
 }
 
 void QmitkScreenshotMaker::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   if(nodes.size())
     m_SelectedNode = nodes[0];
 }
 
 void QmitkScreenshotMaker::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     m_Parent = parent;
     m_Controls = new Ui::QmitkScreenshotMakerControls;
     m_Controls->setupUi(parent);
 
     // Initialize "Selected Window" combo box
     const mitk::RenderingManager::RenderWindowVector rwv =
         mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
 
   }
 
   this->CreateConnections();
 
 }
 
 void QmitkScreenshotMaker::SetFocus()
 {
   m_Controls->btnScreenshot->setFocus();
 }
 
 void QmitkScreenshotMaker::RenderWindowPartActivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_Parent->setEnabled(true);
 }
 
 void QmitkScreenshotMaker::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_Parent->setEnabled(false);
 }
 
 void QmitkScreenshotMaker::TakeScreenshot(vtkRenderer* renderer, unsigned int magnificationFactor, QString fileName, QString filter)
 {
   if ((renderer == nullptr) ||(magnificationFactor < 1) || fileName.isEmpty())
     return;
 
   bool doubleBuffering( renderer->GetRenderWindow()->GetDoubleBuffer() );
   renderer->GetRenderWindow()->DoubleBufferOff();
 
   vtkImageWriter* fileWriter = nullptr;
 
   QFileInfo fi(fileName);
   QString suffix = fi.suffix().toLower();
 
   if (suffix.isEmpty() || (suffix != "png" && suffix != "jpg" && suffix != "jpeg"))
   {
     if (filter == m_PNGExtension)
     {
       suffix = "png";
     }
     else if (filter == m_JPGExtension)
     {
       suffix = "jpg";
     }
     fileName += "." + suffix;
   }
 
   if (suffix.compare("jpg", Qt::CaseInsensitive) == 0 || suffix.compare("jpeg", Qt::CaseInsensitive) == 0)
   {
     vtkJPEGWriter* w = vtkJPEGWriter::New();
     w->SetQuality(100);
     w->ProgressiveOff();
     fileWriter = w;
   }
   else //default is png
   {
     fileWriter = vtkPNGWriter::New();
   }
 
   vtkRenderLargeImage* magnifier = vtkRenderLargeImage::New();
   magnifier->SetInput(renderer);
   magnifier->SetMagnification(magnificationFactor);
   //magnifier->Update();
   fileWriter->SetInputConnection(magnifier->GetOutputPort());
   fileWriter->SetFileName(fileName.toLatin1());
 
   // vtkRenderLargeImage has problems with different layers, therefore we have to
   // temporarily deactivate all other layers.
   // we set the background to white, because it is nicer than black...
   double oldBackground[3];
   renderer->GetBackground(oldBackground);
 
 
   //  QColor color = QColorDialog::getColor();
   double bgcolor[] = {m_BackgroundColor.red()/255.0, m_BackgroundColor.green()/255.0, m_BackgroundColor.blue()/255.0};
   renderer->SetBackground(bgcolor);
 
   mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
 
   renderWindowPart->EnableDecorations(false);
 
   fileWriter->Write();
   fileWriter->Delete();
 
   renderWindowPart->EnableDecorations(true);
 
   renderer->SetBackground(oldBackground);
 
   renderer->GetRenderWindow()->SetDoubleBuffer(doubleBuffering);
 }
 
 void QmitkScreenshotMaker::SelectBackgroundColor()
 {
   m_BackgroundColor = QColorDialog::getColor();
 
   m_Controls->m_BackgroundColor->setAutoFillBackground(true);
 
 
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(m_BackgroundColor.red()));
   styleSheet.append(",");
   styleSheet.append(QString::number(m_BackgroundColor.green()));
   styleSheet.append(",");
   styleSheet.append(QString::number(m_BackgroundColor.blue()));
   styleSheet.append(")");
   m_Controls->m_BackgroundColor->setStyleSheet(styleSheet);
 }
diff --git a/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.h b/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.h
index 6330112769..ceae0ffe26 100644
--- a/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.h
+++ b/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.h
@@ -1,132 +1,132 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #if !defined(QMITK_ScreenshotMaker_H__INCLUDED)
 #define QMITK_ScreenshotMaker_H__INCLUDED
 
 #include <QmitkAbstractView.h>
 #include <mitkIRenderWindowPartListener.h>
 
 #include "mitkCameraRotationController.h"
 #include "mitkStepper.h"
 #include "mitkMultiStepper.h"
 #include "mitkMovieGenerator.h"
 #include "itkCommand.h"
 
 #include "vtkEventQtSlotConnect.h"
 #include "vtkRenderWindow.h"
 #include "mitkVtkPropRenderer.h"
 
 #include "ui_QmitkScreenshotMakerControls.h"
 //#include "../MovieMakerDll.h"
 
 //class QmitkMovieMakerControls;
 class QmitkStepperAdapter;
 class vtkCamera;
 class QTimer;
 class QTime;
 
 /**
  * \brief View for creating movies (AVIs)
  */
 class QmitkScreenshotMaker: public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   Q_OBJECT
 
 public:
   /** \brief Constructor. */
-  QmitkScreenshotMaker(QObject *parent=0, const char *name=0);
+  QmitkScreenshotMaker(QObject *parent=nullptr, const char *name=nullptr);
 
   /** \brief Destructor. */
   ~QmitkScreenshotMaker() override;
 
   /** \brief Method for creating the widget containing the application
    * controls, like sliders, buttons etc.
    */
   void CreateQtPartControl(QWidget *parent) override;
   //  virtual QWidget * CreateControlWidget(QWidget *parent);
 
   ///
   /// Sets the focus to an internal widget.
   ///
   void SetFocus() override;
 
   /** \brief Method for creating the connections of main and control widget.
    */
   virtual void CreateConnections();
 
   /** \brief Method for creating an QAction object, i.e. button & menu entry.
    * @param parent the parent QWidget
    */
   //  virtual QAction * CreateAction(QActionGroup *parent);
 
   ///
   /// Called when a RenderWindowPart becomes available.
   ///
   void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
   ///
   /// Called when a RenderWindowPart becomes unavailable.
   ///
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override;
 
   signals:
 
 protected slots:
 
   void GenerateScreenshot();
   void GenerateMultiplanarScreenshots();
   void Generate3DHighresScreenshot();
   void GenerateMultiplanar3DHighresScreenshot();
   void SelectBackgroundColor();
 
 protected:
 
   QObject *parentWidget;
   QWidget* m_Parent;
   vtkEventQtSlotConnect * connections;
   vtkRenderWindow * renderWindow;
   mitk::VtkPropRenderer::Pointer m_PropRenderer;
 
   Ui::QmitkScreenshotMakerControls* m_Controls;
 
 private:
 
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   vtkCamera* GetCam();
   void GenerateHR3DAtlasScreenshots(QString fileName, QString filter = "");
   void GenerateMultiplanarScreenshots(QString fileName);
 
   mitk::DataNode::Pointer GetTopLayerNode();
   void MultichannelScreenshot(mitk::VtkPropRenderer* renderer, QString fileName, QString filter);
 
   /*!
   \brief taking a screenshot "from" the specified renderer
   \param magnificationFactor specifying the quality of the screenshot (the magnification of the actual RenderWindow size)
   \param fileName file location and name where the screenshot should be saved
   */
   void TakeScreenshot(vtkRenderer* renderer, unsigned int magnificationFactor, QString fileName, QString filter = "");
 
   QColor m_BackgroundColor;
 
   mitk::DataNode* m_SelectedNode;
   QString           m_LastPath;
   QString           m_LastFile;
   QString           m_PNGExtension = "PNG File (*.png)";
   QString           m_JPGExtension = "JPEG File (*.jpg)";
 };
 #endif // !defined(QMITK_ScreenshotMaker_H__INCLUDED)
 
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/QmitkMultiLabelSegmentationPreferencePage.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/QmitkMultiLabelSegmentationPreferencePage.cpp
index b7e9811848..0ec3458d21 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/QmitkMultiLabelSegmentationPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/QmitkMultiLabelSegmentationPreferencePage.cpp
@@ -1,170 +1,170 @@
 /*===================================================================
 
 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 "QmitkMultiLabelSegmentationPreferencePage.h"
 
 #include <QLabel>
 #include <QPushButton>
 #include <QFormLayout>
 #include <QCheckBox>
 #include <QGroupBox>
 #include <QRadioButton>
 #include <QMessageBox>
 #include <QDoubleSpinBox>
 
 #include <berryIPreferencesService.h>
 #include <berryPlatform.h>
 
 QmitkMultiLabelSegmentationPreferencePage::QmitkMultiLabelSegmentationPreferencePage()
-: m_MainControl(0)
+: m_MainControl(nullptr)
 , m_Initializing(false)
 {
 
 }
 
 QmitkMultiLabelSegmentationPreferencePage::~QmitkMultiLabelSegmentationPreferencePage()
 {
 
 }
 
 void QmitkMultiLabelSegmentationPreferencePage::Init(berry::IWorkbench::Pointer )
 {
 
 }
 
 void QmitkMultiLabelSegmentationPreferencePage::CreateQtControl(QWidget* parent)
 {
   m_Initializing = true;
   berry::IPreferencesService* prefService
     = berry::Platform::GetPreferencesService();
 
   m_SegmentationPreferencesNode = prefService->GetSystemPreferences()->Node("/org.mitk.views.multilabelsegmentation");
 
   m_MainControl = new QWidget(parent);
 
   QVBoxLayout* displayOptionsLayout = new QVBoxLayout;
   m_RadioOutline = new QRadioButton( "Draw as outline", m_MainControl);
   displayOptionsLayout->addWidget( m_RadioOutline );
   m_RadioOverlay = new QRadioButton( "Draw as transparent overlay", m_MainControl);
   displayOptionsLayout->addWidget( m_RadioOverlay );
 
   QFormLayout *formLayout = new QFormLayout;
   formLayout->setHorizontalSpacing(8);
   formLayout->setVerticalSpacing(24);
   formLayout->addRow( "2D display", displayOptionsLayout );
 
   m_VolumeRenderingCheckBox = new QCheckBox( "Show as volume rendering", m_MainControl );
   formLayout->addRow( "3D display", m_VolumeRenderingCheckBox );
   connect( m_VolumeRenderingCheckBox, SIGNAL(stateChanged(int)), this, SLOT(OnVolumeRenderingCheckboxChecked(int)) );
 
   QFormLayout* surfaceLayout = new QFormLayout;
   surfaceLayout->setSpacing(8);
 
   m_SmoothingSpinBox = new QDoubleSpinBox(m_MainControl);
   m_SmoothingSpinBox->setMinimum(0.0);
   m_SmoothingSpinBox->setSingleStep(0.5);
   m_SmoothingSpinBox->setValue(0.1);
   m_SmoothingSpinBox->setToolTip("The Smoothing value is used as Sigma for a gaussian blur.");
   surfaceLayout->addRow("Smoothing value (mm)", m_SmoothingSpinBox);
 
   m_DecimationSpinBox = new QDoubleSpinBox(m_MainControl);
   m_DecimationSpinBox->setMinimum(0.0);
   m_DecimationSpinBox->setMaximum(0.99);
   m_DecimationSpinBox->setSingleStep(0.1);
   m_DecimationSpinBox->setValue(0.5);
   m_DecimationSpinBox->setToolTip("Valid range is [0, 1). High values increase decimation, especially when very close to 1. A value of 0 disables decimation.");
   surfaceLayout->addRow("Decimation rate", m_DecimationSpinBox);
 
   m_SelectionModeCheckBox = new QCheckBox("Enable auto-selection mode", m_MainControl);
   m_SelectionModeCheckBox->setToolTip("If checked the segmentation plugin ensures that only one segmentation and the according greyvalue image are visible at one time.");
   formLayout->addRow("Data node selection mode",m_SelectionModeCheckBox);
 
   formLayout->addRow("Smoothed surface creation", surfaceLayout);
 
   m_MainControl->setLayout(formLayout);
   this->Update();
   m_Initializing = false;
 }
 
 QWidget* QmitkMultiLabelSegmentationPreferencePage::GetQtControl() const
 {
   return m_MainControl;
 }
 
 bool QmitkMultiLabelSegmentationPreferencePage::PerformOk()
 {
   m_SegmentationPreferencesNode->PutBool("draw outline", m_RadioOutline->isChecked());
   m_SegmentationPreferencesNode->PutBool("volume rendering", m_VolumeRenderingCheckBox->isChecked());
   m_SegmentationPreferencesNode->PutDouble("smoothing value", m_SmoothingSpinBox->value());
   m_SegmentationPreferencesNode->PutDouble("decimation rate", m_DecimationSpinBox->value());
   m_SegmentationPreferencesNode->PutBool("auto selection", m_SelectionModeCheckBox->isChecked());
   return true;
 }
 
 void QmitkMultiLabelSegmentationPreferencePage::PerformCancel()
 {
 
 }
 
 void QmitkMultiLabelSegmentationPreferencePage::Update()
 {
   //m_EnableSingleEditing->setChecked(m_SegmentationPreferencesNode->GetBool("Single click property editing", true));
   if (m_SegmentationPreferencesNode->GetBool("draw outline", true) )
   {
     m_RadioOutline->setChecked( true );
   }
   else
   {
     m_RadioOverlay->setChecked( true );
   }
 
   m_VolumeRenderingCheckBox->setChecked( m_SegmentationPreferencesNode->GetBool("volume rendering", false) );
 
   if (m_SegmentationPreferencesNode->GetBool("smoothing hint", true))
   {
     m_SmoothingSpinBox->setDisabled(true);
   }
   else
   {
     m_SmoothingSpinBox->setEnabled(true);
   }
 
   m_SelectionModeCheckBox->setChecked( m_SegmentationPreferencesNode->GetBool("auto selection", false) );
 
   m_SmoothingSpinBox->setValue(m_SegmentationPreferencesNode->GetDouble("smoothing value", 0.1));
   m_DecimationSpinBox->setValue(m_SegmentationPreferencesNode->GetDouble("decimation rate", 0.5));
 }
 
 void QmitkMultiLabelSegmentationPreferencePage::OnVolumeRenderingCheckboxChecked(int state)
 {
   if (m_Initializing) return;
 
   if ( state != Qt::Unchecked )
   {
     QMessageBox::information(nullptr,
                              "Memory warning",
                              "Turning on volume rendering of segmentations will make the application more memory intensive (and potentially prone to crashes).\n\n"
                              "If you encounter out-of-memory problems, try turning off volume rendering again.");
   }
 }
 
 void QmitkMultiLabelSegmentationPreferencePage::OnSmoothingCheckboxChecked(int state)
 {
   if (state != Qt::Unchecked)
     m_SmoothingSpinBox->setDisabled(true);
   else
     m_SmoothingSpinBox->setEnabled(true);
 }
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp
index a12eaab7ad..bfa943e81f 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp
@@ -1,1184 +1,1184 @@
 /*===================================================================
 
 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 "QmitkMultiLabelSegmentationView.h"
 
 // blueberry
 #include <berryConstants.h>
 #include <berryIWorkbenchPage.h>
 
 // mitk
 #include "mitkApplicationCursor.h"
 #include "mitkLabelSetImage.h"
 #include "mitkStatusBar.h"
 #include "mitkToolManagerProvider.h"
 //#include "mitkSegmentationObjectFactory.h"
 #include "mitkInteractionEventObserver.h"
 #include "mitkPlanePositionManager.h"
 #include "mitkPluginActivator.h"
 #include "mitkSegTool2D.h"
 
 // Qmitk
 #include "QmitkNewSegmentationDialog.h"
 #include "QmitkRenderWindow.h"
 #include "QmitkSegmentationOrganNamesHandling.cpp"
 
 // us
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 
 // Qt
 #include <QDateTime>
 #include <QFileDialog>
 #include <QInputDialog>
 #include <QMessageBox>
 #include <QShortcut>
 
 #include "tinyxml.h"
 
 #include <itksys/SystemTools.hxx>
 
 #include <regex>
 
 const std::string QmitkMultiLabelSegmentationView::VIEW_ID = "org.mitk.views.multilabelsegmentation";
 
 QmitkMultiLabelSegmentationView::QmitkMultiLabelSegmentationView()
   : m_Parent(nullptr),
     m_IRenderWindowPart(nullptr),
     m_ToolManager(nullptr),
     m_ReferenceNode(nullptr),
     m_WorkingNode(nullptr),
     m_AutoSelectionEnabled(false),
     m_MouseCursorSet(false)
 {
   m_SegmentationPredicate = mitk::NodePredicateAnd::New();
   m_SegmentationPredicate->AddPredicate(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
   m_SegmentationPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
 
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::NodePredicateProperty::Pointer isBinary =
     mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   mitk::NodePredicateAnd::Pointer isMask = mitk::NodePredicateAnd::New(isBinary, isImage);
 
   mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
   mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
   mitk::NodePredicateDataType::Pointer isOdf = mitk::NodePredicateDataType::New("OdfImage");
   auto isSegment = mitk::NodePredicateDataType::New("Segment");
 
   mitk::NodePredicateOr::Pointer validImages = mitk::NodePredicateOr::New();
   validImages->AddPredicate(mitk::NodePredicateAnd::New(isImage, mitk::NodePredicateNot::New(isSegment)));
   validImages->AddPredicate(isDwi);
   validImages->AddPredicate(isDti);
   validImages->AddPredicate(isOdf);
 
   m_ReferencePredicate = mitk::NodePredicateAnd::New();
   m_ReferencePredicate->AddPredicate(validImages);
   m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(m_SegmentationPredicate));
   m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(isMask));
   m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
 }
 
 QmitkMultiLabelSegmentationView::~QmitkMultiLabelSegmentationView()
 {
   // m_ToolManager->ActivateTool(-1);
   /*
   todo: check this
   m_Controls.m_SliceBasedInterpolatorWidget->EnableInterpolation(false);
   ctkPluginContext* context = mitk::PluginActivator::getContext();
   ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
   mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
   service->RemoveAllPlanePositions();
   context->ungetService(ppmRef);
   */
   // m_ToolManager->SetReferenceData(nullptr);
   // m_ToolManager->SetWorkingData(nullptr);
 
   // m_ServiceRegistration.Unregister();
 
   // Loose LabelSetConnections
   OnLooseLabelSetConnection();
 }
 
 void QmitkMultiLabelSegmentationView::CreateQtPartControl(QWidget *parent)
 {
   // setup the basic GUI of this view
   m_Parent = parent;
 
   m_Controls.setupUi(parent);
 
   // *------------------------
   // * Shortcuts
   // *------------------------
   QShortcut* visibilityShortcut = new QShortcut(QKeySequence("CTRL+H"), parent);
   connect(visibilityShortcut, &QShortcut::activated, this, &QmitkMultiLabelSegmentationView::OnVisibilityShortcutActivated);
   QShortcut* labelToggleShortcut = new QShortcut(QKeySequence("CTRL+L"), parent);
   connect(labelToggleShortcut, &QShortcut::activated, this, &QmitkMultiLabelSegmentationView::OnLabelToggleShortcutActivated);
 
   // *------------------------
   // * DATA SELECTION WIDGETS
   // *------------------------
 
   m_Controls.m_cbReferenceNodeSelector->SetAutoSelectNewItems(true);
   m_Controls.m_cbReferenceNodeSelector->SetPredicate(m_ReferencePredicate);
   m_Controls.m_cbReferenceNodeSelector->SetDataStorage(this->GetDataStorage());
 
   m_Controls.m_cbWorkingNodeSelector->SetAutoSelectNewItems(true);
   m_Controls.m_cbWorkingNodeSelector->SetPredicate(m_SegmentationPredicate);
   m_Controls.m_cbWorkingNodeSelector->SetDataStorage(this->GetDataStorage());
 
   connect(m_Controls.m_cbReferenceNodeSelector,
           SIGNAL(OnSelectionChanged(const mitk::DataNode *)),
           this,
           SLOT(OnReferenceSelectionChanged(const mitk::DataNode *)));
 
   connect(m_Controls.m_cbWorkingNodeSelector,
           SIGNAL(OnSelectionChanged(const mitk::DataNode *)),
           this,
           SLOT(OnSegmentationSelectionChanged(const mitk::DataNode *)));
 
   // *------------------------
   // * ToolManager
   // *------------------------
 
   m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
   assert(m_ToolManager);
   m_ToolManager->SetDataStorage(*(this->GetDataStorage()));
   m_ToolManager->InitializeTools();
   // use the same ToolManager instance for our 3D Tools
   m_Controls.m_ManualToolSelectionBox3D->SetToolManager(*m_ToolManager);
 
   // *------------------------
   // * LabelSetWidget
   // *------------------------
 
   m_Controls.m_LabelSetWidget->SetDataStorage(this->GetDataStorage());
   m_Controls.m_LabelSetWidget->SetOrganColors(mitk::OrganNamesHandling::GetDefaultOrganColorString());
   m_Controls.m_LabelSetWidget->hide();
 
   // *------------------------
   // * Interpolation
   // *------------------------
 
   m_Controls.m_SurfaceBasedInterpolatorWidget->SetDataStorage(*(this->GetDataStorage()));
   m_Controls.m_SliceBasedInterpolatorWidget->SetDataStorage(*(this->GetDataStorage()));
   connect(m_Controls.m_cbInterpolation, SIGNAL(activated(int)), this, SLOT(OnInterpolationSelectionChanged(int)));
 
   m_Controls.m_cbInterpolation->setCurrentIndex(0);
   m_Controls.m_swInterpolation->hide();
 
   QString segTools2D = tr("Add Subtract Fill Erase Paint Wipe 'Region Growing' FastMarching2D Correction 'Live Wire'");
   QString segTools3D = tr("Threshold 'Two Thresholds' 'Auto Threshold' 'Multiple Otsu'");
 
   std::regex extSegTool2DRegEx("SegTool2D$");
   std::regex extSegTool3DRegEx("SegTool3D$");
 
   auto tools = m_ToolManager->GetTools();
 
   for (const auto &tool : tools)
   {
     if (std::regex_search(tool->GetNameOfClass(), extSegTool2DRegEx))
     {
       segTools2D.append(QString(" '%1'").arg(tool->GetName()));
     }
     else if (std::regex_search(tool->GetNameOfClass(), extSegTool3DRegEx))
     {
       segTools3D.append(QString(" '%1'").arg(tool->GetName()));
     }
   }
 
   // *------------------------
   // * ToolSelection 2D
   // *------------------------
 
   m_Controls.m_ManualToolSelectionBox2D->SetGenerateAccelerators(true);
   m_Controls.m_ManualToolSelectionBox2D->SetToolGUIArea(m_Controls.m_ManualToolGUIContainer2D);
   m_Controls.m_ManualToolSelectionBox2D->SetDisplayedToolGroups(segTools2D.toStdString()); // todo: "Correction
   // 'Live Wire'"
   m_Controls.m_ManualToolSelectionBox2D->SetEnabledMode(
     QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
   connect(m_Controls.m_ManualToolSelectionBox2D, SIGNAL(ToolSelected(int)), this, SLOT(OnManualTool2DSelected(int)));
 
   // *------------------------
   // * ToolSelection 3D
   // *------------------------
 
   m_Controls.m_ManualToolSelectionBox3D->SetGenerateAccelerators(true);
   m_Controls.m_ManualToolSelectionBox3D->SetToolGUIArea(m_Controls.m_ManualToolGUIContainer3D);
   m_Controls.m_ManualToolSelectionBox3D->SetDisplayedToolGroups(segTools3D.toStdString()); // todo add : FastMarching3D RegionGrowing Watershed
   m_Controls.m_ManualToolSelectionBox3D->SetLayoutColumns(2);
   m_Controls.m_ManualToolSelectionBox3D->SetEnabledMode(
     QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
 
   // *------------------------*
   // * Connect PushButtons (pb)
   // *------------------------*
 
   connect(m_Controls.m_pbNewLabel, SIGNAL(clicked()), this, SLOT(OnNewLabel()));
   connect(m_Controls.m_pbNewSegmentationSession, SIGNAL(clicked()), this, SLOT(OnNewSegmentationSession()));
   connect(m_Controls.m_pbShowLabelTable, SIGNAL(toggled(bool)), this, SLOT(OnShowLabelTable(bool)));
 
   // *------------------------*
   // * Connect LabelSetWidget
   // *------------------------*
 
   connect(m_Controls.m_LabelSetWidget,
           SIGNAL(goToLabel(const mitk::Point3D &)),
           this,
           SLOT(OnGoToLabel(const mitk::Point3D &)));
   connect(m_Controls.m_LabelSetWidget, SIGNAL(resetView()), this, SLOT(OnResetView()));
 
   // *------------------------*
   // * DATA SLECTION WIDGET
   // *------------------------*
   m_IRenderWindowPart = this->GetRenderWindowPart();
   if (m_IRenderWindowPart)
   {
     QList<mitk::SliceNavigationController *> controllers;
     controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
     controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
     controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
     m_Controls.m_SliceBasedInterpolatorWidget->SetSliceNavigationControllers(controllers);
     //    m_Controls.m_LabelSetWidget->SetRenderWindowPart(this->m_IRenderWindowPart);
   }
 
   //  this->InitializeListeners();
 
   connect(m_Controls.m_btAddLayer, SIGNAL(clicked()), this, SLOT(OnAddLayer()));
   connect(m_Controls.m_btDeleteLayer, SIGNAL(clicked()), this, SLOT(OnDeleteLayer()));
   connect(m_Controls.m_btPreviousLayer, SIGNAL(clicked()), this, SLOT(OnPreviousLayer()));
   connect(m_Controls.m_btNextLayer, SIGNAL(clicked()), this, SLOT(OnNextLayer()));
   connect(m_Controls.m_btLockExterior, SIGNAL(toggled(bool)), this, SLOT(OnLockExteriorToggled(bool)));
   connect(m_Controls.m_cbActiveLayer, SIGNAL(currentIndexChanged(int)), this, SLOT(OnChangeLayer(int)));
 
   m_Controls.m_btAddLayer->setEnabled(false);
   m_Controls.m_btDeleteLayer->setEnabled(false);
   m_Controls.m_btNextLayer->setEnabled(false);
   m_Controls.m_btPreviousLayer->setEnabled(false);
   m_Controls.m_cbActiveLayer->setEnabled(false);
 
   m_Controls.m_pbNewLabel->setEnabled(false);
   m_Controls.m_btLockExterior->setEnabled(false);
   m_Controls.m_pbShowLabelTable->setEnabled(false);
 
   // Make sure the GUI notices if appropriate data is already present on creation
   this->OnReferenceSelectionChanged(m_Controls.m_cbReferenceNodeSelector->GetSelectedNode());
   this->OnSegmentationSelectionChanged(m_Controls.m_cbWorkingNodeSelector->GetSelectedNode());
 }
 
 void QmitkMultiLabelSegmentationView::Activated()
 {
   m_ToolManager->SetReferenceData(m_Controls.m_cbReferenceNodeSelector->GetSelectedNode());
   m_ToolManager->SetWorkingData(m_Controls.m_cbWorkingNodeSelector->GetSelectedNode());
 }
 
 void QmitkMultiLabelSegmentationView::Deactivated()
 {
   // Not yet implemented
 }
 
 void QmitkMultiLabelSegmentationView::Visible()
 {
   // Not yet implemented
 }
 
 void QmitkMultiLabelSegmentationView::Hidden()
 {
   // Not yet implemented
 }
 
 int QmitkMultiLabelSegmentationView::GetSizeFlags(bool width)
 {
   if (!width)
   {
     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
   }
   else
   {
     return 0;
   }
 }
 
 int QmitkMultiLabelSegmentationView::ComputePreferredSize(bool width,
                                                           int /*availableParallel*/,
                                                           int /*availablePerpendicular*/,
                                                           int preferredResult)
 {
   if (width == false)
   {
     return 100;
   }
   else
   {
     return preferredResult;
   }
 }
 
 /************************************************************************/
 /* protected slots                                                      */
 /************************************************************************/
 void QmitkMultiLabelSegmentationView::OnVisibilityShortcutActivated()
 {
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
 
   bool isVisible = false;
   workingNode->GetBoolProperty("visible", isVisible);
   workingNode->SetVisibility(!isVisible);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkMultiLabelSegmentationView::OnLabelToggleShortcutActivated()
 {
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
 
   mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
   assert(workingImage);
 
   WaitCursorOn();
   workingImage->GetActiveLabelSet()->SetNextActiveLabel();
   workingImage->Modified();
   WaitCursorOff();
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkMultiLabelSegmentationView::OnManualTool2DSelected(int id)
 {
   this->ResetMouseCursor();
   mitk::StatusBar::GetInstance()->DisplayText("");
 
   if (id >= 0)
   {
     std::string text = "Active Tool: \"";
     text += m_ToolManager->GetToolById(id)->GetName();
     text += "\"";
     mitk::StatusBar::GetInstance()->DisplayText(text.c_str());
 
     us::ModuleResource resource = m_ToolManager->GetToolById(id)->GetCursorIconResource();
     this->SetMouseCursor(resource, 0, 0);
   }
 }
 
 void QmitkMultiLabelSegmentationView::OnNewLabel()
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   if (!workingNode)
   {
     QMessageBox::information(
       m_Parent, "New Segmentation Session", "Please load and select a patient image before starting some action.");
     return;
   }
 
   mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
   if (!workingImage)
   {
     QMessageBox::information(
       m_Parent, "New Segmentation Session", "Please load and select a patient image before starting some action.");
     return;
   }
 
   QmitkNewSegmentationDialog* dialog = new QmitkNewSegmentationDialog(m_Parent);
   dialog->SetSuggestionList(mitk::OrganNamesHandling::GetDefaultOrganColorString());
   dialog->setWindowTitle("New Label");
 
   int dialogReturnValue = dialog->exec();
   if (dialogReturnValue == QDialog::Rejected)
   {
     return;
   }
 
   QString segName = dialog->GetSegmentationName();
   if (segName.isEmpty())
   {
     segName = "Unnamed";
   }
   workingImage->GetActiveLabelSet()->AddLabel(segName.toStdString(), dialog->GetColor());
 
   UpdateControls();
   m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
 
   mitk::RenderingManager::GetInstance()->InitializeViews(workingNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
 }
 
 void QmitkMultiLabelSegmentationView::OnShowLabelTable(bool value)
 {
   if (value)
     m_Controls.m_LabelSetWidget->show();
   else
     m_Controls.m_LabelSetWidget->hide();
 }
 
 void QmitkMultiLabelSegmentationView::OnNewSegmentationSession()
 {
   mitk::DataNode *referenceNode = m_Controls.m_cbReferenceNodeSelector->GetSelectedNode();
 
   if (!referenceNode)
   {
     QMessageBox::information(
       m_Parent, "New Segmentation Session", "Please load and select a patient image before starting some action.");
     return;
   }
 
   m_ToolManager->ActivateTool(-1);
 
   mitk::Image* referenceImage = dynamic_cast<mitk::Image*>(referenceNode->GetData());
   assert(referenceImage);
 
   QString newName = QString::fromStdString(referenceNode->GetName());
   newName.append("-labels");
 
   bool ok = false;
   newName = QInputDialog::getText(m_Parent, "New Segmentation Session", "New name:", QLineEdit::Normal, newName, &ok);
 
   if (!ok)
   {
     return;
   }
   this->WaitCursorOn();
 
   mitk::LabelSetImage::Pointer workingImage = mitk::LabelSetImage::New();
   try
   {
     workingImage->Initialize(referenceImage);
   }
   catch (mitk::Exception& e)
   {
     this->WaitCursorOff();
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(m_Parent, "New Segmentation Session", "Could not create a new segmentation session.\n");
     return;
   }
 
   this->WaitCursorOff();
 
   mitk::DataNode::Pointer workingNode = mitk::DataNode::New();
   workingNode->SetData(workingImage);
   workingNode->SetName(newName.toStdString());
 
   workingImage->GetExteriorLabel()->SetProperty("name.parent", mitk::StringProperty::New(referenceNode->GetName().c_str()));
   workingImage->GetExteriorLabel()->SetProperty("name.image", mitk::StringProperty::New(newName.toStdString().c_str()));
 
   if (!GetDataStorage()->Exists(workingNode))
   {
     GetDataStorage()->Add(workingNode, referenceNode);
   }
 
   OnNewLabel();
 }
 
 void QmitkMultiLabelSegmentationView::OnGoToLabel(const mitk::Point3D& pos)
 {
   if (m_IRenderWindowPart)
     m_IRenderWindowPart->SetSelectedPosition(pos);
 }
 
 void QmitkMultiLabelSegmentationView::OnResetView()
 {
   if (m_IRenderWindowPart)
     m_IRenderWindowPart->ForceImmediateUpdate();
 }
 
 void QmitkMultiLabelSegmentationView::OnAddLayer()
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
 
   mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
   assert(workingImage);
 
   QString question = "Do you really want to add a layer to the current segmentation session?";
   QMessageBox::StandardButton answerButton = QMessageBox::question(
     m_Controls.m_LabelSetWidget, "Add layer", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton != QMessageBox::Yes) return;
 
   try
   {
     WaitCursorOn();
     workingImage->AddLayer();
     WaitCursorOff();
   }
   catch ( mitk::Exception& e )
   {
     WaitCursorOff();
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(
       m_Controls.m_LabelSetWidget, "Add Layer", "Could not add a new layer. See error log for details.\n");
     return;
   }
 
   OnNewLabel();
 }
 
 void QmitkMultiLabelSegmentationView::OnDeleteLayer()
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
 
   mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
   assert(workingImage);
 
   if (workingImage->GetNumberOfLayers() < 2)
     return;
 
   QString question = "Do you really want to delete the current layer?";
 
   QMessageBox::StandardButton answerButton = QMessageBox::question(
     m_Controls.m_LabelSetWidget, "Delete layer", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton != QMessageBox::Yes)
   {
     return;
   }
 
   try
   {
     this->WaitCursorOn();
     workingImage->RemoveLayer();
     this->WaitCursorOff();
   }
   catch (mitk::Exception& e)
   {
     this->WaitCursorOff();
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(m_Controls.m_LabelSetWidget, "Delete Layer",
                              "Could not delete the currently active layer. See error log for details.\n");
     return;
   }
 
   UpdateControls();
   m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
 }
 
 void QmitkMultiLabelSegmentationView::OnPreviousLayer()
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
   assert(workingImage);
 
   OnChangeLayer(workingImage->GetActiveLayer() - 1);
 }
 
 void QmitkMultiLabelSegmentationView::OnNextLayer()
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
   assert(workingImage);
 
   OnChangeLayer(workingImage->GetActiveLayer() + 1);
 }
 
 void QmitkMultiLabelSegmentationView::OnChangeLayer(int layer)
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
 
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
   assert(workingImage);
 
   this->WaitCursorOn();
   workingImage->SetActiveLayer(layer);
   this->WaitCursorOff();
 
   UpdateControls();
   m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
 }
 
 void QmitkMultiLabelSegmentationView::OnDeactivateActiveTool()
 {
   m_ToolManager->ActivateTool(-1);
 }
 
 void QmitkMultiLabelSegmentationView::OnLockExteriorToggled(bool checked)
 {
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
 
   mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
   assert(workingImage);
 
   workingImage->GetLabel(0)->SetLocked(checked);
 }
 
 void QmitkMultiLabelSegmentationView::OnReferenceSelectionChanged(const mitk::DataNode* node)
 {
   m_ToolManager->ActivateTool(-1);
 
   m_ReferenceNode = const_cast<mitk::DataNode*>(node);
   m_ToolManager->SetReferenceData(m_ReferenceNode);
 
   if (m_ReferenceNode.IsNotNull())
   {
     if (m_AutoSelectionEnabled)
     {
       // if an image is selected find a possible working / segmentation image
       mitk::DataStorage::SetOfObjects::ConstPointer derivations = this->GetDataStorage()->GetDerivations(m_ReferenceNode, m_SegmentationPredicate);
       if (derivations->Size() != 0)
       {
         // use the first segmentation child node
         m_WorkingNode = derivations->ElementAt(0);
         m_ToolManager->SetWorkingData(m_WorkingNode);
 
         m_Controls.m_cbWorkingNodeSelector->blockSignals(true);
         m_Controls.m_cbWorkingNodeSelector->SetSelectedNode(m_WorkingNode);
         m_Controls.m_cbWorkingNodeSelector->blockSignals(false);
       }
       else if (derivations->size() == 0)
       {
         m_Controls.m_cbWorkingNodeSelector->setCurrentIndex(-1);
       }
 
       // hide all image and segmentation nodes to later show only the automatically selected ones
       mitk::DataStorage::SetOfObjects::ConstPointer patientNodes = GetDataStorage()->GetSubset(m_ReferencePredicate);
       for (mitk::DataStorage::SetOfObjects::const_iterator iter = patientNodes->begin(); iter != patientNodes->end(); ++iter)
       {
         (*iter)->SetVisibility(false);
       }
 
       mitk::DataStorage::SetOfObjects::ConstPointer segmentationNodes = GetDataStorage()->GetSubset(m_SegmentationPredicate);
       for (mitk::DataStorage::SetOfObjects::const_iterator iter = segmentationNodes->begin(); iter != segmentationNodes->end(); ++iter)
       {
         (*iter)->SetVisibility(false);
       }
     }
     m_ReferenceNode->SetVisibility(true);
 
     // check match of segmentation and reference image geometries
     if (m_WorkingNode.IsNotNull())
     {
       mitk::Image* workingImage = dynamic_cast<mitk::Image*>(m_WorkingNode->GetData());
       assert(workingImage);
 
       mitk::Image* referenceImage = dynamic_cast<mitk::Image*>(node->GetData());
       assert(referenceImage);
 
       if (!this->CheckForSameGeometry(referenceImage, workingImage))
       {
         return;
       }
       m_WorkingNode->SetVisibility(true);
     }
   }
 
   UpdateControls();
   if (m_WorkingNode.IsNotNull())
   {
     m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
     mitk::RenderingManager::GetInstance()->InitializeViews(m_WorkingNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
   }
 }
 
 void QmitkMultiLabelSegmentationView::OnSegmentationSelectionChanged(const mitk::DataNode* node)
 {
   m_ToolManager->ActivateTool(-1);
 
   if (m_WorkingNode.IsNotNull())
     OnLooseLabelSetConnection();
 
   m_WorkingNode = const_cast<mitk::DataNode*>(node);
   m_ToolManager->SetWorkingData(m_WorkingNode);
   if (m_WorkingNode.IsNotNull())
   {
     OnEstablishLabelSetConnection();
 
     if (m_AutoSelectionEnabled)
     {
       // if a segmentation is selected find a possible reference image
       mitk::DataStorage::SetOfObjects::ConstPointer sources = this->GetDataStorage()->GetSources(m_WorkingNode, m_ReferencePredicate);
       if (sources->Size() != 0)
       {
         m_ReferenceNode = sources->ElementAt(0);
         m_ToolManager->SetReferenceData(m_ReferenceNode);
 
         m_Controls.m_cbReferenceNodeSelector->blockSignals(true);
         m_Controls.m_cbReferenceNodeSelector->SetSelectedNode(m_ReferenceNode);
         m_Controls.m_cbReferenceNodeSelector->blockSignals(false);
       }
       else if(sources->size() == 0)
       {
         m_Controls.m_cbReferenceNodeSelector->setCurrentIndex(-1);
       }
 
       // hide all image and segmentation nodes to later show only the automatically selected ones
       mitk::DataStorage::SetOfObjects::ConstPointer patientNodes = GetDataStorage()->GetSubset(m_ReferencePredicate);
       for (mitk::DataStorage::SetOfObjects::const_iterator iter = patientNodes->begin(); iter != patientNodes->end(); ++iter)
       {
         (*iter)->SetVisibility(false);
       }
 
       mitk::DataStorage::SetOfObjects::ConstPointer segmentationNodes = GetDataStorage()->GetSubset(m_SegmentationPredicate);
       for (mitk::DataStorage::SetOfObjects::const_iterator iter = segmentationNodes->begin(); iter != segmentationNodes->end(); ++iter)
       {
         (*iter)->SetVisibility(false);
       }
     }
     m_WorkingNode->SetVisibility(true);
 
     // check match of segmentation and reference image geometries
     if (m_ReferenceNode.IsNotNull())
     {
       mitk::Image* referenceImage = dynamic_cast<mitk::Image*>(m_ReferenceNode->GetData());
       assert(referenceImage);
 
       mitk::Image* workingImage = dynamic_cast<mitk::Image*>(m_WorkingNode->GetData());
       assert(workingImage);
 
       if (!this->CheckForSameGeometry(referenceImage, workingImage))
       {
         return;
       }
       m_ReferenceNode->SetVisibility(true);
     }
   }
 
   UpdateControls();
   if (m_WorkingNode.IsNotNull())
   {
     m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
     mitk::RenderingManager::GetInstance()->InitializeViews(m_WorkingNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
   }
 }
 
 void QmitkMultiLabelSegmentationView::OnInterpolationSelectionChanged(int index)
 {
   if (index == 1)
   {
     m_Controls.m_SurfaceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);//OnToggleWidgetActivation(false);
     m_Controls.m_swInterpolation->setCurrentIndex(0);
     m_Controls.m_swInterpolation->show();
   }
   else if (index == 2)
   {
     m_Controls.m_SliceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);
     m_Controls.m_swInterpolation->setCurrentIndex(1);
     m_Controls.m_swInterpolation->show();
   }
   else
   {
     m_Controls.m_SurfaceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);
     m_Controls.m_SliceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);
     m_Controls.m_swInterpolation->setCurrentIndex(2);
     m_Controls.m_swInterpolation->hide();
   }
 }
 
 /************************************************************************/
 /* protected                                                            */
 /************************************************************************/
 void QmitkMultiLabelSegmentationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer> &nodes)
 {
   if (m_AutoSelectionEnabled)
   {
     // automatically set the reference node and the working node of the multi label plugin
     if (1 == nodes.size())
     {
       mitk::DataNode::Pointer selectedNode = nodes.at(0);
       if (selectedNode.IsNull())
       {
         return;
       }
 
       // check selected node
       mitk::LabelSetImage::Pointer labelSetImage = dynamic_cast<mitk::LabelSetImage*>(selectedNode->GetData());
       if (labelSetImage.IsNotNull())
       {
         // reset the image / reference node selector in case the current selected segmentation has no image parent
         m_Controls.m_cbReferenceNodeSelector->setCurrentIndex(-1);
         // selected a label set image (a segmentation ( working node)
         m_Controls.m_cbWorkingNodeSelector->SetSelectedNode(selectedNode);
         return;
       }
 
       mitk::Image::Pointer selectedImage = dynamic_cast<mitk::Image*>(selectedNode->GetData());
       if (selectedImage.IsNotNull())
       {
         // reset the segmentation / working node selector in case the current selected image has no segmentation child
         m_Controls.m_cbWorkingNodeSelector->setCurrentIndex(-1);
         // selected an image (a reference node)
         m_Controls.m_cbReferenceNodeSelector->SetSelectedNode(selectedNode);
         return;
       }
     }
   }
 }
 
 void QmitkMultiLabelSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
   if (m_Parent && m_WorkingNode.IsNotNull())
   {
     m_AutoSelectionEnabled = prefs->GetBool("auto selection", false);
 
     mitk::BoolProperty::Pointer drawOutline = mitk::BoolProperty::New(prefs->GetBool("draw outline", true));
     mitk::BoolProperty::Pointer volumeRendering = mitk::BoolProperty::New(prefs->GetBool("volume rendering", false));
     mitk::LabelSetImage* labelSetImage;
     mitk::DataNode* segmentation;
 
     // iterate all segmentations (binary (single label) and LabelSetImages)
     mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
     mitk::NodePredicateOr::Pointer allSegmentationsPredicate = mitk::NodePredicateOr::New(isBinaryPredicate, m_SegmentationPredicate);
     mitk::DataStorage::SetOfObjects::ConstPointer allSegmentations = GetDataStorage()->GetSubset(allSegmentationsPredicate);
 
     for (mitk::DataStorage::SetOfObjects::const_iterator it = allSegmentations->begin(); it != allSegmentations->end(); ++it)
     {
       segmentation = *it;
       labelSetImage = dynamic_cast<mitk::LabelSetImage*>(segmentation->GetData());
       if (nullptr != labelSetImage)
       {
         // segmentation node is a multi label segmentation
         segmentation->SetProperty("labelset.contour.active", drawOutline);
         //segmentation->SetProperty("opacity", mitk::FloatProperty::New(drawOutline->GetValue() ? 1.0f : 0.3f));
         segmentation->SetProperty("volumerendering", volumeRendering);
         // force render window update to show outline
         segmentation->GetData()->Modified();
       }
       else if (nullptr != segmentation->GetData())
       {
         // node is actually a 'single label' segmentation,
         // but its outline property can be set in the 'multi label' segmentation preference page as well
         bool isBinary = false;
         segmentation->GetBoolProperty("binary", isBinary);
         if (isBinary)
         {
           segmentation->SetProperty("outline binary", drawOutline);
           segmentation->SetProperty("outline width", mitk::FloatProperty::New(2.0));
           //segmentation->SetProperty("opacity", mitk::FloatProperty::New(drawOutline->GetValue() ? 1.0f : 0.3f));
           segmentation->SetProperty("volumerendering", volumeRendering);
           // force render window update to show outline
           segmentation->GetData()->Modified();
         }
       }
       else
       {
         // "interpolation feedback" data nodes have binary flag but don't have a data set. So skip them for now.
         MITK_INFO << "DataNode " << segmentation->GetName() << " doesn't contain a base data.";
       }
     }
   }
 }
 
 void QmitkMultiLabelSegmentationView::NodeAdded(const mitk::DataNode *)
 {
   /*
   bool isHelperObject(false);
   node->GetBoolProperty("helper object", isHelperObject);
   if (isHelperObject) return;
 
   if (m_ReferenceNode.IsNotNull() && dynamic_cast<mitk::LabelSetImage*>(node->GetData()))
   {
   mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
 
   if (workingImage->GetNumberOfLabels() > 2)
   m_Controls.m_LabelSetWidget->show();
   else
   m_Controls.m_LabelSetWidget->hide();
   }
   */
 }
 
 void QmitkMultiLabelSegmentationView::NodeRemoved(const mitk::DataNode *node)
 {
   bool isHelperObject(false);
   node->GetBoolProperty("helper object", isHelperObject);
   if (isHelperObject)
   {
     return;
   }
 
   if (m_ReferenceNode.IsNotNull() && dynamic_cast<mitk::LabelSetImage *>(node->GetData()))
   {
     // remove all possible contour markers of the segmentation
     mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = this->GetDataStorage()->GetDerivations(
       node, mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true)));
 
     ctkPluginContext *context = mitk::PluginActivator::getContext();
     ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
     mitk::PlanePositionManagerService *service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
 
     for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
     {
       std::string nodeName = node->GetName();
       unsigned int t = nodeName.find_last_of(" ");
       unsigned int id = atof(nodeName.substr(t + 1).c_str()) - 1;
 
       service->RemovePlanePosition(id);
 
       this->GetDataStorage()->Remove(it->Value());
     }
 
     context->ungetService(ppmRef);
     service = nullptr;
   }
 }
 
 void QmitkMultiLabelSegmentationView::OnEstablishLabelSetConnection()
 {
   if (m_WorkingNode.IsNull())
   {
     return;
   }
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(m_WorkingNode->GetData());
   assert(workingImage);
 
   workingImage->GetActiveLabelSet()->AddLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->RemoveLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ModifyLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->AllLabelsModifiedEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ActiveLabelEvent +=
     mitk::MessageDelegate1<QmitkLabelSetWidget, mitk::Label::PixelType>(m_Controls.m_LabelSetWidget,
                                                                         &QmitkLabelSetWidget::SelectLabelByPixelValue);
   workingImage->BeforeChangeLayerEvent += mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
     this, &QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection);
 }
 
 void QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection()
 {
   if (m_WorkingNode.IsNull())
   {
     return;
   }
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(m_WorkingNode->GetData());
   assert(workingImage);
 
   // Reset LabelSetWidget Events
   workingImage->GetActiveLabelSet()->AddLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->RemoveLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ModifyLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->AllLabelsModifiedEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ActiveLabelEvent -=
     mitk::MessageDelegate1<QmitkLabelSetWidget, mitk::Label::PixelType>(m_Controls.m_LabelSetWidget,
                                                                         &QmitkLabelSetWidget::SelectLabelByPixelValue);
   workingImage->BeforeChangeLayerEvent -= mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
     this, &QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection);
 }
 
 void QmitkMultiLabelSegmentationView::SetFocus()
 {
 }
 
 void QmitkMultiLabelSegmentationView::UpdateControls()
 {
   mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
   bool hasReferenceNode = referenceNode != nullptr;
 
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   bool hasValidWorkingNode = workingNode != nullptr;
 
   m_Controls.m_pbNewLabel->setEnabled(false);
   m_Controls.m_gbInterpolation->setEnabled(false);
   m_Controls.m_SliceBasedInterpolatorWidget->setEnabled(false);
   m_Controls.m_SurfaceBasedInterpolatorWidget->setEnabled(false);
   m_Controls.m_LabelSetWidget->setEnabled(false);
   m_Controls.m_btAddLayer->setEnabled(false);
   m_Controls.m_btDeleteLayer->setEnabled(false);
   m_Controls.m_cbActiveLayer->setEnabled(false);
   m_Controls.m_btPreviousLayer->setEnabled(false);
   m_Controls.m_btNextLayer->setEnabled(false);
   m_Controls.m_btLockExterior->setChecked(false);
   m_Controls.m_btLockExterior->setEnabled(false);
   m_Controls.m_pbShowLabelTable->setChecked(false);
   m_Controls.m_pbShowLabelTable->setEnabled(false);
 
   m_Controls.m_ManualToolSelectionBox3D->SetEnabledMode(QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
   m_Controls.m_ManualToolSelectionBox2D->SetEnabledMode(QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
 
   if (hasValidWorkingNode)
   {
     // TODO adapt tool manager so that this check is done there, e.g. convenience function
     mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
     hasValidWorkingNode = workingImage != nullptr;
     if (hasValidWorkingNode)
     {
       m_Controls.m_pbNewLabel->setEnabled(true);
       m_Controls.m_btLockExterior->setEnabled(true);
       m_Controls.m_pbShowLabelTable->setEnabled(true);
       m_Controls.m_gbInterpolation->setEnabled(true);
       m_Controls.m_SliceBasedInterpolatorWidget->setEnabled(true);
       m_Controls.m_SurfaceBasedInterpolatorWidget->setEnabled(true);
       m_Controls.m_LabelSetWidget->setEnabled(true);
       m_Controls.m_btAddLayer->setEnabled(true);
 
       int activeLayer = workingImage->GetActiveLayer();
       int numberOfLayers = workingImage->GetNumberOfLayers();
 
       m_Controls.m_cbActiveLayer->blockSignals(true);
       m_Controls.m_cbActiveLayer->clear();
       for (unsigned int lidx = 0; lidx < workingImage->GetNumberOfLayers(); ++lidx)
       {
         m_Controls.m_cbActiveLayer->addItem(QString::number(lidx));
       }
       m_Controls.m_cbActiveLayer->setCurrentIndex(activeLayer);
       m_Controls.m_cbActiveLayer->blockSignals(false);
 
       m_Controls.m_cbActiveLayer->setEnabled(numberOfLayers > 1);
       m_Controls.m_btDeleteLayer->setEnabled(numberOfLayers > 1);
       m_Controls.m_btPreviousLayer->setEnabled(activeLayer > 0);
       m_Controls.m_btNextLayer->setEnabled(activeLayer != numberOfLayers - 1);
 
       m_Controls.m_btLockExterior->setChecked(workingImage->GetLabel(0, activeLayer)->GetLocked());
       m_Controls.m_pbShowLabelTable->setChecked(workingImage->GetNumberOfLabels() > 1 /*1st is exterior*/);
 
       //MLI TODO
       //m_Controls.m_ManualToolSelectionBox2D->SetEnabledMode(QmitkToolSelectionBox::EnabledWithWorkingDataVisible);
     }
   }
 
   if (hasValidWorkingNode && hasReferenceNode)
   {
     int layer = -1;
     referenceNode->GetIntProperty("layer", layer);
     workingNode->SetIntProperty("layer", layer + 1);
   }
 
   this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_ALL);
 }
 
 void QmitkMultiLabelSegmentationView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_IRenderWindowPart != renderWindowPart)
   {
     m_IRenderWindowPart = renderWindowPart;
     m_Parent->setEnabled(true);
 
     QList<mitk::SliceNavigationController*> controllers;
     controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
     controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
     controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
     m_Controls.m_SliceBasedInterpolatorWidget->SetSliceNavigationControllers(controllers);
   }
 }
 
 void QmitkMultiLabelSegmentationView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_ToolManager->ActivateTool(-1);
-  m_IRenderWindowPart = 0;
+  m_IRenderWindowPart = nullptr;
   m_Parent->setEnabled(false);
 }
 
 void QmitkMultiLabelSegmentationView::ResetMouseCursor()
 {
   if (m_MouseCursorSet)
   {
     mitk::ApplicationCursor::GetInstance()->PopCursor();
     m_MouseCursorSet = false;
   }
 }
 
 void QmitkMultiLabelSegmentationView::SetMouseCursor(const us::ModuleResource resource, int hotspotX, int hotspotY)
 {
   // Remove previously set mouse cursor
   if (m_MouseCursorSet)
     this->ResetMouseCursor();
 
   if (resource)
   {
     us::ModuleResourceStream cursor(resource, std::ios::binary);
     mitk::ApplicationCursor::GetInstance()->PushCursor(cursor, hotspotX, hotspotY);
     m_MouseCursorSet = true;
   }
 }
 
 void QmitkMultiLabelSegmentationView::InitializeListeners()
 {
   if (m_Interactor.IsNull())
   {
     us::Module* module = us::GetModuleContext()->GetModule();
     std::vector<us::ModuleResource> resources = module->FindResources("/", "*", true);
     for (std::vector<us::ModuleResource>::iterator iter = resources.begin(); iter != resources.end(); ++iter)
     {
       MITK_INFO << iter->GetResourcePath();
     }
 
     m_Interactor = mitk::SegmentationInteractor::New();
     if (!m_Interactor->LoadStateMachine("SegmentationInteraction.xml", module))
     {
       MITK_WARN << "Error loading state machine";
     }
 
     if (!m_Interactor->SetEventConfig("ConfigSegmentation.xml", module))
     {
       MITK_WARN << "Error loading state machine configuration";
     }
 
     // Register as listener via micro services
     us::ServiceProperties props;
     props["name"] = std::string("SegmentationInteraction");
     m_ServiceRegistration =
       us::GetModuleContext()->RegisterService<mitk::InteractionEventObserver>(m_Interactor.GetPointer(), props);
   }
 }
 
 bool QmitkMultiLabelSegmentationView::CheckForSameGeometry(const mitk::Image *image1, const mitk::Image *image2) const
 {
   bool isSameGeometry(true);
 
   if (image1 && image2)
   {
     mitk::BaseGeometry::Pointer geo1 = image1->GetGeometry();
     mitk::BaseGeometry::Pointer geo2 = image2->GetGeometry();
 
     isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetOrigin(), geo2->GetOrigin());
     isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(0), geo2->GetExtent(0));
     isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(1), geo2->GetExtent(1));
     isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(2), geo2->GetExtent(2));
     isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetSpacing(), geo2->GetSpacing());
     isSameGeometry = isSameGeometry && mitk::MatrixEqualElementWise(geo1->GetIndexToWorldTransform()->GetMatrix(),
                                                                     geo2->GetIndexToWorldTransform()->GetMatrix());
 
     return isSameGeometry;
   }
   else
   {
     return false;
   }
 }
 
 QString QmitkMultiLabelSegmentationView::GetLastFileOpenPath()
 {
   return this->GetPreferences()->Get("LastFileOpenPath", "");
 }
 
 void QmitkMultiLabelSegmentationView::SetLastFileOpenPath(const QString &path)
 {
   this->GetPreferences()->Put("LastFileOpenPath", path);
   this->GetPreferences()->Flush();
 }
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkThresholdAction.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkThresholdAction.cpp
index 811011581c..4cefb5d839 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkThresholdAction.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkThresholdAction.cpp
@@ -1,117 +1,117 @@
 /*===================================================================
 
 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 "QmitkThresholdAction.h"
 
 // MITK
 #include <mitkBinaryThresholdTool.h>
 #include <mitkRenderingManager.h>
 #include <QmitkBinaryThresholdToolGUI.h>
 
 // Qt
 #include <QDialog>
 #include <QVBoxLayout>
 #include <QApplication>
 #include <QDialogButtonBox>
 
 using namespace berry;
 using namespace mitk;
 using namespace std;
 
 QmitkThresholdAction::QmitkThresholdAction()
 {
 }
 
 QmitkThresholdAction::~QmitkThresholdAction()
 {
 }
 
 void QmitkThresholdAction::Run(const QList<DataNode::Pointer> &selectedNodes)
 {
   m_ThresholdingToolManager = ToolManager::New(m_DataStorage);
 
   m_ThresholdingToolManager->RegisterClient();
 
   Tool *binaryThresholdTool = m_ThresholdingToolManager->GetToolById(m_ThresholdingToolManager->GetToolIdByToolType<mitk::BinaryThresholdTool>());
   if (binaryThresholdTool != nullptr)
   {
     QmitkBinaryThresholdToolGUI *gui = dynamic_cast<QmitkBinaryThresholdToolGUI *>(binaryThresholdTool->GetGUI("Qmitk", "GUI").GetPointer());
     if (gui != nullptr)
     {
       QDialog thresholdingDialog(QApplication::activeWindow(), Qt::Window | Qt::WindowStaysOnTopHint);
 
       thresholdingDialog.setWindowFlags(thresholdingDialog.windowFlags() & ~Qt::WindowMinimizeButtonHint);
 
       QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Cancel);
       connect(buttonBox, SIGNAL(rejected()), &thresholdingDialog, SLOT(reject()));
       connect(gui, SIGNAL(thresholdAccepted()), &thresholdingDialog, SLOT(reject()));
 
       QVBoxLayout *layout = new QVBoxLayout;
       layout->setContentsMargins(3, 3, 3, 3);
 
       gui->SetTool(binaryThresholdTool);
       gui->setParent(&thresholdingDialog);
 
       layout->addWidget(gui);
       layout->addWidget(buttonBox);
 
       thresholdingDialog.setLayout(layout);
       thresholdingDialog.setMinimumWidth(350);
 
       m_SelectedNode = selectedNodes[0];
       m_ThresholdingToolManager->SetReferenceData(selectedNodes[0]);
       m_ThresholdingToolManager->ActivateTool(m_ThresholdingToolManager->GetToolIdByToolType<mitk::BinaryThresholdTool>());
 
       m_ThresholdingToolManager->ActiveToolChanged += mitk::MessageDelegate<QmitkThresholdAction>(this, &QmitkThresholdAction::OnThresholdingToolManagerToolModified);
       thresholdingDialog.exec();
       m_ThresholdingToolManager->ActiveToolChanged -= mitk::MessageDelegate<QmitkThresholdAction>(this, &QmitkThresholdAction::OnThresholdingToolManagerToolModified);
 
       m_ThresholdingToolManager->SetReferenceData(nullptr);
       m_ThresholdingToolManager->ActivateTool(-1);
-      m_SelectedNode = 0;
+      m_SelectedNode = nullptr;
     }
   }
 
   m_ThresholdingToolManager->UnregisterClient();
 }
 
 void QmitkThresholdAction::OnThresholdingToolManagerToolModified()
 {
   if (m_ThresholdingToolManager.IsNotNull())
   {
     if (m_ThresholdingToolManager->GetActiveToolID() < 0)
     {
       m_ThresholdingToolManager->SetReferenceData(m_SelectedNode);
       m_ThresholdingToolManager->ActivateTool(m_ThresholdingToolManager->GetToolIdByToolType<mitk::BinaryThresholdTool>());
     }
   }
 }
 
 void QmitkThresholdAction::SetDataStorage(DataStorage *dataStorage)
 {
   m_DataStorage = dataStorage;
 }
 
 void QmitkThresholdAction::SetSmoothed(bool)
 {
 }
 
 void QmitkThresholdAction::SetDecimated(bool)
 {
 }
 
 void QmitkThresholdAction::SetFunctionality(QtViewPart* /*functionality*/)
 {
 }
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.cpp
index 6c17c79691..a96149527f 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.cpp
@@ -1,322 +1,322 @@
 /*===================================================================
 
 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 "QmitkImageMaskingWidget.h"
 #include "../../Common/QmitkDataSelectionWidget.h"
 
 #include <mitkException.h>
 #include <mitkExceptionMacro.h>
 #include <mitkImageStatisticsHolder.h>
 #include <mitkMaskImageFilter.h>
 #include <mitkPadImageFilter.h>
 #include <mitkProgressBar.h>
 #include <mitkIDataStorageService.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkSurfaceToImageFilter.h>
 
 #include <berryPlatform.h>
 
 #include <qmessagebox.h>
 
 static const char* const HelpText = "Select a patient image and a mask";
 
 QmitkImageMaskingWidget::QmitkImageMaskingWidget(mitk::SliceNavigationController* timeNavigationController, QWidget* parent)
   : QmitkSegmentationUtilityWidget(timeNavigationController, parent)
 {
   m_Controls.setupUi(this);
 
   m_Controls.dataSelectionWidget->AddDataStorageComboBox(QmitkDataSelectionWidget::ImagePredicate);
   m_Controls.dataSelectionWidget->AddDataStorageComboBox(QmitkDataSelectionWidget::MaskPredicate);
   m_Controls.dataSelectionWidget->SetHelpText(HelpText);
 
 //  mitk::IDataStorageService::Pointer service =
 //    berry::Platform::GetServiceRegistry().GetServiceById<mitk::IDataStorageService>(mitk::IDataStorageService::ID);
 
 //  assert(service.IsNotNull());
 
   mitk::DataStorage::Pointer ds = m_Controls.dataSelectionWidget->GetDataStorage();
   m_Controls.m_LabelSetWidget->SetDataStorage(ds);
   m_Controls.m_LabelSetWidget->setEnabled(true);
 
   m_Controls.m_MaskStampWidget->SetDataStorage(ds);
 
   this->EnableButtons(false);
 
   connect (m_Controls.rbMaskImage, SIGNAL(toggled(bool)), this, SLOT(OnImageMaskingToggled(bool)));
   connect (m_Controls.rbMaskSurface, SIGNAL(toggled(bool)), this, SLOT(OnSurfaceMaskingToggled(bool)));
   connect (m_Controls.btnMaskImage, SIGNAL(pressed()), this, SLOT(OnMaskImagePressed()));
 
   connect(m_Controls.dataSelectionWidget, SIGNAL(SelectionChanged(unsigned int, const mitk::DataNode*)),
     this, SLOT(OnSelectionChanged(unsigned int, const mitk::DataNode*)));
 
   if( m_Controls.dataSelectionWidget->GetSelection(0).IsNotNull() &&
     m_Controls.dataSelectionWidget->GetSelection(1).IsNotNull() )
   {
     this->OnSelectionChanged( 0, m_Controls.dataSelectionWidget->GetSelection(0));
   }
 }
 
 QmitkImageMaskingWidget::~QmitkImageMaskingWidget()
 {
 }
 
 void QmitkImageMaskingWidget::OnSelectionChanged(unsigned int index, const mitk::DataNode* selection)
 {
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
   mitk::DataNode::Pointer node0 = dataSelectionWidget->GetSelection(0);
   mitk::DataNode::Pointer node1 = dataSelectionWidget->GetSelection(1);
 
   if (node0.IsNull() || node1.IsNull() )
   {
     if( m_Controls.rbMaskImage->isChecked() )
     {
       dataSelectionWidget->SetHelpText(HelpText);
     }
     else
     {
       dataSelectionWidget->SetHelpText("Select a patient image and a surface");
     }
     this->EnableButtons(false);
   }
   else
   {
     this->SelectionControl(index, selection);
   }
 }
 
 void QmitkImageMaskingWidget::SelectionControl(unsigned int index, const mitk::DataNode*)
 {
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
   mitk::DataNode::Pointer node = dataSelectionWidget->GetSelection(index);
 
   //if Image-Masking is enabled, check if image-dimension of reference and binary image is identical
   if( m_Controls.rbMaskImage->isChecked() )
   {
     if( dataSelectionWidget->GetSelection(0) == dataSelectionWidget->GetSelection(1) )
     {
       dataSelectionWidget->SetHelpText("Select two different images above");
       this->EnableButtons(false);
       return;
     }
   }
 
   dataSelectionWidget->SetHelpText("");
   this->EnableButtons();
 }
 
 void QmitkImageMaskingWidget::EnableButtons(bool enable)
 {
   m_Controls.btnMaskImage->setEnabled(enable);
 }
 
 void QmitkImageMaskingWidget::OnImageMaskingToggled(bool status)
 {
   if (status)
   {
     m_Controls.dataSelectionWidget->SetHelpText("Select a patient image and a mask");
     m_Controls.dataSelectionWidget->SetPredicate(1, QmitkDataSelectionWidget::MaskPredicate);
   }
 }
 
 void QmitkImageMaskingWidget::OnSurfaceMaskingToggled(bool status)
 {
   if (status)
   {
     m_Controls.dataSelectionWidget->SetHelpText("Select a patient image and a surface");
     m_Controls.dataSelectionWidget->SetPredicate(1, QmitkDataSelectionWidget::SurfacePredicate);
   }
 }
 
 
 void QmitkImageMaskingWidget::OnMaskImagePressed()
 {
   //Disable Buttons during calculation and initialize Progressbar
   this->EnableButtons(false);
   mitk::ProgressBar::GetInstance()->AddStepsToDo(4);
   mitk::ProgressBar::GetInstance()->Progress();
 
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
 
   //create result image, get mask node and reference image
-  mitk::Image::Pointer resultImage(0);
+  mitk::Image::Pointer resultImage(nullptr);
   mitk::DataNode::Pointer maskingNode = dataSelectionWidget->GetSelection(1);
   mitk::Image::Pointer referenceImage = static_cast<mitk::Image*>(dataSelectionWidget->GetSelection(0)->GetData());
 
   if(referenceImage.IsNull() || maskingNode.IsNull() )
   {
     MITK_ERROR << "Selection does not contain an image";
     QMessageBox::information( this, "Image and Surface Masking", "Selection does not contain an image", QMessageBox::Ok );
     m_Controls.btnMaskImage->setEnabled(true);
     return;
   }
 
   //Do Image-Masking
   if (m_Controls.rbMaskImage->isChecked())
   {
     mitk::ProgressBar::GetInstance()->Progress();
 
     mitk::Image::Pointer maskImage = dynamic_cast<mitk::Image*> ( maskingNode->GetData() );
 
     if( referenceImage->GetLargestPossibleRegion().GetSize() != maskImage->GetLargestPossibleRegion().GetSize() )
     {
       mitk::PadImageFilter::Pointer padImageFilter = mitk::PadImageFilter::New();
       padImageFilter->SetInput(0, maskImage);
       padImageFilter->SetInput(1, referenceImage);
       padImageFilter->SetPadConstant(0);
       padImageFilter->SetBinaryFilter(false);
       padImageFilter->SetLowerThreshold(0);
       padImageFilter->SetUpperThreshold(1);
 
       MITK_INFO << "Padding mask ...";
 
       padImageFilter->Update();
 
       maskImage = padImageFilter->GetOutput();
     }
 
     if(maskImage.IsNull() )
     {
       MITK_ERROR << "Selection does not contain a binary image";
       QMessageBox::information( this, "Image and Surface Masking", "Selection does not contain a binary image", QMessageBox::Ok );
       this->EnableButtons();
       return;
     }
 
     resultImage = this->MaskImage( referenceImage, maskImage );
   }
 
   //Do Surface-Masking
   else
   {
     mitk::ProgressBar::GetInstance()->Progress();
 
     //1. convert surface to image
     mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*> ( maskingNode->GetData() );
 
     //TODO Get 3D Surface of current time step
 
     if(surface.IsNull())
     {
       MITK_ERROR << "Selection does not contain a surface";
       QMessageBox::information( this, "Image and Surface Masking", "Selection does not contain a surface", QMessageBox::Ok );
       this->EnableButtons();
       return;
     }
 
     mitk::Image::Pointer maskImage = this->ConvertSurfaceToImage( referenceImage, surface );
 
     //2. mask reference image with mask image
     if(maskImage.IsNotNull() &&
        referenceImage->GetLargestPossibleRegion().GetSize() == maskImage->GetLargestPossibleRegion().GetSize() )
     {
       resultImage = this->MaskImage( referenceImage, maskImage );
     }
   }
 
   mitk::ProgressBar::GetInstance()->Progress();
 
   if( resultImage.IsNull() )
   {
     MITK_ERROR << "Masking failed";
     QMessageBox::information( this, "Image and Surface Masking", "Masking failed. For more information please see logging window.", QMessageBox::Ok );
     this->EnableButtons();
     mitk::ProgressBar::GetInstance()->Progress(4);
     return;
   }
 
   //Add result to data storage
   this->AddToDataStorage(
     dataSelectionWidget->GetDataStorage(),
     resultImage,
     dataSelectionWidget->GetSelection(0)->GetName() + "_" + dataSelectionWidget->GetSelection(1)->GetName(),
     dataSelectionWidget->GetSelection(0));
 
   this->EnableButtons();
 
   mitk::ProgressBar::GetInstance()->Progress();
 }
 
 mitk::Image::Pointer QmitkImageMaskingWidget::MaskImage(mitk::Image::Pointer referenceImage, mitk::Image::Pointer maskImage )
 {
-  mitk::Image::Pointer resultImage(0);
+  mitk::Image::Pointer resultImage(nullptr);
 
   mitk::MaskImageFilter::Pointer maskFilter = mitk::MaskImageFilter::New();
   maskFilter->SetInput( referenceImage );
   maskFilter->SetMask( maskImage );
   //MLI TODO
   //if ( m_Controls.m_chkMakeOutputBinary->isChecked() )
   //{
   //  maskFilter->SetInsideValue(1.0);
   //  maskFilter->SetOutsideValue(0.0);
   //  maskFilter->SetOverrideOutsideValue(true);
   //  maskFilter->SetOverrideInsideValue(true);
   //}
 
   //maskFilter->SetOverrideOutsideValue( m_Controls.m_chkOverwriteBackground->isChecked() );
   //maskFilter->SetOverrideInsideValue( m_Controls.m_chkOverwriteForeground->isChecked() );
   //maskFilter->SetInsideValue( m_Controls.m_leForegroundValue->text().toFloat() );//referenceImage->GetStatistics()->GetScalarValueMin() );
   //maskFilter->SetOutsideValue( m_Controls.m_leBackgroundValue->text().toFloat() );//referenceImage->GetStatistics()->GetScalarValueMin() );
 
   try
   {
     maskFilter->Update();
   }
   catch(itk::ExceptionObject& excpt)
   {
     MITK_ERROR << excpt.GetDescription();
-    return 0;
+    return nullptr;
   }
 
   resultImage = maskFilter->GetOutput();
 
   return resultImage;
 }
 
 mitk::Image::Pointer QmitkImageMaskingWidget::ConvertSurfaceToImage( mitk::Image::Pointer image, mitk::Surface::Pointer surface )
 {
   mitk::ProgressBar::GetInstance()->AddStepsToDo(2);
   mitk::ProgressBar::GetInstance()->Progress();
 
   mitk::SurfaceToImageFilter::Pointer surfaceToImageFilter = mitk::SurfaceToImageFilter::New();
   surfaceToImageFilter->MakeOutputBinaryOn();
   surfaceToImageFilter->SetInput(surface);
   surfaceToImageFilter->SetImage(image);
   try
   {
     surfaceToImageFilter->Update();
   }
   catch(itk::ExceptionObject& excpt)
   {
     MITK_ERROR << excpt.GetDescription();
-    return 0;
+    return nullptr;
   }
 
   mitk::ProgressBar::GetInstance()->Progress();
   mitk::Image::Pointer resultImage = mitk::Image::New();
   resultImage = surfaceToImageFilter->GetOutput();
 
   return resultImage;
 }
 
 void QmitkImageMaskingWidget::AddToDataStorage(mitk::DataStorage::Pointer dataStorage, mitk::Image::Pointer segmentation, const std::string& name, mitk::DataNode::Pointer parent )
 {
   mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
 
   dataNode->SetName(name);
   dataNode->SetData(segmentation);
 
   dataStorage->Add(dataNode, parent);
 }
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.cpp
index 7b2d5a28c0..0ece4ce49a 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.cpp
@@ -1,179 +1,179 @@
 /*===================================================================
 
 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 "QmitkSurfaceToImageWidget.h"
 
 #include <mitkException.h>
 #include <mitkExceptionMacro.h>
 #include <mitkProgressBar.h>
 #include <mitkProperties.h>
 #include <mitkIDataStorageService.h>
 #include <mitkSurfaceStampImageFilter.h>
 
 #include <berryPlatform.h>
 
 #include <qmessagebox.h>
 
 static const char* const HelpText = "Select a patient image and a surface";
 
 QmitkSurfaceToImageWidget::QmitkSurfaceToImageWidget(mitk::SliceNavigationController* timeNavigationController, QWidget* parent)
   : QmitkSegmentationUtilityWidget(timeNavigationController, parent)
 {
   m_Controls.setupUi(this);
 
   m_Controls.m_DataSelectionWidget->AddDataStorageComboBox(QmitkDataSelectionWidget::ImagePredicate);
   m_Controls.m_DataSelectionWidget->AddDataStorageComboBox(QmitkDataSelectionWidget::SurfacePredicate);
   m_Controls.m_DataSelectionWidget->SetHelpText(HelpText);
 
 //  mitk::IDataStorageService* service =
 //    berry::Platform::GetServiceRegistry().GetServiceById<mitk::IDataStorageService>(mitk::IDataStorageService::ID);
 
 //  assert(service.IsNotNull());
 
   mitk::DataStorage::Pointer ds = m_Controls.m_DataSelectionWidget->GetDataStorage();
   m_Controls.m_LabelSetWidget->SetDataStorage(ds);
   m_Controls.m_LabelSetWidget->setEnabled(true);
 
   m_Controls.m_SurfaceStampWidget->SetDataStorage(ds);
 
   this->EnableButtons(false);
 
   m_Controls.m_chkMakeOutputBinary->setChecked(true);
 
   connect (m_Controls.btnSurface2Image, SIGNAL(pressed()), this, SLOT(OnSurface2ImagePressed()));
   connect(m_Controls.m_DataSelectionWidget, SIGNAL(SelectionChanged(unsigned int, const mitk::DataNode*)),
     this, SLOT(OnSelectionChanged(unsigned int, const mitk::DataNode*)));
   connect (m_Controls.m_chkMakeOutputBinary, SIGNAL(toggled(bool)), this, SLOT(OnMakeOutputBinaryChanged(bool)));
 
   if( m_Controls.m_DataSelectionWidget->GetSelection(0).IsNotNull() &&
     m_Controls.m_DataSelectionWidget->GetSelection(1).IsNotNull() )
   {
     this->OnSelectionChanged( 0, m_Controls.m_DataSelectionWidget->GetSelection(0));
   }
 }
 
 QmitkSurfaceToImageWidget::~QmitkSurfaceToImageWidget()
 {
 }
 
 void QmitkSurfaceToImageWidget::EnableButtons(bool enable)
 {
   m_Controls.btnSurface2Image->setEnabled(enable);
   m_Controls.m_chkMakeOutputBinary->setEnabled(enable);
   m_Controls.m_chkOverwriteBackground->setEnabled(enable && !m_Controls.m_chkMakeOutputBinary->isChecked());
   m_Controls.m_leForegroundValue->setEnabled(enable && !m_Controls.m_chkMakeOutputBinary->isChecked());
   m_Controls.m_leBackgroundValue->setEnabled(enable && !m_Controls.m_chkMakeOutputBinary->isChecked());
 }
 
 void QmitkSurfaceToImageWidget::OnSelectionChanged(unsigned int, const mitk::DataNode*)
 {
   mitk::DataNode::Pointer imageNode = m_Controls.m_DataSelectionWidget->GetSelection(0);
   mitk::DataNode::Pointer surfaceNode = m_Controls.m_DataSelectionWidget->GetSelection(1);
 
   if (imageNode.IsNull() || surfaceNode.IsNull() )
   {
     m_Controls.m_DataSelectionWidget->SetHelpText(HelpText);
     this->EnableButtons(false);
   }
   else
   {
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( m_Controls.m_DataSelectionWidget->GetSelection(0)->GetData() );
     mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>( m_Controls.m_DataSelectionWidget->GetSelection(1)->GetData() );
     if( image->GetTimeSteps() != surface->GetTimeSteps() )
     {
       m_Controls.m_DataSelectionWidget->SetHelpText("Image and surface are of different size");
       this->EnableButtons(false);
     }
     else
     {
       m_Controls.m_DataSelectionWidget->SetHelpText("");
       this->EnableButtons();
     }
   }
 }
 
 void QmitkSurfaceToImageWidget::OnSurface2ImagePressed()
 {
   this->EnableButtons(false);
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( m_Controls.m_DataSelectionWidget->GetSelection(0)->GetData() );
   mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>( m_Controls.m_DataSelectionWidget->GetSelection(1)->GetData() );
 
   if( image.IsNull() || surface.IsNull())
   {
     MITK_ERROR << "Selection does not contain an image and/or a surface";
     QMessageBox::information( this, "Surface To Image", "Selection does not contain an image and/or a surface", QMessageBox::Ok );
     this->EnableButtons();
     return;
   }
 
-  mitk::Image::Pointer resultImage(0);
+  mitk::Image::Pointer resultImage(nullptr);
   resultImage = this->ConvertSurfaceToImage( image, surface );
 
   if( resultImage.IsNull() )
   {
     QMessageBox::information( this, "Surface to Image", "Could not stamp surface.\n See error log for details.", QMessageBox::Ok );
     this->EnableButtons();
     return;
   }
 
   //create name for result node
   std::string nameOfResultImage = m_Controls.m_DataSelectionWidget->GetSelection(0)->GetName();
   nameOfResultImage.append("_");
   nameOfResultImage.append(m_Controls.m_DataSelectionWidget->GetSelection(1)->GetName());
 
   //create data node and add to data storage
   mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
   resultNode->SetData( resultImage );
   resultNode->SetProperty("name", mitk::StringProperty::New(nameOfResultImage) );
   resultNode->SetProperty("binary", mitk::BoolProperty::New(m_Controls.m_chkMakeOutputBinary->isChecked()) );
 
   m_Controls.m_DataSelectionWidget->GetDataStorage()->Add(resultNode, m_Controls.m_DataSelectionWidget->GetSelection(0));
 
   this->EnableButtons();
 }
 
 mitk::Image::Pointer QmitkSurfaceToImageWidget::ConvertSurfaceToImage( mitk::Image::Pointer image, mitk::Surface::Pointer surface )
 {
   mitk::SurfaceStampImageFilter::Pointer filter = mitk::SurfaceStampImageFilter::New();
   filter->SetInput(image);
   filter->SetSurface(surface);
   filter->SetMakeOutputBinary(m_Controls.m_chkMakeOutputBinary->isChecked());
   filter->SetOverwriteBackground(m_Controls.m_chkOverwriteBackground->isChecked());
   filter->SetForegroundValue(m_Controls.m_leForegroundValue->text().toFloat());
   filter->SetBackgroundValue(m_Controls.m_leBackgroundValue->text().toFloat());
 
   try
   {
     filter->Update();
   }
   catch(mitk::Exception& e)
   {
     MITK_ERROR << "exception caught: " << e.GetDescription();
-    return 0;
+    return nullptr;
   }
 
   mitk::Image::Pointer resultImage = filter->GetOutput();
 
   return resultImage;
 }
 
 void QmitkSurfaceToImageWidget::OnMakeOutputBinaryChanged(bool value)
 {
   m_Controls.m_chkOverwriteBackground->setEnabled(!value);
   m_Controls.m_leForegroundValue->setEnabled(!value);
   m_Controls.m_leBackgroundValue->setEnabled(!value);
 }
diff --git a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
index f29e769d65..79ae91af09 100644
--- a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
@@ -1,272 +1,272 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical Image Computing.
 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 "QmitkMxNMultiWidgetEditor.h"
 
 #include <berryIPreferencesService.h>
 #include <berryIPreferences.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIWorkbenchPartConstants.h>
 #include <berryUIException.h>
 
 // mxn multi widget editor plugin
 #include "QmitkMultiWidgetDecorationManager.h"
 
 // mitk qt widgets module
 #include <QmitkMxNMultiWidget.h>
 #include <QmitkInteractionSchemeToolBar.h>
 #include <QmitkMultiWidgetConfigurationToolBar.h>
 
 const QString QmitkMxNMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.mxnmultiwidget";
 
 class QmitkMxNMultiWidgetEditor::Impl final
 {
 
 public:
 
   Impl();
   ~Impl() = default;
 
   QmitkMxNMultiWidget* m_MxNMultiWidget;
   QmitkInteractionSchemeToolBar* m_InteractionSchemeToolBar;
   QmitkMultiWidgetConfigurationToolBar* m_ConfigurationToolBar;
 
   std::unique_ptr<QmitkMultiWidgetDecorationManager> m_MultiWidgetDecorationManager;
 };
 
 QmitkMxNMultiWidgetEditor::Impl::Impl()
   : m_MxNMultiWidget(nullptr)
   , m_InteractionSchemeToolBar(nullptr)
   , m_ConfigurationToolBar(nullptr)
 {
   // nothing here
 }
 
 //////////////////////////////////////////////////////////////////////////
 // QmitkMxNMultiWidgetEditor
 //////////////////////////////////////////////////////////////////////////
 QmitkMxNMultiWidgetEditor::QmitkMxNMultiWidgetEditor()
   : m_Impl(new Impl())
 {}
 
 QmitkMxNMultiWidgetEditor::~QmitkMxNMultiWidgetEditor()
 {
   GetSite()->GetPage()->RemovePartListener(this);
 }
 
 QmitkRenderWindow* QmitkMxNMultiWidgetEditor::GetActiveQmitkRenderWindow() const
 {
   if (nullptr != m_Impl->m_MxNMultiWidget)
   {
     auto activeRenderWindowWidget = m_Impl->m_MxNMultiWidget->GetActiveRenderWindowWidget();
     if (nullptr != activeRenderWindowWidget)
     {
       return activeRenderWindowWidget->GetRenderWindow();
     }
   }
 
   return nullptr;
 }
 
 QHash<QString, QmitkRenderWindow*> QmitkMxNMultiWidgetEditor::GetQmitkRenderWindows() const
 {
   QHash<QString, QmitkRenderWindow*> result;
   if (nullptr == m_Impl->m_MxNMultiWidget)
   {
     return result;
   }
 
   result = m_Impl->m_MxNMultiWidget->GetRenderWindows();
   return result;
 }
 
 QmitkRenderWindow* QmitkMxNMultiWidgetEditor::GetQmitkRenderWindow(const QString& id) const
 {
   if (nullptr == m_Impl->m_MxNMultiWidget)
   {
     return nullptr;
   }
 
   return m_Impl->m_MxNMultiWidget->GetRenderWindow(id);
 }
 
 mitk::Point3D QmitkMxNMultiWidgetEditor::GetSelectedPosition(const QString& id) const
 {
   if (nullptr == m_Impl->m_MxNMultiWidget)
   {
     return mitk::Point3D();
   }
 
   return m_Impl->m_MxNMultiWidget->GetSelectedPosition(id);
 }
 
 void QmitkMxNMultiWidgetEditor::SetSelectedPosition(const mitk::Point3D& pos, const QString& id)
 {
   if (nullptr != m_Impl->m_MxNMultiWidget)
   {
     m_Impl->m_MxNMultiWidget->SetSelectedPosition(id, pos);
   }
 }
 
 void QmitkMxNMultiWidgetEditor::EnableDecorations(bool enable, const QStringList& decorations)
 {
   m_Impl->m_MultiWidgetDecorationManager->ShowDecorations(enable, decorations);
 }
 
 bool QmitkMxNMultiWidgetEditor::IsDecorationEnabled(const QString& decoration) const
 {
   return m_Impl->m_MultiWidgetDecorationManager->IsDecorationVisible(decoration);
 }
 
 QStringList QmitkMxNMultiWidgetEditor::GetDecorations() const
 {
   return m_Impl->m_MultiWidgetDecorationManager->GetDecorations();
 }
 
 berry::IPartListener::Events::Types QmitkMxNMultiWidgetEditor::GetPartEventTypes() const
 {
   return Events::CLOSED | Events::OPENED;
 }
 
 void QmitkMxNMultiWidgetEditor::PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
   {
     m_Impl->m_MxNMultiWidget->ActivateAllCrosshairs(true);
   }
 }
 
 void QmitkMxNMultiWidgetEditor::PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef)
 {
   if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
   {
     m_Impl->m_MxNMultiWidget->ActivateAllCrosshairs(false);
   }
 }
 
 QmitkMxNMultiWidget* QmitkMxNMultiWidgetEditor::GetMxNMultiWidget()
 {
   return m_Impl->m_MxNMultiWidget;
 }
 
 void QmitkMxNMultiWidgetEditor::OnLayoutSet(int row, int column)
 {
   m_Impl->m_MxNMultiWidget->ResetLayout(row, column);
   m_Impl->m_MxNMultiWidget->ActivateAllCrosshairs(true);
   FirePropertyChange(berry::IWorkbenchPartConstants::PROP_INPUT);
 }
 
 void QmitkMxNMultiWidgetEditor::OnSynchronize(bool synchronized)
 {
   m_Impl->m_MxNMultiWidget->Synchronize(synchronized);
 }
 
 void QmitkMxNMultiWidgetEditor::OnInteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme)
 {
   if (mitk::InteractionSchemeSwitcher::PACSStandard == scheme)
   {
     m_Impl->m_InteractionSchemeToolBar->setVisible(true);
   }
   else
   {
     m_Impl->m_InteractionSchemeToolBar->setVisible(false);
   }
 
   m_Impl->m_MxNMultiWidget->SetInteractionScheme(scheme);
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkMxNMultiWidgetEditor::SetFocus()
 {
   if (nullptr != m_Impl->m_MxNMultiWidget)
   {
     m_Impl->m_MxNMultiWidget->setFocus();
   }
 }
 
 void QmitkMxNMultiWidgetEditor::CreateQtPartControl(QWidget* parent)
 {
   if (nullptr == m_Impl->m_MxNMultiWidget)
   {
     QHBoxLayout* layout = new QHBoxLayout(parent);
     layout->setContentsMargins(0, 0, 0, 0);
 
     berry::IBerryPreferences* preferences = dynamic_cast<berry::IBerryPreferences*>(GetPreferences().GetPointer());
     mitk::BaseRenderer::RenderingMode::Type renderingMode = static_cast<mitk::BaseRenderer::RenderingMode::Type>(preferences->GetInt("Rendering Mode", 0));
 
-    m_Impl->m_MxNMultiWidget = new QmitkMxNMultiWidget(parent, 0, 0, renderingMode);
+    m_Impl->m_MxNMultiWidget = new QmitkMxNMultiWidget(parent, nullptr, nullptr, renderingMode);
 
     // create left toolbar: interaction scheme toolbar to switch how the render window navigation behaves in PACS mode
     if (nullptr == m_Impl->m_InteractionSchemeToolBar)
     {
       m_Impl->m_InteractionSchemeToolBar = new QmitkInteractionSchemeToolBar(parent);
       layout->addWidget(m_Impl->m_InteractionSchemeToolBar);
     }
     m_Impl->m_InteractionSchemeToolBar->SetInteractionEventHandler(m_Impl->m_MxNMultiWidget->GetInteractionEventHandler());
 
     // show / hide PACS mouse mode interaction scheme toolbar
     bool PACSInteractionScheme = preferences->GetBool("PACS like mouse interaction", false);
     m_Impl->m_InteractionSchemeToolBar->setVisible(PACSInteractionScheme);
 
     // add center widget: the mxn multi widget
     layout->addWidget(m_Impl->m_MxNMultiWidget);
 
     m_Impl->m_MxNMultiWidget->SetDataStorage(GetDataStorage());
     m_Impl->m_MxNMultiWidget->InitializeRenderWindowWidgets();
 
     // create right toolbar: configuration toolbar to change the render window widget layout
     if (nullptr == m_Impl->m_ConfigurationToolBar)
     {
       m_Impl->m_ConfigurationToolBar = new QmitkMultiWidgetConfigurationToolBar();
       layout->addWidget(m_Impl->m_ConfigurationToolBar);
     }
 
     connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::LayoutSet, this, &QmitkMxNMultiWidgetEditor::OnLayoutSet);
     connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::Synchronized, this, &QmitkMxNMultiWidgetEditor::OnSynchronize);
     connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::InteractionSchemeChanged, this, &QmitkMxNMultiWidgetEditor::OnInteractionSchemeChanged);
 
     m_Impl->m_MultiWidgetDecorationManager = std::make_unique<QmitkMultiWidgetDecorationManager>(m_Impl->m_MxNMultiWidget);
 
     GetSite()->GetPage()->AddPartListener(this);
 
     OnPreferencesChanged(preferences);
   }
 }
 
 void QmitkMxNMultiWidgetEditor::OnPreferencesChanged(const berry::IBerryPreferences* preferences)
 {
   if (m_Impl->m_MxNMultiWidget->GetRenderWindowWidgets().empty())
   {
     return;
   }
 
   // update decoration preferences
   m_Impl->m_MultiWidgetDecorationManager->DecorationPreferencesChanged(preferences);
 
   // zooming and panning preferences
   bool constrainedZooming = preferences->GetBool("Use constrained zooming and panning", true);
   mitk::RenderingManager::GetInstance()->SetConstrainedPanningZooming(constrainedZooming);
 
   bool PACSInteractionScheme = preferences->GetBool("PACS like mouse interaction", false);
   OnInteractionSchemeChanged(PACSInteractionScheme ?
     mitk::InteractionSchemeSwitcher::PACSStandard :
     mitk::InteractionSchemeSwitcher::MITKStandard);
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(GetDataStorage());
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
diff --git a/Plugins/org.mitk.gui.qt.pharmacokinetics.concentration.mri/src/internal/ConcentrationCurveConverterView.cpp b/Plugins/org.mitk.gui.qt.pharmacokinetics.concentration.mri/src/internal/ConcentrationCurveConverterView.cpp
index 829114a84c..c9cad98ddb 100644
--- a/Plugins/org.mitk.gui.qt.pharmacokinetics.concentration.mri/src/internal/ConcentrationCurveConverterView.cpp
+++ b/Plugins/org.mitk.gui.qt.pharmacokinetics.concentration.mri/src/internal/ConcentrationCurveConverterView.cpp
@@ -1,401 +1,401 @@
 /*===================================================================
 
 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 <QMessageBox>
 
 #include "mitkWorkbenchUtil.h"
 
 #include "ConcentrationCurveConverterView.h"
 #include "mitkConcentrationCurveGenerator.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkConvertToConcentrationTurboFlashFunctor.h"
 #include "mitkConvertToConcentrationAbsoluteFunctor.h"
 #include "mitkConvertToConcentrationRelativeFunctor.h"
 #include "itkBinaryFunctorImageFilter.h"
 
 
 
 // Includes for image casting between ITK and MITK
 #include "mitkImageTimeSelector.h"
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 #include <mitkImagePixelReadAccessor.h>
 
 #include <iostream>
 
 const std::string ConcentrationCurveConverterView::VIEW_ID = "org.mitk.ConcentrationCurveConverterView";
 
 void ConcentrationCurveConverterView::SetFocus()
 {
     m_Controls.btnConvertToConcentration->setFocus();
 }
 
 void ConcentrationCurveConverterView::CreateQtPartControl(QWidget* parent)
 {
 	m_Controls.setupUi(parent);
     m_Controls.btnConvertToConcentration->setEnabled(false);
 
     connect(m_Controls.btnConvertToConcentration, SIGNAL(clicked()), this, SLOT(OnConvertToConcentrationButtonClicked()));
 
     m_Controls.groupBox_T1->hide();
     m_Controls.groupBox_T2->hide();
     m_Controls.groupBox3D->hide();
     m_Controls.groupBox4D->hide();
     m_Controls.groupBoxTurboFlash->hide();
     m_Controls.factorSpinBox->setEnabled(false);
     m_Controls.groupBox_ConcentrationParameters->hide();
 
     connect(m_Controls.radioButton_T1, SIGNAL(toggled(bool)),this, SLOT(OnSettingChanged()));
     connect(m_Controls.radioButton_T2, SIGNAL(toggled(bool)),this, SLOT(OnSettingChanged()));
 
     connect(m_Controls.radioButton3D, SIGNAL(toggled(bool)),this, SLOT(OnSettingChanged()));
     connect(m_Controls.radioButton4D, SIGNAL(toggled(bool)),this, SLOT(OnSettingChanged()));
 
     connect(m_Controls.radioButtonTurboFlash, SIGNAL(toggled(bool)), m_Controls.groupBoxTurboFlash,
             SLOT(setVisible(bool)));
 
     connect(m_Controls.radioButtonTurboFlash, SIGNAL(toggled(bool)), this,
             SLOT(OnSettingChanged()));
     connect(m_Controls.relaxationTime, SIGNAL(valueChanged(double)), this,
             SLOT(OnSettingChanged()));
     connect(m_Controls.recoveryTime, SIGNAL(valueChanged(double)), this, SLOT(OnSettingChanged()));
     connect(m_Controls.relaxivity, SIGNAL(valueChanged(double)), this, SLOT(OnSettingChanged()));
 
     connect(m_Controls.radioButton_absoluteEnhancement, SIGNAL(toggled(bool)), this,
             SLOT(OnSettingChanged()));
     connect(m_Controls.radioButton_relativeEnchancement, SIGNAL(toggled(bool)), this,
             SLOT(OnSettingChanged()));
     connect(m_Controls.radioButton_absoluteEnhancement, SIGNAL(toggled(bool)), m_Controls.factorSpinBox,
             SLOT(setEnabled(bool)));
     connect(m_Controls.radioButton_relativeEnchancement, SIGNAL(toggled(bool)),
             m_Controls.factorSpinBox,
             SLOT(setEnabled(bool)));
     connect(m_Controls.factorSpinBox, SIGNAL(valueChanged(double)), this,
             SLOT(OnSettingChanged()));
 
 }
 
 
 void ConcentrationCurveConverterView::OnSettingChanged()
 {
   bool ok = true;
   m_Controls.groupBox_T1->setVisible(m_Controls.radioButton_T1->isChecked());
   m_Controls.groupBox_T2->setVisible(m_Controls.radioButton_T2->isChecked());
 
   if(m_Controls.radioButton_T1->isChecked())
   {
       m_Controls.groupBox_ConcentrationParameters->setVisible(true);
       m_Controls.groupBox3D->setVisible(m_Controls.radioButton3D->isChecked());
       m_Controls.groupBox4D->setVisible(m_Controls.radioButton4D->isChecked());
 
       if(m_Controls.radioButton4D->isChecked())
       {
           ok = m_selectedImage.IsNotNull() && CheckSettings();
       }
       else if(m_Controls.radioButton3D->isChecked())
       {
           ok = m_selectedImage.IsNotNull() && m_selectedBaselineImage.IsNotNull() && CheckSettings();
 
       }
   }
   else if (m_Controls.radioButton_T2->isChecked())
   {
       m_Controls.groupBox_ConcentrationParameters->setVisible(false);
 
       ok = m_selectedImage.IsNotNull() && CheckSettings();
 
   }
 
   m_Controls.btnConvertToConcentration->setEnabled(ok);
 }
 
 
 bool ConcentrationCurveConverterView::CheckSettings() const
 {
   bool ok = true;
 
   if(m_Controls.radioButton_T1->isChecked())
   {
       if (this->m_Controls.radioButtonTurboFlash->isChecked())
       {
           ok = ok && (m_Controls.recoveryTime->value() > 0);
           ok = ok && (m_Controls.relaxationTime->value() > 0);
           ok = ok && (m_Controls.relaxivity->value() > 0);
 
       }
       else if (this->m_Controls.radioButton_absoluteEnhancement->isChecked()
                || this->m_Controls.radioButton_relativeEnchancement->isChecked())
       {
           ok = ok && (m_Controls.factorSpinBox->value() > 0);
       }
       else
       {
           ok = false;
       }
   }
   else if (this->m_Controls.radioButton_T2->isChecked())
   {
        ok = ok && m_Controls.T2EchoTimeSpinBox->value() > 0;
        ok = ok && m_Controls.T2FactorSpinBox->value() > 0;
   }
   else
   {
       ok=false;
   }
 
 
   return ok;
 }
 
 void ConcentrationCurveConverterView::OnConvertToConcentrationButtonClicked()
 {
 
     mitk::Image::Pointer concentrationImage;
     mitk::DataNode::Pointer concentrationNode;
 
     if(m_Controls.radioButton_T1->isChecked())
     {
         if(m_Controls.radioButton4D->isChecked())
         {
             concentrationImage = this->Convert4DConcentrationImage(this->m_selectedImage);
         }
         else if(m_Controls.radioButton3D->isChecked())
         {
             concentrationImage = Convert3DConcentrationImage(this->m_selectedImage, this->m_selectedBaselineImage);
         }
     }
     else if(m_Controls.radioButton_T2->isChecked())
     {
         concentrationImage = this->ConvertT2ConcentrationImgage(this->m_selectedImage);
     }
     std::string nameOfResultImage = m_selectedNode->GetName();
     nameOfResultImage.append("_Concentration");
 
     concentrationNode = AddConcentrationImage(concentrationImage,nameOfResultImage);
 
 }
 
 
 mitk::Image::Pointer ConcentrationCurveConverterView::Convert3DConcentrationImage(mitk::Image::Pointer inputImage,mitk::Image::Pointer baselineImage)
     {
     typedef itk::Image<double, 3> InputImageType;
 
     InputImageType::Pointer itkInputImage = InputImageType::New();
     InputImageType::Pointer itkBaselineImage = InputImageType::New();
 
     mitk::CastToItkImage(inputImage, itkInputImage );
     mitk::CastToItkImage(baselineImage, itkBaselineImage );
 
 
     mitk::Image::Pointer outputImage;
 
     if(this->m_Controls.radioButtonTurboFlash->isChecked())
     {
         typedef mitk::ConvertToConcentrationTurboFlashFunctor <double, double, double> ConversionFunctorTurboFlashType;
         typedef itk::BinaryFunctorImageFilter<InputImageType,InputImageType, ConvertedImageType, ConversionFunctorTurboFlashType> FilterTurboFlashType;
 
         ConversionFunctorTurboFlashType ConversionTurboFlashFunctor;
         ConversionTurboFlashFunctor.initialize(m_Controls.relaxationTime->value(), m_Controls.relaxivity->value(), m_Controls.recoveryTime->value());
 
         FilterTurboFlashType::Pointer ConversionTurboFlashFilter = FilterTurboFlashType::New();
 
         ConversionTurboFlashFilter->SetFunctor(ConversionTurboFlashFunctor);
         ConversionTurboFlashFilter->SetInput1(itkInputImage);
         ConversionTurboFlashFilter->SetInput2(itkBaselineImage);
 
         ConversionTurboFlashFilter->Update();
         outputImage = mitk::ImportItkImage(ConversionTurboFlashFilter->GetOutput())->Clone();
 
 
     }
     else if(this->m_Controls.radioButton_absoluteEnhancement->isChecked())
     {
         typedef mitk::ConvertToConcentrationAbsoluteFunctor <double, double, double> ConversionFunctorAbsoluteType;
         typedef itk::BinaryFunctorImageFilter<InputImageType,InputImageType, ConvertedImageType, ConversionFunctorAbsoluteType> FilterAbsoluteType;
 
         ConversionFunctorAbsoluteType ConversionAbsoluteFunctor;
         ConversionAbsoluteFunctor.initialize(m_Controls.factorSpinBox->value());
 
         FilterAbsoluteType::Pointer ConversionAbsoluteFilter = FilterAbsoluteType::New();
 
         ConversionAbsoluteFilter->SetFunctor(ConversionAbsoluteFunctor);
         ConversionAbsoluteFilter->SetInput1(itkInputImage);
         ConversionAbsoluteFilter->SetInput2(itkBaselineImage);
 
         ConversionAbsoluteFilter->Update();
 
         outputImage = mitk::ImportItkImage(ConversionAbsoluteFilter->GetOutput())->Clone();
     }
 
     else if(m_Controls.radioButton_relativeEnchancement->isChecked())
     {
         typedef mitk::ConvertToConcentrationRelativeFunctor <double, double, double> ConversionFunctorRelativeType;
         typedef itk::BinaryFunctorImageFilter<InputImageType,InputImageType, ConvertedImageType, ConversionFunctorRelativeType> FilterRelativeType;
 
         ConversionFunctorRelativeType ConversionRelativeFunctor;
         ConversionRelativeFunctor.initialize(m_Controls.factorSpinBox->value());
 
         FilterRelativeType::Pointer ConversionRelativeFilter = FilterRelativeType::New();
 
         ConversionRelativeFilter->SetFunctor(ConversionRelativeFunctor);
         ConversionRelativeFilter->SetInput1(itkInputImage);
         ConversionRelativeFilter->SetInput2(itkBaselineImage);
 
         ConversionRelativeFilter->Update();
 
         outputImage = mitk::ImportItkImage(ConversionRelativeFilter->GetOutput())->Clone();
     }
 
 
 
     return outputImage;
 }
 
 
 mitk::DataNode::Pointer ConcentrationCurveConverterView::AddConcentrationImage(mitk::Image* image, std::string nodeName) const
 {
   if (!image)
   {
     mitkThrow() << "Cannot generate concentration node. Passed image is null. parameter name: ";
   }
 
   mitk::DataNode::Pointer result = mitk::DataNode::New();
 
   result->SetData(image);
 
   result->SetName(nodeName);
 
   result->SetVisibility(true);
 
 
   this->GetDataStorage()->Add(result, m_selectedNode);
 
   return result;
 };
 
 
 mitk::Image::Pointer ConcentrationCurveConverterView::Convert4DConcentrationImage(mitk::Image::Pointer inputImage)
 {
   //Compute Concentration image
   mitk::ConcentrationCurveGenerator::Pointer concentrationGen =
     mitk::ConcentrationCurveGenerator::New();
   concentrationGen->SetDynamicImage(inputImage);
 
   concentrationGen->SetisTurboFlashSequence(m_Controls.radioButtonTurboFlash->isChecked());
   concentrationGen->SetAbsoluteSignalEnhancement(m_Controls.radioButton_absoluteEnhancement->isChecked());
   concentrationGen->SetRelativeSignalEnhancement(m_Controls.radioButton_relativeEnchancement->isChecked());
 
   concentrationGen->SetisT2weightedImage(false);
 
   if (m_Controls.radioButtonTurboFlash->isChecked())
   {
     concentrationGen->SetRecoveryTime(m_Controls.recoveryTime->value());
     concentrationGen->SetRelaxationTime(m_Controls.relaxationTime->value());
     concentrationGen->SetRelaxivity(m_Controls.relaxivity->value());
   }
 
   else
   {
     concentrationGen->SetFactor(m_Controls.factorSpinBox->value());
   }
 
   mitk::Image::Pointer concentrationImage = concentrationGen->GetConvertedImage();
 
   return concentrationImage;
 }
 
 
 mitk::Image::Pointer ConcentrationCurveConverterView::ConvertT2ConcentrationImgage(mitk::Image::Pointer inputImage)
 {
     //Compute Concentration image
     mitk::ConcentrationCurveGenerator::Pointer concentrationGen =
       mitk::ConcentrationCurveGenerator::New();
     concentrationGen->SetDynamicImage(inputImage);
 
     concentrationGen->SetisTurboFlashSequence(false);
     concentrationGen->SetAbsoluteSignalEnhancement(false);
     concentrationGen->SetRelativeSignalEnhancement(false);
 
     concentrationGen->SetisT2weightedImage(true);
 
 
     concentrationGen->SetT2Factor(m_Controls.T2FactorSpinBox->value());
     concentrationGen->SetT2EchoTime(m_Controls.T2EchoTimeSpinBox->value());
 
 
     mitk::Image::Pointer concentrationImage = concentrationGen->GetConvertedImage();
 
     return concentrationImage;
 }
 
 void ConcentrationCurveConverterView::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*source*/,const QList<mitk::DataNode::Pointer>& selectedNodes ){
 
-    m_selectedNode = NULL;
-    m_selectedImage = NULL;
-    m_selectedBaselineNode = NULL;
-    m_selectedBaselineImage = NULL;
+    m_selectedNode = nullptr;
+    m_selectedImage = nullptr;
+    m_selectedBaselineNode = nullptr;
+    m_selectedBaselineImage = nullptr;
 
     m_Controls.timeserieslabel->setText("No (valid) series selected.");
     m_Controls.BaselineImageLabel->setText("No (valid) baseline image selected.");
     m_Controls.ImageLabel->setText("No (valid) image selected.");
     m_Controls.T2_SeriesLabel->setText("No (valid) series selected.");
 
     m_Controls.btnConvertToConcentration->setEnabled(false);
 
     QList<mitk::DataNode::Pointer> nodes = selectedNodes;
     mitk::NodePredicateDataType::Pointer imagePredicate = mitk::NodePredicateDataType::New("Image");
 
     if(m_Controls.radioButton_T1->isChecked())
     {
         if (nodes.size() > 0 && imagePredicate->CheckNode(nodes.front()))
         {
             this->m_selectedNode = nodes.front();
             this->m_selectedImage = dynamic_cast<mitk::Image*>(this->m_selectedNode->GetData());
             m_Controls.timeserieslabel->setText((this->m_selectedNode->GetName()).c_str());
             nodes.pop_front();
         }
 
         if (nodes.size() > 0 && imagePredicate->CheckNode(nodes.front()))
         {
 
             this->m_selectedBaselineNode = nodes.front();
             this->m_selectedBaselineImage = dynamic_cast<mitk::Image*>(this->m_selectedBaselineNode->GetData());
             this->m_Controls.BaselineImageLabel->setText((this->m_selectedBaselineNode->GetName()).c_str());
         }
     }
     else if(m_Controls.radioButton_T2->isChecked())
     {
         if (nodes.size() > 0 && imagePredicate->CheckNode(nodes.front()))
         {
             this->m_selectedNode = nodes.front();
             this->m_selectedImage = dynamic_cast<mitk::Image*>(this->m_selectedNode->GetData());
             m_Controls.T2_SeriesLabel->setText((this->m_selectedNode->GetName()).c_str());
             nodes.pop_front();
         }
     }
 
 
     m_Controls.btnConvertToConcentration->setEnabled(m_selectedImage.IsNotNull() && CheckSettings());
 
 
 
 }
 
 
 
 ConcentrationCurveConverterView::ConcentrationCurveConverterView()
 {
 }
diff --git a/Plugins/org.mitk.gui.qt.pharmacokinetics.curvedescriptor/src/internal/PerfusionCurveDescriptionParameterView.cpp b/Plugins/org.mitk.gui.qt.pharmacokinetics.curvedescriptor/src/internal/PerfusionCurveDescriptionParameterView.cpp
index 520fcd55ad..07966664c3 100644
--- a/Plugins/org.mitk.gui.qt.pharmacokinetics.curvedescriptor/src/internal/PerfusionCurveDescriptionParameterView.cpp
+++ b/Plugins/org.mitk.gui.qt.pharmacokinetics.curvedescriptor/src/internal/PerfusionCurveDescriptionParameterView.cpp
@@ -1,220 +1,220 @@
 /*===================================================================
 
 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 <QMessageBox>
 #include <QThreadPool>
 
 #include "mitkWorkbenchUtil.h"
 
 #include "PerfusionCurveDescriptionParameterView.h"
 #include "QmitkDescriptionParameterBackgroundJob.h"
 #include "mitkAreaUnderTheCurveDescriptionParameter.h"
 #include "mitkAreaUnderFirstMomentDescriptionParameter.h"
 #include "mitkMeanResidenceTimeDescriptionParameter.h"
 #include "mitkTimeToPeakCurveDescriptionParameter.h"
 #include "mitkMaximumCurveDescriptionParameter.h"
 #include "mitkPixelBasedDescriptionParameterImageGenerator.h"
 #include "mitkCurveParameterFunctor.h"
 #include "mitkExtractTimeGrid.h"
 
 #include <iostream>
 
 const std::string PerfusionCurveDescriptionParameterView::VIEW_ID =
   "org.mitk.gui.qt.pharmacokinetics.curvedescriptor";
 
 void PerfusionCurveDescriptionParameterView::SetFocus()
 {
   m_Controls.btnCalculateParameters->setFocus();
 }
 
 void PerfusionCurveDescriptionParameterView::CreateQtPartControl(QWidget* parent)
 {
   m_Controls.setupUi(parent);
   m_Controls.btnCalculateParameters->setEnabled(false);
 
 
 
   connect(m_Controls.btnCalculateParameters, SIGNAL(clicked()), this,
           SLOT(OnCalculateParametersButtonClicked()));
 
 
   InitParameterList();
 }
 
 
 void PerfusionCurveDescriptionParameterView::OnSelectionChanged(
   berry::IWorkbenchPart::Pointer /*source*/, const QList<mitk::DataNode::Pointer>& /*nodes*/)
 {
 
   m_Controls.btnCalculateParameters->setEnabled(false);
 
 
 
   QList<mitk::DataNode::Pointer> dataNodes = this->GetDataManagerSelection();
 
   if (dataNodes.empty())
   {
-    m_selectedNode = NULL;
-    m_selectedImage = NULL;
+    m_selectedNode = nullptr;
+    m_selectedImage = nullptr;
   }
   else
   {
     m_selectedNode = dataNodes[0];
     m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
   }
 
   m_Controls.lableSelectedImage->setText("No series selected.");
 
   if (m_selectedImage.IsNotNull())
   {
     if (m_selectedImage->GetTimeGeometry()->CountTimeSteps() > 1)
     {
       m_Controls.btnCalculateParameters->setEnabled(true);
       m_Controls.lableSelectedImage->setText((this->m_selectedNode->GetName()).c_str());
     }
     else
     {
       this->OnJobStatusChanged("Cannot compute parameters. Selected image must have multiple time steps.");
     }
   }
   else if (m_selectedNode.IsNotNull())
   {
     this->OnJobStatusChanged("Cannot compute parameters. Selected node is not an image.");
   }
   else
   {
     this->OnJobStatusChanged("Cannot compute parameters. No node selected.");
   }
 }
 
 PerfusionCurveDescriptionParameterView::PerfusionCurveDescriptionParameterView()
 {
-  m_selectedNode = NULL;
-  m_selectedImage = NULL;
-  m_selectedMask = NULL;
+  m_selectedNode = nullptr;
+  m_selectedImage = nullptr;
+  m_selectedMask = nullptr;
 }
 
 void PerfusionCurveDescriptionParameterView::InitParameterList()
 {
   m_ParameterMap.clear();
 
   mitk::CurveDescriptionParameterBase::Pointer parameterFunction =
     mitk::AreaUnderTheCurveDescriptionParameter::New().GetPointer();
   m_ParameterMap.insert(std::make_pair(ParameterNameType("AUC"), parameterFunction));
   parameterFunction = mitk::AreaUnderFirstMomentDescriptionParameter::New().GetPointer();
   m_ParameterMap.insert(std::make_pair(ParameterNameType("AUMC"), parameterFunction));
   parameterFunction = mitk::MeanResidenceTimeDescriptionParameter::New().GetPointer();
   m_ParameterMap.insert(std::make_pair(ParameterNameType("MRT"), parameterFunction));
   parameterFunction = mitk::MaximumCurveDescriptionParameter::New().GetPointer();
   m_ParameterMap.insert(std::make_pair(ParameterNameType("Maximum"), parameterFunction));
   parameterFunction = mitk::TimeToPeakCurveDescriptionParameter::New().GetPointer();
   m_ParameterMap.insert(std::make_pair(ParameterNameType("TimeToPeak"), parameterFunction));
 
   for (ParameterMapType::const_iterator pos = m_ParameterMap.begin(); pos != m_ParameterMap.end();
        ++pos)
   {
     QListWidgetItem* item = new QListWidgetItem(QString::fromStdString(pos->first),
         this->m_Controls.parameterlist);
     item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
     item->setCheckState(Qt::Unchecked);
   }
 };
 
 void PerfusionCurveDescriptionParameterView::ConfigureFunctor(mitk::CurveParameterFunctor* functor)
 const
 {
   functor->SetGrid(mitk::ExtractTimeGrid(m_selectedImage));
 
   for (int pos = 0; pos < this->m_Controls.parameterlist->count(); ++pos)
   {
     QListWidgetItem* item = this->m_Controls.parameterlist->item(pos);
     mitk::CurveDescriptionParameterBase::Pointer parameterFunction = m_ParameterMap.at(
           item->text().toStdString());
 
     if (item->checkState() == Qt::Checked)
     {
       functor->RegisterDescriptionParameter(item->text().toStdString(), parameterFunction);
     }
   }
 }
 
 void PerfusionCurveDescriptionParameterView::OnCalculateParametersButtonClicked()
 {
   mitk::PixelBasedDescriptionParameterImageGenerator::Pointer generator =
     mitk::PixelBasedDescriptionParameterImageGenerator::New();
   mitk::CurveParameterFunctor::Pointer functor = mitk::CurveParameterFunctor::New();
   this->ConfigureFunctor(functor);
 
 
 
   generator->SetFunctor(functor);
   generator->SetDynamicImage(m_selectedImage);
   generator->SetMask(m_selectedMask);
 
 
   /////////////////////////
   //create job and put it into the thread pool
   DescriptionParameterBackgroundJob* pJob = new DescriptionParameterBackgroundJob(generator,
       this->m_selectedNode);
   pJob->setAutoDelete(true);
 
   connect(pJob, SIGNAL(Error(QString)), this, SLOT(OnJobError(QString)));
   connect(pJob, SIGNAL(Finished()), this, SLOT(OnJobFinished()));
   connect(pJob, SIGNAL(ResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType,
                        const DescriptionParameterBackgroundJob*)), this,
           SLOT(OnJobResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType,
                                         const DescriptionParameterBackgroundJob*)), Qt::BlockingQueuedConnection);
 
   connect(pJob, SIGNAL(JobProgress(double)), this, SLOT(OnJobProgress(double)));
   connect(pJob, SIGNAL(JobStatusChanged(QString)), this, SLOT(OnJobStatusChanged(QString)));
 
   QThreadPool* threadPool = QThreadPool::globalInstance();
   threadPool->start(pJob);
 }
 
 void PerfusionCurveDescriptionParameterView::OnJobFinished()
 {
   this->m_Controls.infoBox->append(QString("Fitting finished"));
 };
 
 void PerfusionCurveDescriptionParameterView::OnJobError(QString err)
 {
   MITK_ERROR << err.toStdString().c_str();
   m_Controls.infoBox->append(QString("<font color='red'><b>") + err + QString("</b></font>"));
 };
 
 void PerfusionCurveDescriptionParameterView::OnJobResultsAreAvailable(
   mitk::modelFit::ModelFitResultNodeVectorType results, const DescriptionParameterBackgroundJob* pJob)
 {
   for (auto image : results)
   {
     this->GetDataStorage()->Add(image, pJob->GetParentNode());
   }
 };
 
 void PerfusionCurveDescriptionParameterView::OnJobProgress(double progress)
 {
   this->m_Controls.progressBar->setValue(100 * progress);
   QString report = QString("Progress. ") + QString::number(progress);
   this->m_Controls.infoBox->append(report);
 };
 
 void PerfusionCurveDescriptionParameterView::OnJobStatusChanged(QString info)
 {
   this->m_Controls.infoBox->append(info);
   MITK_INFO << info.toStdString().c_str();
 }
 
diff --git a/Plugins/org.mitk.gui.qt.pharmacokinetics.mri/src/internal/MRPerfusionView.cpp b/Plugins/org.mitk.gui.qt.pharmacokinetics.mri/src/internal/MRPerfusionView.cpp
index ee12fad365..89e8288c8c 100644
--- a/Plugins/org.mitk.gui.qt.pharmacokinetics.mri/src/internal/MRPerfusionView.cpp
+++ b/Plugins/org.mitk.gui.qt.pharmacokinetics.mri/src/internal/MRPerfusionView.cpp
@@ -1,1398 +1,1398 @@
 /*===================================================================
 
 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 "MRPerfusionView.h"
 
 #include "boost/tokenizer.hpp"
 #include "boost/math/constants/constants.hpp"
 #include <iostream>
 
 #include "mitkWorkbenchUtil.h"
 
 #include "mitkAterialInputFunctionGenerator.h"
 #include "mitkConcentrationCurveGenerator.h"
 
 #include <mitkDescriptivePharmacokineticBrixModelFactory.h>
 #include <mitkDescriptivePharmacokineticBrixModelParameterizer.h>
 #include <mitkDescriptivePharmacokineticBrixModelValueBasedParameterizer.h>
 #include "mitkThreeStepLinearModelFactory.h"
 #include "mitkThreeStepLinearModelParameterizer.h"
 #include <mitkExtendedToftsModelFactory.h>
 #include <mitkExtendedToftsModelParameterizer.h>
 #include <mitkStandardToftsModelFactory.h>
 #include <mitkStandardToftsModelParameterizer.h>
 #include "mitkTwoCompartmentExchangeModelFactory.h"
 #include "mitkTwoCompartmentExchangeModelParameterizer.h"
 #include "mitkNumericTwoCompartmentExchangeModelFactory.h"
 #include "mitkNumericTwoCompartmentExchangeModelParameterizer.h"
 #include <mitkInitialParameterizationDelegateBase.h>
 
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkPixelBasedParameterFitImageGenerator.h>
 #include <mitkROIBasedParameterFitImageGenerator.h>
 #include <mitkLevenbergMarquardtModelFitFunctor.h>
 #include <mitkSumOfSquaredDifferencesFitCostFunction.h>
 #include <mitkNormalizedSumOfSquaredDifferencesFitCostFunction.h>
 #include <mitkSimpleBarrierConstraintChecker.h>
 #include <mitkModelFitResultHelper.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkMaskedDynamicImageStatisticsGenerator.h>
 #include <mitkExtractTimeGrid.h>
 
 #include <QMessageBox>
 #include <QThreadPool>
 #include <QFileDialog>
 #include <QmitkDataStorageComboBox.h>
 
 
 // Includes for image casting between ITK and MITK
 #include <mitkImage.h>
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 #include <itkImage.h>
 #include <itkImageRegionIterator.h>
 
 //#include <mitkDICOMPMPropertyHelper.h>
 //#include <mitkDICOMQIPropertyHelper.h>
 
 
 const std::string MRPerfusionView::VIEW_ID = "org.mitk.gui.qt.pharmacokinetics.mri";
 
 inline double convertToDouble(const std::string& data)
 {
   std::istringstream stepStream(data);
   stepStream.imbue(std::locale("C"));
   double value = 0.0;
 
   if (!(stepStream >> value) || !(stepStream.eof()))
   {
     mitkThrow() << "Cannot convert string to double. String: " << data;
   }
   return value;
 }
 
 void MRPerfusionView::SetFocus()
 {
   m_Controls.btnModelling->setFocus();
 }
 
 void MRPerfusionView::CreateQtPartControl(QWidget* parent)
 {
   m_Controls.setupUi(parent);
 
   m_Controls.btnModelling->setEnabled(false);
   m_Controls.errorMessageLabel->hide();
 
   this->InitModelComboBox();
 
   connect(m_Controls.btnModelling, SIGNAL(clicked()), this, SLOT(OnModellingButtonClicked()));
 
   connect(m_Controls.comboModel, SIGNAL(currentIndexChanged(int)), this, SLOT(OnModellSet(int)));
   connect(m_Controls.radioPixelBased, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
 
   //AIF setting
   m_Controls.groupAIF->hide();
   m_Controls.btnAIFFile->setEnabled(false);
   m_Controls.btnAIFFile->setEnabled(false);
   m_Controls.radioAIFImage->setChecked(true);
   m_Controls.comboAIFMask->SetDataStorage(this->GetDataStorage());
   m_Controls.comboAIFMask->SetPredicate(m_IsMaskPredicate);
   m_Controls.comboAIFMask->setVisible(true);
   m_Controls.comboAIFMask->setEnabled(true);
   m_Controls.comboAIFImage->SetDataStorage(this->GetDataStorage());
   m_Controls.comboAIFImage->SetPredicate(m_IsNoMaskImagePredicate);
   m_Controls.comboAIFImage->setEnabled(false);
   m_Controls.checkDedicatedAIFImage->setEnabled(true);
   m_Controls.HCLSpinBox->setValue(mitk::AterialInputFunctionGenerator::DEFAULT_HEMATOCRIT_LEVEL);
 
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.comboAIFMask, SLOT(setVisible(bool)));
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.labelAIFMask, SLOT(setVisible(bool)));
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.checkDedicatedAIFImage, SLOT(setVisible(bool)));
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.comboAIFMask, SLOT(setEnabled(bool)));
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.checkDedicatedAIFImage, SLOT(setEnabled(bool)));
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.checkDedicatedAIFImage, SLOT(setVisible(bool)));
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.comboAIFImage, SLOT(setVisible(bool)));
   connect(m_Controls.checkDedicatedAIFImage, SIGNAL(toggled(bool)), m_Controls.comboAIFImage, SLOT(setEnabled(bool)));
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
   connect(m_Controls.radioAIFFile, SIGNAL(toggled(bool)), m_Controls.btnAIFFile, SLOT(setEnabled(bool)));
   connect(m_Controls.radioAIFFile, SIGNAL(toggled(bool)), m_Controls.aifFilePath, SLOT(setEnabled(bool)));
   connect(m_Controls.radioAIFFile, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
 
   connect(m_Controls.btnAIFFile, SIGNAL(clicked()), this, SLOT(LoadAIFfromFile()));
 
   //Brix setting
   m_Controls.groupDescBrix->hide();
   connect(m_Controls.injectiontime, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
 
   //Num2CX setting
   m_Controls.groupNum2CXM->hide();
   connect(m_Controls.odeStepSize, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
 
   //Model fit configuration
   m_Controls.groupBox_FitConfiguration->hide();
 
   m_Controls.checkBox_Constraints->setEnabled(false);
   m_Controls.constraintManager->setEnabled(false);
   m_Controls.initialValuesManager->setEnabled(false);
   m_Controls.initialValuesManager->setDataStorage(this->GetDataStorage());
 
   connect(m_Controls.radioButton_StartParameters, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
   connect(m_Controls.checkBox_Constraints, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
   connect(m_Controls.initialValuesManager, SIGNAL(initialValuesChanged(void)), this, SLOT(UpdateGUIControls()));
 
 
   connect(m_Controls.radioButton_StartParameters, SIGNAL(toggled(bool)), m_Controls.initialValuesManager, SLOT(setEnabled(bool)));
   connect(m_Controls.checkBox_Constraints, SIGNAL(toggled(bool)), m_Controls.constraintManager, SLOT(setEnabled(bool)));
   connect(m_Controls.checkBox_Constraints, SIGNAL(toggled(bool)), m_Controls.constraintManager, SLOT(setVisible(bool)));
 
   //Concentration
   m_Controls.groupConcentration->hide();
   m_Controls.groupBoxTurboFlash->hide();
   m_Controls.radioButtonNoConversion->setChecked(true);
   m_Controls.factorSpinBox->setEnabled(false);
   m_Controls.groupBox_viaT1Map->hide();
 
   connect(m_Controls.radioButtonTurboFlash, SIGNAL(toggled(bool)), m_Controls.groupBoxTurboFlash, SLOT(setVisible(bool)));
   connect(m_Controls.radioButtonTurboFlash, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
   connect(m_Controls.relaxationtime, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
   connect(m_Controls.recoverytime, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
   connect(m_Controls.relaxivity, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
 
   connect(m_Controls.radioButton_absoluteEnhancement, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
   connect(m_Controls.radioButton_relativeEnchancement, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
   connect(m_Controls.radioButton_absoluteEnhancement, SIGNAL(toggled(bool)), m_Controls.factorSpinBox, SLOT(setEnabled(bool)));
   connect(m_Controls.radioButton_relativeEnchancement, SIGNAL(toggled(bool)), m_Controls.factorSpinBox, SLOT(setEnabled(bool)));
   connect(m_Controls.factorSpinBox, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
 
   connect(m_Controls.radioButtonUsingT1, SIGNAL(toggled(bool)), m_Controls.groupBox_viaT1Map, SLOT(setVisible(bool)));
   connect(m_Controls.radioButtonUsingT1, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
   connect(m_Controls.FlipangleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
   connect(m_Controls.RelaxivitySpinBox, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
   connect(m_Controls.TRSpinBox, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
   m_Controls.ComboT1Map->SetDataStorage(this->GetDataStorage());
   m_Controls.ComboT1Map->SetPredicate(m_IsNoMaskImagePredicate);
   m_Controls.ComboT1Map->setEnabled(false);
   connect(m_Controls.radioButtonUsingT1, SIGNAL(toggled(bool)), m_Controls.ComboT1Map, SLOT(setEnabled(bool)));
 
   UpdateGUIControls();
 }
 
 bool MRPerfusionView::IsTurboFlashSequenceFlag() const
 {
   return this->m_Controls.radioButtonTurboFlash->isChecked();
 };
 
 
 
 void MRPerfusionView::UpdateGUIControls()
 {
   m_Controls.lineFitName->setPlaceholderText(QString::fromStdString(this->GetDefaultFitName()));
   m_Controls.lineFitName->setEnabled(!m_FittingInProgress);
 
   m_Controls.checkBox_Constraints->setEnabled(m_modelConstraints.IsNotNull());
 
   bool isDescBrixFactory = dynamic_cast<mitk::DescriptivePharmacokineticBrixModelFactory*>
-                           (m_selectedModelFactory.GetPointer()) != NULL;
+                           (m_selectedModelFactory.GetPointer()) != nullptr;
   bool isToftsFactory = dynamic_cast<mitk::StandardToftsModelFactory*>
-                        (m_selectedModelFactory.GetPointer()) != NULL ||
+                        (m_selectedModelFactory.GetPointer()) != nullptr ||
                          dynamic_cast<mitk::ExtendedToftsModelFactory*>
-                                  (m_selectedModelFactory.GetPointer()) != NULL;
+                                  (m_selectedModelFactory.GetPointer()) != nullptr;
   bool is2CXMFactory = dynamic_cast<mitk::TwoCompartmentExchangeModelFactory*>
-                       (m_selectedModelFactory.GetPointer()) != NULL ||
+                       (m_selectedModelFactory.GetPointer()) != nullptr ||
                        dynamic_cast<mitk::NumericTwoCompartmentExchangeModelFactory*>
-                       (m_selectedModelFactory.GetPointer()) != NULL;
+                       (m_selectedModelFactory.GetPointer()) != nullptr;
 
   bool isNum2CXMFactory = dynamic_cast<mitk::NumericTwoCompartmentExchangeModelFactory*>
-                          (m_selectedModelFactory.GetPointer()) != NULL;
+                          (m_selectedModelFactory.GetPointer()) != nullptr;
 
   m_Controls.groupAIF->setVisible(isToftsFactory || is2CXMFactory);
   m_Controls.groupDescBrix->setVisible(isDescBrixFactory);
   m_Controls.groupNum2CXM->setVisible(isNum2CXMFactory);
   m_Controls.groupConcentration->setVisible(isToftsFactory || is2CXMFactory);
 
   m_Controls.groupBox_FitConfiguration->setVisible(m_selectedModelFactory);
 
   m_Controls.groupBox->setEnabled(!m_FittingInProgress);
   m_Controls.comboModel->setEnabled(!m_FittingInProgress);
   m_Controls.groupAIF->setEnabled(!m_FittingInProgress);
   m_Controls.groupDescBrix->setEnabled(!m_FittingInProgress);
   m_Controls.groupNum2CXM->setEnabled(!m_FittingInProgress);
   m_Controls.groupConcentration->setEnabled(!m_FittingInProgress);
   m_Controls.groupBox_FitConfiguration->setEnabled(!m_FittingInProgress);
 
   m_Controls.radioROIbased->setEnabled(m_selectedMask.IsNotNull());
 
   m_Controls.btnModelling->setEnabled(m_selectedImage.IsNotNull()
                                       && m_selectedModelFactory.IsNotNull() && !m_FittingInProgress && CheckModelSettings());
 }
 
 void MRPerfusionView::OnModellSet(int index)
 {
-  m_selectedModelFactory = NULL;
+  m_selectedModelFactory = nullptr;
 
   if (index > 0)
   {
     if (static_cast<ModelFactoryStackType::size_type>(index) <= m_FactoryStack.size() )
     {
         m_selectedModelFactory = m_FactoryStack[index - 1];
     }
     else
     {
         MITK_WARN << "Invalid model index. Index outside of the factory stack. Factory stack size: "<< m_FactoryStack.size() << "; invalid index: "<< index;
     }
   }
 
   if (m_selectedModelFactory)
   {
     this->m_modelConstraints = dynamic_cast<mitk::SimpleBarrierConstraintChecker*>
                                (m_selectedModelFactory->CreateDefaultConstraints().GetPointer());
 
     m_Controls.initialValuesManager->setInitialValues(m_selectedModelFactory->GetParameterNames(),
         m_selectedModelFactory->GetDefaultInitialParameterization());
 
     if (this->m_modelConstraints.IsNull())
     {
       this->m_modelConstraints = mitk::SimpleBarrierConstraintChecker::New();
     }
 
     m_Controls.constraintManager->setChecker(this->m_modelConstraints,
         this->m_selectedModelFactory->GetParameterNames());
 
   }
 
   UpdateGUIControls();
 }
 
 std::string MRPerfusionView::GetFitName() const
 {
   std::string fitName = m_Controls.lineFitName->text().toStdString();
   if (fitName.empty())
   {
     fitName = m_Controls.lineFitName->placeholderText().toStdString();
   }
   return fitName;
 }
 
 std::string MRPerfusionView::GetDefaultFitName() const
 {
     std::string defaultName = "undefined model";
     
     if (this->m_selectedModelFactory.IsNotNull())
     {
         defaultName = this->m_selectedModelFactory->GetClassID();
     }
 
     if (this->m_Controls.radioPixelBased->isChecked())
     {
         defaultName += "_pixel";
     }
     else
     {
         defaultName += "_roi";
     }
 
     return defaultName;
 }
 
 void MRPerfusionView::OnModellingButtonClicked()
 {
   //check if all static parameters set
   if (m_selectedModelFactory.IsNotNull() && CheckModelSettings())
   {
     m_HasGeneratedNewInput = false;
     m_HasGeneratedNewInputAIF = false;
 
-    mitk::ParameterFitImageGeneratorBase::Pointer generator = NULL;
-    mitk::modelFit::ModelFitInfo::Pointer fitSession = NULL;
+    mitk::ParameterFitImageGeneratorBase::Pointer generator = nullptr;
+    mitk::modelFit::ModelFitInfo::Pointer fitSession = nullptr;
 
     bool isDescBrixFactory = dynamic_cast<mitk::DescriptivePharmacokineticBrixModelFactory*>
-                             (m_selectedModelFactory.GetPointer()) != NULL;
+                             (m_selectedModelFactory.GetPointer()) != nullptr;
     bool is3LinearFactory = dynamic_cast<mitk::ThreeStepLinearModelFactory*>
-                             (m_selectedModelFactory.GetPointer()) != NULL;
+                             (m_selectedModelFactory.GetPointer()) != nullptr;
     bool isExtToftsFactory = dynamic_cast<mitk::ExtendedToftsModelFactory*>
-                          (m_selectedModelFactory.GetPointer()) != NULL;
+                          (m_selectedModelFactory.GetPointer()) != nullptr;
     bool isStanToftsFactory = dynamic_cast<mitk::StandardToftsModelFactory*>
-                          (m_selectedModelFactory.GetPointer()) != NULL;
+                          (m_selectedModelFactory.GetPointer()) != nullptr;
     bool is2CXMFactory = dynamic_cast<mitk::TwoCompartmentExchangeModelFactory*>
-                         (m_selectedModelFactory.GetPointer()) != NULL;
+                         (m_selectedModelFactory.GetPointer()) != nullptr;
     bool isNum2CXMFactory = dynamic_cast<mitk::NumericTwoCompartmentExchangeModelFactory*>
-                            (m_selectedModelFactory.GetPointer()) != NULL;
+                            (m_selectedModelFactory.GetPointer()) != nullptr;
 
     if (isDescBrixFactory)
     {
       if (this->m_Controls.radioPixelBased->isChecked())
       {
         GenerateDescriptiveBrixModel_PixelBased(fitSession, generator);
       }
       else
       {
         GenerateDescriptiveBrixModel_ROIBased(fitSession, generator);
       }
     }
     else if (is3LinearFactory)
     {
         if (this->m_Controls.radioPixelBased->isChecked())
         {
           Generate3StepLinearModelFit_PixelBased(fitSession, generator);
         }
         else
         {
           Generate3StepLinearModelFit_ROIBased(fitSession, generator);
         }
     }
     else if (isStanToftsFactory)
     {
       if (this->m_Controls.radioPixelBased->isChecked())
       {
         GenerateAIFbasedModelFit_PixelBased<mitk::StandardToftsModelParameterizer>(fitSession, generator);
       }
       else
       {
         GenerateAIFbasedModelFit_ROIBased<mitk::StandardToftsModelParameterizer>(fitSession, generator);
       }
     }
     else if (isExtToftsFactory)
     {
       if (this->m_Controls.radioPixelBased->isChecked())
       {
         GenerateAIFbasedModelFit_PixelBased<mitk::ExtendedToftsModelParameterizer>(fitSession, generator);
       }
       else
       {
         GenerateAIFbasedModelFit_ROIBased<mitk::ExtendedToftsModelParameterizer>(fitSession, generator);
       }
     }
     else if (is2CXMFactory)
     {
       if (this->m_Controls.radioPixelBased->isChecked())
       {
         GenerateAIFbasedModelFit_PixelBased<mitk::TwoCompartmentExchangeModelParameterizer>(fitSession, generator);
       }
       else
       {
         GenerateAIFbasedModelFit_ROIBased<mitk::TwoCompartmentExchangeModelParameterizer>(fitSession, generator);
       }
     }
     else if (isNum2CXMFactory)
     {
       if (this->m_Controls.radioPixelBased->isChecked())
       {
         GenerateAIFbasedModelFit_PixelBased<mitk::NumericTwoCompartmentExchangeModelParameterizer>(fitSession,
             generator);
       }
       else
       {
         GenerateAIFbasedModelFit_ROIBased<mitk::NumericTwoCompartmentExchangeModelParameterizer>(fitSession,
             generator);
       }
     }
 
     //add other models with else if
 
     if (generator.IsNotNull() && fitSession.IsNotNull())
     {
       m_FittingInProgress = true;
       UpdateGUIControls();
       DoFit(fitSession, generator);
     }
     else
     {
       QMessageBox box;
       box.setText("Fitting error!");
       box.setInformativeText("Could not establish fitting job. Error when setting ab generator, model parameterizer or session info.");
       box.setStandardButtons(QMessageBox::Ok);
       box.setDefaultButton(QMessageBox::Ok);
       box.setIcon(QMessageBox::Warning);
       box.exec();
     }
 
   }
   else
   {
     QMessageBox box;
     box.setText("Static parameters for model are not set!");
     box.setInformativeText("Some static parameters, that are needed for calculation are not set and equal to zero. Modeling not possible");
     box.setStandardButtons(QMessageBox::Ok);
     box.setDefaultButton(QMessageBox::Ok);
     box.setIcon(QMessageBox::Warning);
     box.exec();
   }
 }
 
 
 void MRPerfusionView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
     const QList<mitk::DataNode::Pointer>& selectedNodes)
 {
-  m_selectedMaskNode = NULL;
-  m_selectedMask = NULL;
+  m_selectedMaskNode = nullptr;
+  m_selectedMask = nullptr;
 
   m_Controls.errorMessageLabel->setText("");
   m_Controls.masklabel->setText("No (valid) mask selected.");
   m_Controls.timeserieslabel->setText("No (valid) series selected.");
 
   QList<mitk::DataNode::Pointer> nodes = selectedNodes;
 
   if (nodes.size() > 0 && this->m_IsNoMaskImagePredicate->CheckNode(nodes.front()))
   {
     this->m_selectedNode = nodes.front();
     auto selectedImage = dynamic_cast<mitk::Image*>(this->m_selectedNode->GetData());
     m_Controls.timeserieslabel->setText((this->m_selectedNode->GetName()).c_str());
 
     if (selectedImage != this->m_selectedImage)
     {
       if (selectedImage)
       {
         this->m_Controls.initialValuesManager->setReferenceImageGeometry(selectedImage->GetGeometry());
       }
       else
       {
         this->m_Controls.initialValuesManager->setReferenceImageGeometry(nullptr);
       }
     }
     this->m_selectedImage = selectedImage;
     nodes.pop_front();
   }
   else
   {
-    this->m_selectedNode = NULL;
-    this->m_selectedImage = NULL;
+    this->m_selectedNode = nullptr;
+    this->m_selectedImage = nullptr;
     this->m_Controls.initialValuesManager->setReferenceImageGeometry(nullptr);
   }
 
   if (nodes.size() > 0 && this->m_IsMaskPredicate->CheckNode(nodes.front()))
   {
       this->m_selectedMaskNode = nodes.front();
       this->m_selectedMask = dynamic_cast<mitk::Image*>(this->m_selectedMaskNode->GetData());
 
       if (this->m_selectedMask->GetTimeSteps() > 1)
       {
         MITK_INFO <<
                   "Selected mask has multiple timesteps. Only use first timestep to mask model fit. Mask name: " <<
                   m_selectedMaskNode->GetName();
         mitk::ImageTimeSelector::Pointer maskedImageTimeSelector = mitk::ImageTimeSelector::New();
         maskedImageTimeSelector->SetInput(this->m_selectedMask);
         maskedImageTimeSelector->SetTimeNr(0);
         maskedImageTimeSelector->UpdateLargestPossibleRegion();
         this->m_selectedMask = maskedImageTimeSelector->GetOutput();
       }
 
       m_Controls.masklabel->setText((this->m_selectedMaskNode->GetName()).c_str());
   }
 
   if (m_selectedMask.IsNull())
   {
     this->m_Controls.radioPixelBased->setChecked(true);
   }
 
   m_Controls.errorMessageLabel->show();
 
   UpdateGUIControls();
 }
 
 bool MRPerfusionView::CheckModelSettings() const
 {
   bool ok = true;
 
   //check wether any model is set at all. Otherwise exit with false
   if (m_selectedModelFactory.IsNotNull())
   {
     bool isDescBrixFactory = dynamic_cast<mitk::DescriptivePharmacokineticBrixModelFactory*>
-                             (m_selectedModelFactory.GetPointer()) != NULL;
+                             (m_selectedModelFactory.GetPointer()) != nullptr;
     bool is3LinearFactory = dynamic_cast<mitk::ThreeStepLinearModelFactory*>
-                             (m_selectedModelFactory.GetPointer()) != NULL;
+                             (m_selectedModelFactory.GetPointer()) != nullptr;
     bool isToftsFactory = dynamic_cast<mitk::StandardToftsModelFactory*>
-                          (m_selectedModelFactory.GetPointer()) != NULL||
+                          (m_selectedModelFactory.GetPointer()) != nullptr||
                           dynamic_cast<mitk::ExtendedToftsModelFactory*>
-                          (m_selectedModelFactory.GetPointer()) != NULL;
+                          (m_selectedModelFactory.GetPointer()) != nullptr;
     bool is2CXMFactory = dynamic_cast<mitk::TwoCompartmentExchangeModelFactory*>
-                         (m_selectedModelFactory.GetPointer()) != NULL;
+                         (m_selectedModelFactory.GetPointer()) != nullptr;
     bool isNum2CXMFactory = dynamic_cast<mitk::NumericTwoCompartmentExchangeModelFactory*>
-                            (m_selectedModelFactory.GetPointer()) != NULL;
+                            (m_selectedModelFactory.GetPointer()) != nullptr;
 
     if (isDescBrixFactory)
     {
       //if all static parameters for this model are set, exit with true, Otherwise exit with false
       ok = m_Controls.injectiontime->value() > 0;
     }
     else if (is3LinearFactory)
     {
         if (this->m_Controls.radioButtonTurboFlash->isChecked())
         {
           ok = ok && (m_Controls.recoverytime->value() > 0);
           ok = ok && (m_Controls.relaxationtime->value() > 0);
           ok = ok && (m_Controls.relaxivity->value() > 0);
           ok = ok && (m_Controls.AifRecoverytime->value() > 0);
 
         }
         else if (this->m_Controls.radioButton_absoluteEnhancement->isChecked()
                  || this->m_Controls.radioButton_relativeEnchancement->isChecked())
         {
           ok = ok && (m_Controls.factorSpinBox->value() > 0);
         }
         else if (this->m_Controls.radioButtonUsingT1->isChecked())
         {
           ok = ok && (m_Controls.FlipangleSpinBox->value() > 0);
           ok = ok && (m_Controls.TRSpinBox->value() > 0);
           ok = ok && (m_Controls.RelaxivitySpinBox->value() > 0);
           ok = ok && (m_Controls.ComboT1Map->GetSelectedNode().IsNotNull());
 
         }
         else
         {
           ok = false;
         }
     }
     else if (isToftsFactory || is2CXMFactory || isNum2CXMFactory)
     {
       if (this->m_Controls.radioAIFImage->isChecked())
       {
         ok = ok && m_Controls.comboAIFMask->GetSelectedNode().IsNotNull();
 
         if (this->m_Controls.checkDedicatedAIFImage->isChecked())
         {
           ok = ok && m_Controls.comboAIFImage->GetSelectedNode().IsNotNull();
         }
       }
       else if (this->m_Controls.radioAIFFile->isChecked())
       {
         ok = ok && (this->AIFinputGrid.size() != 0) && (this->AIFinputFunction.size() != 0);
       }
       else
       {
         ok = false;
       }
 
       if (this->m_Controls.radioButtonTurboFlash->isChecked())
       {
         ok = ok && (m_Controls.recoverytime->value() > 0);
         ok = ok && (m_Controls.relaxationtime->value() > 0);
         ok = ok && (m_Controls.relaxivity->value() > 0);
         ok = ok && (m_Controls.AifRecoverytime->value() > 0);
 
       }
       else if (this->m_Controls.radioButton_absoluteEnhancement->isChecked()
                || this->m_Controls.radioButton_relativeEnchancement->isChecked())
       {
         ok = ok && (m_Controls.factorSpinBox->value() > 0);
       }
       else if (this->m_Controls.radioButtonUsingT1->isChecked())
       {
         ok = ok && (m_Controls.FlipangleSpinBox->value() > 0);
         ok = ok && (m_Controls.TRSpinBox->value() > 0);
         ok = ok && (m_Controls.RelaxivitySpinBox->value() > 0);
         ok = ok && (m_Controls.ComboT1Map->GetSelectedNode().IsNotNull());
 
       }
       else
       {
         ok = false;
       }
 
       if (isNum2CXMFactory)
       {
         ok = ok && (this->m_Controls.odeStepSize->value() > 0);
       }
 
     }
     //add other models as else if and check wether all needed static parameters are set
     else
     {
       ok = false;
     }
 
     if (this->m_Controls.radioButton_StartParameters->isChecked() && !this->m_Controls.initialValuesManager->hasValidInitialValues())
     {
       std::string warning = "Warning. Invalid start parameters. At least one parameter as an invalid image setting as source.";
       MITK_ERROR << warning;
       m_Controls.infoBox->append(QString("<font color='red'><b>") + QString::fromStdString(warning) + QString("</b></font>"));
 
       ok = false;
     };
   }
   else
   {
     ok = false;
   }
 
   return ok;
 }
 
 void MRPerfusionView::ConfigureInitialParametersOfParameterizer(mitk::ModelParameterizerBase*
     parameterizer) const
 {
   if (m_Controls.radioButton_StartParameters->isChecked())
   {
     //use user defined initial parameters
     mitk::InitialParameterizationDelegateBase::Pointer paramDelegate = m_Controls.initialValuesManager->getInitialParametrizationDelegate();
     parameterizer->SetInitialParameterizationDelegate(paramDelegate);
   }
 }
 
 void MRPerfusionView::GenerateDescriptiveBrixModel_PixelBased(mitk::modelFit::ModelFitInfo::Pointer&
     modelFitInfo, mitk::ParameterFitImageGeneratorBase::Pointer& generator)
 {
   mitk::PixelBasedParameterFitImageGenerator::Pointer fitGenerator =
     mitk::PixelBasedParameterFitImageGenerator::New();
 
   mitk::DescriptivePharmacokineticBrixModelParameterizer::Pointer modelParameterizer =
     mitk::DescriptivePharmacokineticBrixModelParameterizer::New();
 
   //Model configuration (static parameters) can be done now
   modelParameterizer->SetTau(m_Controls.injectiontime->value());
 
   mitk::ImageTimeSelector::Pointer imageTimeSelector =	mitk::ImageTimeSelector::New();
   imageTimeSelector->SetInput(this->m_selectedImage);
   imageTimeSelector->SetTimeNr(0);
   imageTimeSelector->UpdateLargestPossibleRegion();
 
   mitk::DescriptivePharmacokineticBrixModelParameterizer::BaseImageType::Pointer baseImage;
   mitk::CastToItkImage(imageTimeSelector->GetOutput(), baseImage);
 
   modelParameterizer->SetBaseImage(baseImage);
   this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
 
   //Specify fitting strategy and criterion parameters
   mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
 
   //Parametrize fit generator
   fitGenerator->SetModelParameterizer(modelParameterizer);
   std::string roiUID = "";
 
   if (m_selectedMask.IsNotNull())
   {
     fitGenerator->SetMask(m_selectedMask);
     roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
   }
 
   fitGenerator->SetDynamicImage(m_selectedImage);
   fitGenerator->SetFitFunctor(fitFunctor);
 
   generator = fitGenerator.GetPointer();
 
   //Create model info
   modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
     m_selectedNode->GetData(), mitk::ModelFitConstants::FIT_TYPE_VALUE_PIXELBASED(), this->GetFitName(), roiUID);
 }
 
 void MRPerfusionView::GenerateDescriptiveBrixModel_ROIBased(mitk::modelFit::ModelFitInfo::Pointer&
     modelFitInfo, mitk::ParameterFitImageGeneratorBase::Pointer& generator)
 {
   if (m_selectedMask.IsNull())
   {
     return;
   }
 
   mitk::ROIBasedParameterFitImageGenerator::Pointer fitGenerator =
     mitk::ROIBasedParameterFitImageGenerator::New();
 
   mitk::DescriptivePharmacokineticBrixModelValueBasedParameterizer::Pointer modelParameterizer =
     mitk::DescriptivePharmacokineticBrixModelValueBasedParameterizer::New();
 
   //Compute ROI signal
   mitk::MaskedDynamicImageStatisticsGenerator::Pointer signalGenerator =
     mitk::MaskedDynamicImageStatisticsGenerator::New();
   signalGenerator->SetMask(m_selectedMask);
   signalGenerator->SetDynamicImage(m_selectedImage);
   signalGenerator->Generate();
 
   mitk::MaskedDynamicImageStatisticsGenerator::ResultType roiSignal = signalGenerator->GetMean();
 
   //Model configuration (static parameters) can be done now
   modelParameterizer->SetTau(m_Controls.injectiontime->value());
   modelParameterizer->SetBaseValue(roiSignal[0]);
   this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
 
   //Specify fitting strategy and criterion parameters
   mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
 
   //Parametrize fit generator
   fitGenerator->SetModelParameterizer(modelParameterizer);
   fitGenerator->SetMask(m_selectedMask);
   fitGenerator->SetFitFunctor(fitFunctor);
   fitGenerator->SetSignal(roiSignal);
   fitGenerator->SetTimeGrid(mitk::ExtractTimeGrid(m_selectedImage));
 
   generator = fitGenerator.GetPointer();
 
   std::string roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
 
   //Create model info
   modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
     m_selectedNode->GetData(), mitk::ModelFitConstants::FIT_TYPE_VALUE_ROIBASED(), this->GetFitName(), roiUID);
   mitk::ScalarListLookupTable::ValueType infoSignal;
 
   for (mitk::MaskedDynamicImageStatisticsGenerator::ResultType::const_iterator pos =
          roiSignal.begin(); pos != roiSignal.end(); ++pos)
   {
     infoSignal.push_back(*pos);
   }
 
   modelFitInfo->inputData.SetTableValue("ROI", infoSignal);
 }
 
 void MRPerfusionView::Generate3StepLinearModelFit_PixelBased(mitk::modelFit::ModelFitInfo::Pointer&
     modelFitInfo, mitk::ParameterFitImageGeneratorBase::Pointer& generator)
 {
   mitk::PixelBasedParameterFitImageGenerator::Pointer fitGenerator =
     mitk::PixelBasedParameterFitImageGenerator::New();
 
   mitk::ThreeStepLinearModelParameterizer::Pointer modelParameterizer =
     mitk::ThreeStepLinearModelParameterizer::New();
 
   this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
 
   //Specify fitting strategy and criterion parameters
   mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
 
   //Parametrize fit generator
   fitGenerator->SetModelParameterizer(modelParameterizer);
   std::string roiUID = "";
 
   if (m_selectedMask.IsNotNull())
   {
     fitGenerator->SetMask(m_selectedMask);
     roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
   }
 
   fitGenerator->SetDynamicImage(m_selectedImage);
   fitGenerator->SetFitFunctor(fitFunctor);
 
   generator = fitGenerator.GetPointer();
 
   //Create model info
   modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
     m_selectedNode->GetData(), mitk::ModelFitConstants::FIT_TYPE_VALUE_PIXELBASED(), this->GetFitName(), roiUID);
 }
 
 void MRPerfusionView::Generate3StepLinearModelFit_ROIBased(mitk::modelFit::ModelFitInfo::Pointer&
     modelFitInfo, mitk::ParameterFitImageGeneratorBase::Pointer& generator)
 {
   if (m_selectedMask.IsNull())
   {
     return;
   }
 
   mitk::ROIBasedParameterFitImageGenerator::Pointer fitGenerator =
     mitk::ROIBasedParameterFitImageGenerator::New();
 
   mitk::ThreeStepLinearModelParameterizer::Pointer modelParameterizer =
     mitk::ThreeStepLinearModelParameterizer::New();
 
   //Compute ROI signal
   mitk::MaskedDynamicImageStatisticsGenerator::Pointer signalGenerator =
     mitk::MaskedDynamicImageStatisticsGenerator::New();
   signalGenerator->SetMask(m_selectedMask);
   signalGenerator->SetDynamicImage(m_selectedImage);
   signalGenerator->Generate();
 
   mitk::MaskedDynamicImageStatisticsGenerator::ResultType roiSignal = signalGenerator->GetMean();
 
   //Model configuration (static parameters) can be done now
   this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
 
   //Specify fitting strategy and criterion parameters
   mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
 
   //Parametrize fit generator
   fitGenerator->SetModelParameterizer(modelParameterizer);
   fitGenerator->SetMask(m_selectedMask);
   fitGenerator->SetFitFunctor(fitFunctor);
   fitGenerator->SetSignal(roiSignal);
   fitGenerator->SetTimeGrid(mitk::ExtractTimeGrid(m_selectedImage));
 
   generator = fitGenerator.GetPointer();
 
   std::string roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
 
   //Create model info
   modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
     m_selectedNode->GetData(), mitk::ModelFitConstants::FIT_TYPE_VALUE_ROIBASED(), this->GetFitName(), roiUID);
   mitk::ScalarListLookupTable::ValueType infoSignal;
 
   for (mitk::MaskedDynamicImageStatisticsGenerator::ResultType::const_iterator pos =
          roiSignal.begin(); pos != roiSignal.end(); ++pos)
   {
     infoSignal.push_back(*pos);
   }
 
   modelFitInfo->inputData.SetTableValue("ROI", infoSignal);
 }
 
 template <typename TParameterizer>
 void MRPerfusionView::GenerateAIFbasedModelFit_PixelBased(mitk::modelFit::ModelFitInfo::Pointer&
     modelFitInfo, mitk::ParameterFitImageGeneratorBase::Pointer& generator)
 {
   mitk::PixelBasedParameterFitImageGenerator::Pointer fitGenerator =
     mitk::PixelBasedParameterFitImageGenerator::New();
 
   typename TParameterizer::Pointer modelParameterizer =
     TParameterizer::New();
 
   PrepareConcentrationImage();
 
   mitk::AIFBasedModelBase::AterialInputFunctionType aif;
   mitk::AIFBasedModelBase::AterialInputFunctionType aifTimeGrid;
   GetAIF(aif, aifTimeGrid);
 
   modelParameterizer->SetAIF(aif);
   modelParameterizer->SetAIFTimeGrid(aifTimeGrid);
 
   this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
 
   mitk::NumericTwoCompartmentExchangeModelParameterizer* numTCXParametrizer =
     dynamic_cast<mitk::NumericTwoCompartmentExchangeModelParameterizer*>
     (modelParameterizer.GetPointer());
 
   if (numTCXParametrizer)
   {
     numTCXParametrizer->SetODEINTStepSize(this->m_Controls.odeStepSize->value());
   }
 
   //Specify fitting strategy and criterion parameters
   mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
 
   //Parametrize fit generator
   fitGenerator->SetModelParameterizer(modelParameterizer);
   std::string roiUID = "";
 
   if (m_selectedMask.IsNotNull())
   {
     fitGenerator->SetMask(m_selectedMask);
     roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
   }
 
   fitGenerator->SetDynamicImage(this->m_inputImage);
   fitGenerator->SetFitFunctor(fitFunctor);
 
   generator = fitGenerator.GetPointer();
 
   //Create model info
   modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
     this->m_inputImage, mitk::ModelFitConstants::FIT_TYPE_VALUE_PIXELBASED(), this->GetFitName(),
                  roiUID);
 
   mitk::ScalarListLookupTable::ValueType infoSignal;
 
   for (mitk::AIFBasedModelBase::AterialInputFunctionType::const_iterator pos =
          aif.begin(); pos != aif.end(); ++pos)
   {
     infoSignal.push_back(*pos);
   }
 
   modelFitInfo->inputData.SetTableValue("AIF", infoSignal);
 }
 
 template <typename TParameterizer>
 void MRPerfusionView::GenerateAIFbasedModelFit_ROIBased(
   mitk::modelFit::ModelFitInfo::Pointer& modelFitInfo,
   mitk::ParameterFitImageGeneratorBase::Pointer& generator)
 {
   if (m_selectedMask.IsNull())
   {
     return;
   }
 
   mitk::ROIBasedParameterFitImageGenerator::Pointer fitGenerator =
     mitk::ROIBasedParameterFitImageGenerator::New();
 
   typename TParameterizer::Pointer modelParameterizer =
     TParameterizer::New();
 
   PrepareConcentrationImage();
 
   mitk::AIFBasedModelBase::AterialInputFunctionType aif;
   mitk::AIFBasedModelBase::AterialInputFunctionType aifTimeGrid;
   GetAIF(aif, aifTimeGrid);
 
   modelParameterizer->SetAIF(aif);
   modelParameterizer->SetAIFTimeGrid(aifTimeGrid);
 
   this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
 
   mitk::NumericTwoCompartmentExchangeModelParameterizer* numTCXParametrizer =
     dynamic_cast<mitk::NumericTwoCompartmentExchangeModelParameterizer*>
     (modelParameterizer.GetPointer());
 
   if (numTCXParametrizer)
   {
     numTCXParametrizer->SetODEINTStepSize(this->m_Controls.odeStepSize->value());
   }
 
   //Compute ROI signal
   mitk::MaskedDynamicImageStatisticsGenerator::Pointer signalGenerator =
     mitk::MaskedDynamicImageStatisticsGenerator::New();
   signalGenerator->SetMask(m_selectedMask);
   signalGenerator->SetDynamicImage(this->m_inputImage);
   signalGenerator->Generate();
 
   mitk::MaskedDynamicImageStatisticsGenerator::ResultType roiSignal = signalGenerator->GetMean();
 
   //Specify fitting strategy and criterion parameters
   mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
 
   //Parametrize fit generator
   fitGenerator->SetModelParameterizer(modelParameterizer);
   fitGenerator->SetMask(m_selectedMask);
   fitGenerator->SetFitFunctor(fitFunctor);
   fitGenerator->SetSignal(roiSignal);
   fitGenerator->SetTimeGrid(mitk::ExtractTimeGrid(this->m_inputImage));
 
   generator = fitGenerator.GetPointer();
 
   std::string roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
 
   //Create model info
   modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
     this->m_inputImage, mitk::ModelFitConstants::FIT_TYPE_VALUE_ROIBASED(), this->GetFitName(),
                  roiUID);
 
   mitk::ScalarListLookupTable::ValueType infoSignal;
 
   for (mitk::MaskedDynamicImageStatisticsGenerator::ResultType::const_iterator pos =
          roiSignal.begin(); pos != roiSignal.end(); ++pos)
   {
     infoSignal.push_back(*pos);
   }
 
   modelFitInfo->inputData.SetTableValue("ROI", infoSignal);
 
   infoSignal.clear();
 
   for (mitk::AIFBasedModelBase::AterialInputFunctionType::const_iterator pos =
          aif.begin(); pos != aif.end(); ++pos)
   {
     infoSignal.push_back(*pos);
   }
 
   modelFitInfo->inputData.SetTableValue("AIF", infoSignal);
 }
 
 
 void MRPerfusionView::DoFit(const mitk::modelFit::ModelFitInfo* fitSession,
                             mitk::ParameterFitImageGeneratorBase* generator)
 {
   std::stringstream message;
   message << "<font color='green'>" << "Fitting Data Set . . ." << "</font>";
   m_Controls.errorMessageLabel->setText(message.str().c_str());
   m_Controls.errorMessageLabel->show();
 
   /////////////////////////
   //create job and put it into the thread pool
   mitk::modelFit::ModelFitResultNodeVectorType additionalNodes;
   if (m_HasGeneratedNewInput)
   {
     additionalNodes.push_back(m_inputNode);
   }
   if (m_HasGeneratedNewInputAIF)
   {
     additionalNodes.push_back(m_inputAIFNode);
   }
 
   ParameterFitBackgroundJob* pJob = new ParameterFitBackgroundJob(generator, fitSession,
       this->m_selectedNode, additionalNodes);
   pJob->setAutoDelete(true);
 
   connect(pJob, SIGNAL(Error(QString)), this, SLOT(OnJobError(QString)));
   connect(pJob, SIGNAL(Finished()), this, SLOT(OnJobFinished()));
   connect(pJob, SIGNAL(ResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType,
                        const ParameterFitBackgroundJob*)), this,
           SLOT(OnJobResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType,
                                         const ParameterFitBackgroundJob*)), Qt::BlockingQueuedConnection);
 
   connect(pJob, SIGNAL(JobProgress(double)), this, SLOT(OnJobProgress(double)));
   connect(pJob, SIGNAL(JobStatusChanged(QString)), this, SLOT(OnJobStatusChanged(QString)));
 
   QThreadPool* threadPool = QThreadPool::globalInstance();
   threadPool->start(pJob);
 }
 
 MRPerfusionView::MRPerfusionView() : m_FittingInProgress(false), m_HasGeneratedNewInput(false), m_HasGeneratedNewInputAIF(false)
 {
-  m_selectedImage = NULL;
-  m_selectedMask = NULL;
+  m_selectedImage = nullptr;
+  m_selectedMask = nullptr;
 
   mitk::ModelFactoryBase::Pointer factory =
     mitk::DescriptivePharmacokineticBrixModelFactory::New().GetPointer();
   m_FactoryStack.push_back(factory);
   factory = mitk::ThreeStepLinearModelFactory::New().GetPointer();
   m_FactoryStack.push_back(factory);
   factory = mitk::StandardToftsModelFactory::New().GetPointer();
   m_FactoryStack.push_back(factory);
   factory = mitk::ExtendedToftsModelFactory::New().GetPointer();
   m_FactoryStack.push_back(factory);
   factory = mitk::TwoCompartmentExchangeModelFactory::New().GetPointer();
   m_FactoryStack.push_back(factory);
   factory = mitk::NumericTwoCompartmentExchangeModelFactory::New().GetPointer();
   m_FactoryStack.push_back(factory);
 
   mitk::NodePredicateDataType::Pointer isLabelSet = mitk::NodePredicateDataType::New("LabelSetImage");
   mitk::NodePredicateDataType::Pointer isImage = mitk::NodePredicateDataType::New("Image");
   mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   mitk::NodePredicateAnd::Pointer isLegacyMask = mitk::NodePredicateAnd::New(isImage, isBinary);
 
   mitk::NodePredicateOr::Pointer isMask = mitk::NodePredicateOr::New(isLegacyMask, isLabelSet);
   mitk::NodePredicateAnd::Pointer isNoMask = mitk::NodePredicateAnd::New(isImage, mitk::NodePredicateNot::New(isMask));
 
   this->m_IsMaskPredicate = mitk::NodePredicateAnd::New(isMask, mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))).GetPointer();
   
   this->m_IsNoMaskImagePredicate = mitk::NodePredicateAnd::New(isNoMask, mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))).GetPointer();
 }
 
 void MRPerfusionView::OnJobFinished()
 {
   this->m_Controls.infoBox->append(QString("Fitting finished."));
   this->m_FittingInProgress = false;
   this->UpdateGUIControls();
 };
 
 void MRPerfusionView::OnJobError(QString err)
 {
   MITK_ERROR << err.toStdString().c_str();
 
   m_Controls.infoBox->append(QString("<font color='red'><b>") + err + QString("</b></font>"));
 };
 
 void MRPerfusionView::OnJobResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType results,
     const ParameterFitBackgroundJob* pJob)
 {
   //Store the resulting parameter fit image via convenience helper function in data storage
   //(handles the correct generation of the nodes and their properties)
   
   mitk::modelFit::StoreResultsInDataStorage(this->GetDataStorage(), results, pJob->GetParentNode());
   //this stores the concentration image and AIF concentration image, if generated for this fit in the storage.
   //if not generated for this fit, relevant nodes are empty.
   mitk::modelFit::StoreResultsInDataStorage(this->GetDataStorage(), pJob->GetAdditionalRelevantNodes(), pJob->GetParentNode());
 
 
 
 };
 
 void MRPerfusionView::OnJobProgress(double progress)
 {
   QString report = QString("Progress. ") + QString::number(progress);
   this->m_Controls.infoBox->append(report);
 };
 
 void MRPerfusionView::OnJobStatusChanged(QString info)
 {
   this->m_Controls.infoBox->append(info);
 }
 
 
 void MRPerfusionView::InitModelComboBox() const
 {
   this->m_Controls.comboModel->clear();
   this->m_Controls.comboModel->addItem(tr("No model selected"));
 
   for (ModelFactoryStackType::const_iterator pos = m_FactoryStack.begin();
        pos != m_FactoryStack.end(); ++pos)
   {
     this->m_Controls.comboModel->addItem(QString::fromStdString((*pos)->GetClassID()));
   }
 
   this->m_Controls.comboModel->setCurrentIndex(0);
 };
 
 mitk::DataNode::Pointer MRPerfusionView::GenerateConcentrationNode(mitk::Image* image,
     const std::string& nodeName) const
 {
   if (!image)
   {
     mitkThrow() << "Cannot generate concentration node. Passed image is null. parameter name: ";
   }
 
   mitk::DataNode::Pointer result = mitk::DataNode::New();
 
   result->SetData(image);
   result->SetName(nodeName);
   result->SetVisibility(true);
 
   mitk::EnsureModelFitUID(result);
 
   return result;
 };
 
 
 mitk::Image::Pointer MRPerfusionView::ConvertConcentrationImage(bool AIFMode)
 {
   //Compute Concentration image
   mitk::ConcentrationCurveGenerator::Pointer concentrationGen =
     mitk::ConcentrationCurveGenerator::New();
 
   if (m_Controls.checkDedicatedAIFImage->isChecked() && AIFMode)
   {
     concentrationGen->SetDynamicImage(this->m_selectedAIFImage);
   }
   else
   {
     concentrationGen->SetDynamicImage(this->m_selectedImage);
   }
 
   concentrationGen->SetisTurboFlashSequence(IsTurboFlashSequenceFlag());
   concentrationGen->SetAbsoluteSignalEnhancement(m_Controls.radioButton_absoluteEnhancement->isChecked());
   concentrationGen->SetRelativeSignalEnhancement(m_Controls.radioButton_relativeEnchancement->isChecked());
   concentrationGen->SetUsingT1Map(m_Controls.radioButtonUsingT1->isChecked());
   
   if (IsTurboFlashSequenceFlag())
   {
     if (AIFMode)
     {
       concentrationGen->SetRecoveryTime(m_Controls.AifRecoverytime->value());
     }
     else
     {
       concentrationGen->SetRecoveryTime(m_Controls.recoverytime->value());
     }
 
     concentrationGen->SetRelaxationTime(m_Controls.relaxationtime->value());
     concentrationGen->SetRelaxivity(m_Controls.relaxivity->value());
   }
   else if (this->m_Controls.radioButtonUsingT1->isChecked())
   {
       concentrationGen->SetRecoveryTime(m_Controls.TRSpinBox->value());
       concentrationGen->SetRelaxivity(m_Controls.RelaxivitySpinBox->value());
       concentrationGen->SetT10Image(dynamic_cast<mitk::Image*>(m_Controls.ComboT1Map->GetSelectedNode()->GetData()));
 
       //Convert Flipangle from degree to radiant
       double alpha = m_Controls.FlipangleSpinBox->value()/360*2* boost::math::constants::pi<double>();
       concentrationGen->SetFlipAngle(alpha);
   }
   else
   {
     concentrationGen->SetFactor(m_Controls.factorSpinBox->value());
   }
 
   mitk::Image::Pointer concentrationImage = concentrationGen->GetConvertedImage();
 
   return concentrationImage;
 }
 
 void MRPerfusionView::GetAIF(mitk::AIFBasedModelBase::AterialInputFunctionType& aif,
                              mitk::AIFBasedModelBase::AterialInputFunctionType& aifTimeGrid)
 {
   if (this->m_Controls.radioAIFFile->isChecked())
   {
     aif.clear();
     aifTimeGrid.clear();
 
     aif.SetSize(AIFinputFunction.size());
     aifTimeGrid.SetSize(AIFinputGrid.size());
 
     aif.fill(0.0);
     aifTimeGrid.fill(0.0);
 
     itk::Array<double>::iterator aifPos = aif.begin();
 
     for (std::vector<double>::const_iterator pos = AIFinputFunction.begin();
          pos != AIFinputFunction.end(); ++pos, ++aifPos)
     {
       *aifPos = *pos;
     }
 
     itk::Array<double>::iterator gridPos = aifTimeGrid.begin();
 
     for (std::vector<double>::const_iterator pos = AIFinputGrid.begin(); pos != AIFinputGrid.end();
          ++pos, ++gridPos)
     {
       *gridPos = *pos;
     }
   }
   else if (this->m_Controls.radioAIFImage->isChecked())
   {
     aif.clear();
     aifTimeGrid.clear();
 
     mitk::AterialInputFunctionGenerator::Pointer aifGenerator =
       mitk::AterialInputFunctionGenerator::New();
 
     //Hematocrit level
     aifGenerator->SetHCL(this->m_Controls.HCLSpinBox->value());
 
     //mask settings
     this->m_selectedAIFMaskNode = m_Controls.comboAIFMask->GetSelectedNode();
     this->m_selectedAIFMask = dynamic_cast<mitk::Image*>(this->m_selectedAIFMaskNode->GetData());
 
     if (this->m_selectedAIFMask->GetTimeSteps() > 1)
     {
       MITK_INFO <<
                 "Selected AIF mask has multiple timesteps. Only use first timestep to mask model fit. AIF Mask name: "
                 <<
                 m_selectedAIFMaskNode->GetName() ;
       mitk::ImageTimeSelector::Pointer maskedImageTimeSelector = mitk::ImageTimeSelector::New();
       maskedImageTimeSelector->SetInput(this->m_selectedAIFMask);
       maskedImageTimeSelector->SetTimeNr(0);
       maskedImageTimeSelector->UpdateLargestPossibleRegion();
       this->m_selectedAIFMask = maskedImageTimeSelector->GetOutput();
     }
 
     if (this->m_selectedAIFMask.IsNotNull())
     {
       aifGenerator->SetMask(this->m_selectedAIFMask);
     }
 
     //image settings
     if (this->m_Controls.checkDedicatedAIFImage->isChecked())
     {
       this->m_selectedAIFImageNode = m_Controls.comboAIFImage->GetSelectedNode();
       this->m_selectedAIFImage = dynamic_cast<mitk::Image*>(this->m_selectedAIFImageNode->GetData());
     }
     else
     {
       this->m_selectedAIFImageNode = m_selectedNode;
       this->m_selectedAIFImage = m_selectedImage;
     }
 
     this->PrepareAIFConcentrationImage();
 
     aifGenerator->SetDynamicImage(this->m_inputAIFImage);
 
     aif = aifGenerator->GetAterialInputFunction();
     aifTimeGrid = aifGenerator->GetAterialInputFunctionTimeGrid();
   }
   else
   {
     mitkThrow() << "Cannot generate AIF. View is in a invalide state. No AIF mode selected.";
   }
 }
 
 
 void MRPerfusionView::LoadAIFfromFile()
 {
   QFileDialog dialog;
   dialog.setNameFilter(tr("Images (*.csv"));
 
   QString fileName = dialog.getOpenFileName();
 
   m_Controls.aifFilePath->setText(fileName);
 
   std::string m_aifFilePath = fileName.toStdString();
   //Read Input
   typedef boost::tokenizer< boost::escaped_list_separator<char> > Tokenizer;
   /////////////////////////////////////////////////////////////////////////////////////////////////
   //AIF Data
 
   std::ifstream in1(m_aifFilePath.c_str());
 
   if (!in1.is_open())
   {
     m_Controls.errorMessageLabel->setText("Could not open AIF File!");
   }
 
 
   std::vector< std::string > vec1;
   std::string line1;
 
   while (getline(in1, line1))
   {
     Tokenizer tok(line1);
     vec1.assign(tok.begin(), tok.end());
 
     this->AIFinputGrid.push_back(convertToDouble(vec1[0]));
     this->AIFinputFunction.push_back(convertToDouble(vec1[1]));
   }
 }
 
 void MRPerfusionView::PrepareConcentrationImage()
 {
   mitk::Image::Pointer concentrationImage = this->m_selectedImage;
   mitk::DataNode::Pointer concentrationNode = this->m_selectedNode;
   m_HasGeneratedNewInput = false;
 
   if (!this->m_Controls.radioButtonNoConversion->isChecked())
   {
     concentrationImage = this->ConvertConcentrationImage(false);
     concentrationNode = GenerateConcentrationNode(concentrationImage, "Concentration");
     m_HasGeneratedNewInput = true;
   }
 
   m_inputImage = concentrationImage;
   m_inputNode = concentrationNode;
 
   mitk::EnsureModelFitUID(concentrationNode);
 }
 
 void MRPerfusionView::PrepareAIFConcentrationImage()
 {
   mitk::Image::Pointer concentrationImage = this->m_selectedImage;
   mitk::DataNode::Pointer concentrationNode = this->m_selectedNode;
   m_HasGeneratedNewInputAIF = false;
 
   if (this->m_Controls.checkDedicatedAIFImage->isChecked())
   {
     concentrationImage = this->m_selectedAIFImage;
     concentrationNode = this->m_selectedAIFImageNode;
   }
 
   if (!this->m_Controls.radioButtonNoConversion->isChecked())
   {
     if (!IsTurboFlashSequenceFlag() && !this->m_Controls.checkDedicatedAIFImage->isChecked())
     {
       if (m_inputImage.IsNull())
       {
         mitkThrow() <<
           "Cannot get AIF concentration image. Invalid view state. Input image is not defined yet, but should be.";
       }
 
       //we can directly use the concentration input image/node (generated by GetConcentrationImage) also for the AIF
       concentrationImage = this->m_inputImage;
       concentrationNode = this->m_inputNode;
     }
     else
     {
       concentrationImage = this->ConvertConcentrationImage(true);
       concentrationNode = GenerateConcentrationNode(concentrationImage, "AIF Concentration");
       m_HasGeneratedNewInputAIF = true;
     }
   }
 
   m_inputAIFImage = concentrationImage;
   m_inputAIFNode = concentrationNode;
 
   mitk::EnsureModelFitUID(concentrationNode);
 }
 
 
 
 mitk::ModelFitFunctorBase::Pointer MRPerfusionView::CreateDefaultFitFunctor(
   const mitk::ModelParameterizerBase* parameterizer) const
 {
   mitk::LevenbergMarquardtModelFitFunctor::Pointer fitFunctor =
     mitk::LevenbergMarquardtModelFitFunctor::New();
 
   mitk::NormalizedSumOfSquaredDifferencesFitCostFunction::Pointer chi2 =
     mitk::NormalizedSumOfSquaredDifferencesFitCostFunction::New();
   fitFunctor->RegisterEvaluationParameter("Chi^2", chi2);
 
   if (m_Controls.checkBox_Constraints->isChecked())
   {
     fitFunctor->SetConstraintChecker(m_modelConstraints);
   }
 
   mitk::ModelBase::Pointer refModel = parameterizer->GenerateParameterizedModel();
 
   ::itk::LevenbergMarquardtOptimizer::ScalesType scales;
   scales.SetSize(refModel->GetNumberOfParameters());
   scales.Fill(1.0);
   fitFunctor->SetScales(scales);
 
   fitFunctor->SetDebugParameterMaps(m_Controls.checkDebug->isChecked());
 
   return fitFunctor.GetPointer();
 }
diff --git a/Plugins/org.mitk.gui.qt.pharmacokinetics.pet/src/internal/PETDynamicView.cpp b/Plugins/org.mitk.gui.qt.pharmacokinetics.pet/src/internal/PETDynamicView.cpp
index 37d27c213b..d3d249ae15 100644
--- a/Plugins/org.mitk.gui.qt.pharmacokinetics.pet/src/internal/PETDynamicView.cpp
+++ b/Plugins/org.mitk.gui.qt.pharmacokinetics.pet/src/internal/PETDynamicView.cpp
@@ -1,946 +1,946 @@
 /*===================================================================
 
 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 "PETDynamicView.h"
 
 #include "mitkWorkbenchUtil.h"
 
 
 #include "mitkAterialInputFunctionGenerator.h"
 
 #include "mitkOneTissueCompartmentModelFactory.h"
 #include "mitkOneTissueCompartmentModelParameterizer.h"
 #include "mitkExtendedOneTissueCompartmentModelFactory.h"
 #include "mitkExtendedOneTissueCompartmentModelParameterizer.h"
 #include "mitkTwoTissueCompartmentFDGModelFactory.h"
 #include "mitkTwoTissueCompartmentFDGModelParameterizer.h"
 #include "mitkTwoTissueCompartmentModelFactory.h"
 #include "mitkTwoTissueCompartmentModelParameterizer.h"
 #include "mitkNumericTwoTissueCompartmentModelFactory.h"
 #include "mitkNumericTwoTissueCompartmentModelParameterizer.h"
 
 
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkPixelBasedParameterFitImageGenerator.h>
 #include <mitkROIBasedParameterFitImageGenerator.h>
 #include <mitkLevenbergMarquardtModelFitFunctor.h>
 #include <mitkSumOfSquaredDifferencesFitCostFunction.h>
 #include <mitkSquaredDifferencesFitCostFunction.h>
 #include <mitkChiSquareFitCostFunction.h>
 #include <mitkReducedChiSquareFitCostFunction.h>
 #include <mitkSimpleBarrierConstraintChecker.h>
 #include <mitkModelFitResultHelper.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkMaskedDynamicImageStatisticsGenerator.h>
 #include <mitkExtractTimeGrid.h>
 #include <mitkInitialParameterizationDelegateBase.h>
 
 #include <QMessageBox>
 #include <QThreadPool>
 #include <QmitkDataStorageComboBox.h>
 #include <QFileDialog>
 #include <boost/tokenizer.hpp>
 
 
 // Includes for image casting between ITK and MITK
 #include <mitkImage.h>
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 #include <itkImage.h>
 #include <itkImageRegionIterator.h>
 #include <iostream>
 
 
 const std::string PETDynamicView::VIEW_ID = "org.mitk.gui.qt.pharmacokinetics.pet";
 
 inline double convertToDouble(const std::string& data)
 {
   std::istringstream stepStream(data);
   double value = 0.0;
   stepStream >> value;
   return value;
 }
 
 void PETDynamicView::SetFocus()
 {
   m_Controls.btnModelling->setFocus();
 }
 
 void PETDynamicView::CreateQtPartControl(QWidget* parent)
 {
   m_Controls.setupUi(parent);
 
   m_Controls.btnModelling->setEnabled(false);
   m_Controls.errorMessageLabel->hide();
 
   this->InitModelComboBox();
 
   connect(m_Controls.btnModelling, SIGNAL(clicked()), this, SLOT(OnModellingButtonClicked()));
 
   connect(m_Controls.comboModel, SIGNAL(currentIndexChanged(int)), this, SLOT(OnModellSet(int)));
   connect(m_Controls.radioPixelBased, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
 
   //AIF setting
   m_Controls.groupAIF->hide();
   m_Controls.btnAIFFile->setEnabled(false);
   m_Controls.btnAIFFile->setEnabled(false);
   m_Controls.radioAIFImage->setChecked(true);
   m_Controls.comboAIFMask->SetDataStorage(this->GetDataStorage());
   m_Controls.comboAIFMask->SetPredicate(m_IsMaskPredicate);
   m_Controls.comboAIFMask->setVisible(true);
   m_Controls.comboAIFMask->setEnabled(true);
   m_Controls.comboAIFImage->SetDataStorage(this->GetDataStorage());
   m_Controls.comboAIFImage->SetPredicate(m_IsNoMaskImagePredicate);
   m_Controls.comboAIFImage->setEnabled(false);
   m_Controls.checkDedicatedAIFImage->setEnabled(true);
   m_Controls.HCLSpinBox->setValue(0.0);
 
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.comboAIFMask,
           SLOT(setVisible(bool)));
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.labelAIFMask,
           SLOT(setVisible(bool)));
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.checkDedicatedAIFImage,
           SLOT(setVisible(bool)));
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.comboAIFMask,
           SLOT(setEnabled(bool)));
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.checkDedicatedAIFImage,
           SLOT(setEnabled(bool)));
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.checkDedicatedAIFImage,
           SLOT(setVisible(bool)));
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.comboAIFImage,
           SLOT(setVisible(bool)));
   connect(m_Controls.checkDedicatedAIFImage, SIGNAL(toggled(bool)), m_Controls.comboAIFImage,
           SLOT(setEnabled(bool)));
   connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
   connect(m_Controls.radioAIFFile, SIGNAL(toggled(bool)), m_Controls.btnAIFFile,
           SLOT(setEnabled(bool)));
   connect(m_Controls.radioAIFFile, SIGNAL(toggled(bool)), m_Controls.aifFilePath,
           SLOT(setEnabled(bool)));
   connect(m_Controls.radioAIFFile, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
 
   connect(m_Controls.btnAIFFile, SIGNAL(clicked()), this, SLOT(LoadAIFfromFile()));
 
   //Model fit configuration
   m_Controls.groupBox_FitConfiguration->hide();
 
   m_Controls.checkBox_Constraints->setEnabled(false);
   m_Controls.constraintManager->setEnabled(false);
   m_Controls.initialValuesManager->setEnabled(false);
   m_Controls.initialValuesManager->setDataStorage(this->GetDataStorage());
 
   connect(m_Controls.radioButton_StartParameters, SIGNAL(toggled(bool)), this,
           SLOT(UpdateGUIControls()));
   connect(m_Controls.checkBox_Constraints, SIGNAL(toggled(bool)), this,
           SLOT(UpdateGUIControls()));
   connect(m_Controls.initialValuesManager, SIGNAL(initialValuesChanged(void)), this, SLOT(UpdateGUIControls()));
 
 
   connect(m_Controls.radioButton_StartParameters, SIGNAL(toggled(bool)),
           m_Controls.initialValuesManager,
           SLOT(setEnabled(bool)));
   connect(m_Controls.checkBox_Constraints, SIGNAL(toggled(bool)), m_Controls.constraintManager,
           SLOT(setEnabled(bool)));
   connect(m_Controls.checkBox_Constraints, SIGNAL(toggled(bool)), m_Controls.constraintManager,
           SLOT(setVisible(bool)));
 
 
   UpdateGUIControls();
 
 }
 
 void PETDynamicView::UpdateGUIControls()
 {
   m_Controls.lineFitName->setPlaceholderText(QString::fromStdString(this->GetDefaultFitName()));
   m_Controls.lineFitName->setEnabled(!m_FittingInProgress);
 
   m_Controls.checkBox_Constraints->setEnabled(m_modelConstraints.IsNotNull());
 
    bool is1TCMFactory = dynamic_cast<mitk::OneTissueCompartmentModelFactory*>
-                        (m_selectedModelFactory.GetPointer()) != NULL;
+                        (m_selectedModelFactory.GetPointer()) != nullptr;
    bool isExt1TCMFactory = dynamic_cast<mitk::ExtendedOneTissueCompartmentModelFactory*>
-                        (m_selectedModelFactory.GetPointer()) != NULL;
+                        (m_selectedModelFactory.GetPointer()) != nullptr;
    bool isFDGCMFactory = dynamic_cast<mitk::TwoTissueCompartmentFDGModelFactory*>
-                        (m_selectedModelFactory.GetPointer()) != NULL;
+                        (m_selectedModelFactory.GetPointer()) != nullptr;
 
   bool is2TCMFactory = dynamic_cast<mitk::TwoTissueCompartmentModelFactory*>
-                       (m_selectedModelFactory.GetPointer()) != NULL ||
+                       (m_selectedModelFactory.GetPointer()) != nullptr ||
                        dynamic_cast<mitk::NumericTwoTissueCompartmentModelFactory*>
-                       (m_selectedModelFactory.GetPointer()) != NULL;
+                       (m_selectedModelFactory.GetPointer()) != nullptr;
 
 
   m_Controls.groupAIF->setVisible(is1TCMFactory || isExt1TCMFactory || isFDGCMFactory || is2TCMFactory);
 
   m_Controls.groupBox_FitConfiguration->setVisible(m_selectedModelFactory);
 
   m_Controls.groupBox->setEnabled(!m_FittingInProgress);
   m_Controls.comboModel->setEnabled(!m_FittingInProgress);
   m_Controls.groupAIF->setEnabled(!m_FittingInProgress);
   m_Controls.groupBox_FitConfiguration->setEnabled(!m_FittingInProgress);
 
   m_Controls.radioROIbased->setEnabled(m_selectedMask.IsNotNull());
 
   m_Controls.btnModelling->setEnabled(m_selectedImage.IsNotNull()
                                       && m_selectedModelFactory.IsNotNull() && !m_FittingInProgress && CheckModelSettings());
 }
 
 //void PETDynamicView::OnModelSettingChanged()
 //{
 //  bool ok = m_selectedImage.IsNotNull() && m_selectedModelFactory.IsNotNull() && !m_FittingInProgress && CheckModelSettings();
 
 //  m_Controls.btnModelling->setEnabled(ok);
 //}
 
 
 void PETDynamicView::OnModellSet(int index)
 {
-  m_selectedModelFactory = NULL;
+  m_selectedModelFactory = nullptr;
 
   if (index > 0)
   {
     if (static_cast<ModelFactoryStackType::size_type>(index) <= m_FactoryStack.size() )
     {
         m_selectedModelFactory = m_FactoryStack[index - 1];
     }
     else
     {
         MITK_WARN << "Invalid model index. Index outside of the factory stack. Factory stack size: "<< m_FactoryStack.size() << "; invalid index: "<< index;
     }
   }
 
   if (m_selectedModelFactory)
   {
     this->m_modelConstraints = dynamic_cast<mitk::SimpleBarrierConstraintChecker*>
                                (m_selectedModelFactory->CreateDefaultConstraints().GetPointer());
 
     m_Controls.initialValuesManager->setInitialValues(m_selectedModelFactory->GetParameterNames(),
         m_selectedModelFactory->GetDefaultInitialParameterization());
 
     if (this->m_modelConstraints.IsNull())
     {
       this->m_modelConstraints = mitk::SimpleBarrierConstraintChecker::New();
     }
 
     m_Controls.constraintManager->setChecker(this->m_modelConstraints,
         this->m_selectedModelFactory->GetParameterNames());
   }
 
   m_Controls.checkBox_Constraints->setEnabled(m_modelConstraints.IsNotNull());
 
 
   UpdateGUIControls();
 }
 
 std::string PETDynamicView::GetFitName() const
 {
   std::string fitName = m_Controls.lineFitName->text().toStdString();
   if (fitName.empty())
   {
     fitName = m_Controls.lineFitName->placeholderText().toStdString();
   }
   return fitName;
 }
 
 std::string PETDynamicView::GetDefaultFitName() const
 {
     std::string defaultName = "undefined model";
 
     if (this->m_selectedModelFactory.IsNotNull())
     {
         defaultName = this->m_selectedModelFactory->GetClassID();
     }
 
     if (this->m_Controls.radioPixelBased->isChecked())
     {
         defaultName += "_pixel";
     }
     else
     {
         defaultName += "_roi";
     }
 
     return defaultName;
 }
 
 
 void PETDynamicView::OnModellingButtonClicked()
 {
   //check if all static parameters set
   if (m_selectedModelFactory.IsNotNull() && CheckModelSettings())
   {
-    mitk::ParameterFitImageGeneratorBase::Pointer generator = NULL;
-    mitk::modelFit::ModelFitInfo::Pointer fitSession = NULL;
+    mitk::ParameterFitImageGeneratorBase::Pointer generator = nullptr;
+    mitk::modelFit::ModelFitInfo::Pointer fitSession = nullptr;
 
 
     bool isOTCFactory = dynamic_cast<mitk::OneTissueCompartmentModelFactory*>
-                        (m_selectedModelFactory.GetPointer()) != NULL;
+                        (m_selectedModelFactory.GetPointer()) != nullptr;
     bool isextOTCFactory = dynamic_cast<mitk::ExtendedOneTissueCompartmentModelFactory*>
-                        (m_selectedModelFactory.GetPointer()) != NULL;
+                        (m_selectedModelFactory.GetPointer()) != nullptr;
 
     bool isFDGFactory = dynamic_cast<mitk::TwoTissueCompartmentFDGModelFactory*>
-                        (m_selectedModelFactory.GetPointer()) != NULL;
+                        (m_selectedModelFactory.GetPointer()) != nullptr;
 
     bool isTTCFactory = dynamic_cast<mitk::TwoTissueCompartmentModelFactory*>
-                        (m_selectedModelFactory.GetPointer()) != NULL;
+                        (m_selectedModelFactory.GetPointer()) != nullptr;
     bool isNumTTCFactory = dynamic_cast<mitk::NumericTwoTissueCompartmentModelFactory*>
-                           (m_selectedModelFactory.GetPointer()) != NULL;
+                           (m_selectedModelFactory.GetPointer()) != nullptr;
 
 
     if (isOTCFactory)
     {
       if (this->m_Controls.radioPixelBased->isChecked())
       {
         GenerateModelFit_PixelBased<mitk::OneTissueCompartmentModelParameterizer>(fitSession, generator);
       }
       else
       {
         GenerateModelFit_ROIBased<mitk::OneTissueCompartmentModelParameterizer>(fitSession, generator);
       }
     }
 
     else if (isextOTCFactory)
     {
       if (this->m_Controls.radioPixelBased->isChecked())
       {
         GenerateModelFit_PixelBased<mitk::ExtendedOneTissueCompartmentModelParameterizer>(fitSession, generator);
       }
       else
       {
         GenerateModelFit_ROIBased<mitk::ExtendedOneTissueCompartmentModelParameterizer>(fitSession, generator);
       }
     }
     else if (isFDGFactory)
     {
       if (this->m_Controls.radioPixelBased->isChecked())
       {
         GenerateModelFit_PixelBased<mitk::TwoTissueCompartmentFDGModelParameterizer>(fitSession, generator);
       }
       else
       {
         GenerateModelFit_ROIBased<mitk::TwoTissueCompartmentFDGModelParameterizer>(fitSession, generator);
       }
     }
 
 
     else if (isTTCFactory)
     {
       if (this->m_Controls.radioPixelBased->isChecked())
       {
         GenerateModelFit_PixelBased<mitk::TwoTissueCompartmentModelParameterizer>(fitSession, generator);
       }
       else
       {
         GenerateModelFit_ROIBased<mitk::TwoTissueCompartmentModelParameterizer>(fitSession, generator);
       }
     }
 
     else if (isNumTTCFactory)
     {
       if (this->m_Controls.radioPixelBased->isChecked())
       {
         GenerateModelFit_PixelBased<mitk::NumericTwoTissueCompartmentModelParameterizer>(fitSession,
             generator);
       }
       else
       {
         GenerateModelFit_ROIBased<mitk::NumericTwoTissueCompartmentModelParameterizer>(fitSession,
             generator);
       }
     }
 
     //add other models with else if
 
     if (generator.IsNotNull() && fitSession.IsNotNull())
     {
       m_FittingInProgress = true;
       DoFit(fitSession, generator);
     }
     else
     {
       QMessageBox box;
       box.setText("Fitting error!");
       box.setInformativeText("Could not establish fitting job. Error when setting ab generator, model parameterizer or session info.");
       box.setStandardButtons(QMessageBox::Ok);
       box.setDefaultButton(QMessageBox::Ok);
       box.setIcon(QMessageBox::Warning);
       box.exec();
     }
 
   }
   else
   {
     QMessageBox box;
     box.setText("Static parameters for model are not set!");
     box.setInformativeText("Some static parameters, that are needed for calculation are not set and equal to zero. Modeling not possible");
     box.setStandardButtons(QMessageBox::Ok);
     box.setDefaultButton(QMessageBox::Ok);
     box.setIcon(QMessageBox::Warning);
     box.exec();
   }
 }
 
 
 void PETDynamicView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
                                         const QList<mitk::DataNode::Pointer>& selectedNodes)
 {
-    m_selectedMaskNode = NULL;
-    m_selectedMask = NULL;
+    m_selectedMaskNode = nullptr;
+    m_selectedMask = nullptr;
 
     m_Controls.errorMessageLabel->setText("");
     m_Controls.masklabel->setText("No (valid) mask selected.");
     m_Controls.timeserieslabel->setText("No (valid) series selected.");
 
     QList<mitk::DataNode::Pointer> nodes = selectedNodes;
 
     if (nodes.size() > 0 && this->m_IsNoMaskImagePredicate->CheckNode(nodes.front()))
     {
       this->m_selectedNode = nodes.front();
       auto selectedImage = dynamic_cast<mitk::Image*>(this->m_selectedNode->GetData());
       m_Controls.timeserieslabel->setText((this->m_selectedNode->GetName()).c_str());
 
       if (selectedImage != this->m_selectedImage)
       {
         if (selectedImage)
         {
           this->m_Controls.initialValuesManager->setReferenceImageGeometry(selectedImage->GetGeometry());
         }
         else
         {
           this->m_Controls.initialValuesManager->setReferenceImageGeometry(nullptr);
         }
       }
       this->m_selectedImage = selectedImage;
       nodes.pop_front();
     }
     else
     {
-      this->m_selectedNode = NULL;
-      this->m_selectedImage = NULL;
+      this->m_selectedNode = nullptr;
+      this->m_selectedImage = nullptr;
       this->m_Controls.initialValuesManager->setReferenceImageGeometry(nullptr);
     }
 
     if (nodes.size() > 0 && this->m_IsMaskPredicate->CheckNode(nodes.front()))
     {
         this->m_selectedMaskNode = nodes.front();
         this->m_selectedMask = dynamic_cast<mitk::Image*>(this->m_selectedMaskNode->GetData());
 
         if (this->m_selectedMask->GetTimeSteps() > 1)
         {
           MITK_INFO <<
                     "Selected mask has multiple timesteps. Only use first timestep to mask model fit. Mask name: " <<
                     m_selectedMaskNode->GetName();
           mitk::ImageTimeSelector::Pointer maskedImageTimeSelector = mitk::ImageTimeSelector::New();
           maskedImageTimeSelector->SetInput(this->m_selectedMask);
           maskedImageTimeSelector->SetTimeNr(0);
           maskedImageTimeSelector->UpdateLargestPossibleRegion();
           this->m_selectedMask = maskedImageTimeSelector->GetOutput();
         }
 
         m_Controls.masklabel->setText((this->m_selectedMaskNode->GetName()).c_str());
     }
 
     if (m_selectedMask.IsNull())
     {
       this->m_Controls.radioPixelBased->setChecked(true);
     }
 
     m_Controls.errorMessageLabel->show();
 
     UpdateGUIControls();
 }
 
 bool PETDynamicView::CheckModelSettings() const
 {
   bool ok = true;
 
   //check wether any model is set at all. Otherwise exit with false
   if (m_selectedModelFactory.IsNotNull())
   {
 
     bool isOTCFactory = dynamic_cast<mitk::OneTissueCompartmentModelFactory*>
-                          (m_selectedModelFactory.GetPointer()) != NULL;
+                          (m_selectedModelFactory.GetPointer()) != nullptr;
     bool isextOTCFactory = dynamic_cast<mitk::ExtendedOneTissueCompartmentModelFactory*>
-                          (m_selectedModelFactory.GetPointer()) != NULL;
+                          (m_selectedModelFactory.GetPointer()) != nullptr;
     bool isFDGFactory = dynamic_cast<mitk::TwoTissueCompartmentFDGModelFactory*>
-                        (m_selectedModelFactory.GetPointer()) != NULL;
+                        (m_selectedModelFactory.GetPointer()) != nullptr;
     bool isTTCFactory = dynamic_cast<mitk::TwoTissueCompartmentModelFactory*>
-                        (m_selectedModelFactory.GetPointer()) != NULL;
+                        (m_selectedModelFactory.GetPointer()) != nullptr;
     bool isNumTTCFactory = dynamic_cast<mitk::NumericTwoTissueCompartmentModelFactory*>
-                           (m_selectedModelFactory.GetPointer()) != NULL;
+                           (m_selectedModelFactory.GetPointer()) != nullptr;
 
     if (isOTCFactory || isextOTCFactory || isFDGFactory || isTTCFactory || isNumTTCFactory)
     {
         if (this->m_Controls.radioAIFImage->isChecked())
         {
           ok = ok && m_Controls.comboAIFMask->GetSelectedNode().IsNotNull();
 
           if (this->m_Controls.checkDedicatedAIFImage->isChecked())
           {
             ok = ok && m_Controls.comboAIFImage->GetSelectedNode().IsNotNull();
           }
         }
         else if (this->m_Controls.radioAIFFile->isChecked())
         {
           ok = ok && (this->AIFinputGrid.size() != 0) && (this->AIFinputFunction.size() != 0);
         }
         else
         {
           ok = false;
         }
 
      }
     //add other models as else if and check wether all needed static parameters are set
     else
     {
       ok = false;
     }
 
     if (this->m_Controls.radioButton_StartParameters->isChecked() && !this->m_Controls.initialValuesManager->hasValidInitialValues())
     {
       std::string warning = "Warning. Invalid start parameters. At least one parameter as an invalid image setting as source.";
       MITK_ERROR << warning;
       m_Controls.infoBox->append(QString("<font color='red'><b>") + QString::fromStdString(warning) + QString("</b></font>"));
 
       ok = false;
     };
   }
   else
   {
     ok = false;
   }
 
   return ok;
 }
 
 void PETDynamicView::ConfigureInitialParametersOfParameterizer(mitk::ModelParameterizerBase*
     parameterizer) const
 {
   if (m_Controls.radioButton_StartParameters->isChecked())
   {
     //use user defined initial parameters
     mitk::InitialParameterizationDelegateBase::Pointer paramDelegate = m_Controls.initialValuesManager->getInitialParametrizationDelegate();
     parameterizer->SetInitialParameterizationDelegate(paramDelegate);
   }
 }
 
 template <typename TParameterizer>
 void PETDynamicView::GenerateModelFit_PixelBased(
   mitk::modelFit::ModelFitInfo::Pointer& modelFitInfo,
   mitk::ParameterFitImageGeneratorBase::Pointer& generator)
 {
   mitk::PixelBasedParameterFitImageGenerator::Pointer fitGenerator =
     mitk::PixelBasedParameterFitImageGenerator::New();
 
   typename TParameterizer::Pointer modelParameterizer =
     TParameterizer::New();
 
 
   mitk::AIFBasedModelBase::AterialInputFunctionType aif;
   mitk::AIFBasedModelBase::TimeGridType aifTimeGrid;
 
   GetAIF(aif, aifTimeGrid);
 
   //Model configuration (static parameters) can be done now
   modelParameterizer->SetAIF(aif);
   modelParameterizer->SetAIFTimeGrid(aifTimeGrid);
   this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
 
   //Specify fitting strategy and criterion parameters
   mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
 
   //Parametrize fit generator
   fitGenerator->SetModelParameterizer(modelParameterizer);
   std::string roiUID = "";
 
   if (m_selectedMask.IsNotNull())
   {
     fitGenerator->SetMask(m_selectedMask);
     roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
   }
 
   fitGenerator->SetDynamicImage(this->m_selectedImage);
   fitGenerator->SetFitFunctor(fitFunctor);
 
   generator = fitGenerator.GetPointer();
 
   //Create model info
   modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
     m_selectedNode->GetData(), mitk::ModelFitConstants::FIT_TYPE_VALUE_PIXELBASED(), this->GetFitName(), roiUID);
 
   mitk::ScalarListLookupTable::ValueType infoSignal;
 
   for (mitk::AIFBasedModelBase::AterialInputFunctionType::const_iterator pos = aif.begin();
        pos != aif.end(); ++pos)
   {
     infoSignal.push_back(*pos);
   }
 
   modelFitInfo->inputData.SetTableValue("AIF", infoSignal);
 }
 
 
 template <typename TParameterizer>
 void PETDynamicView::GenerateModelFit_ROIBased(
   mitk::modelFit::ModelFitInfo::Pointer& modelFitInfo,
   mitk::ParameterFitImageGeneratorBase::Pointer& generator)
 {
   mitk::ROIBasedParameterFitImageGenerator::Pointer fitGenerator =
     mitk::ROIBasedParameterFitImageGenerator::New();
 
   typename TParameterizer::Pointer modelParameterizer =
     TParameterizer::New();
 
 
   //Compute AIF
   mitk::AterialInputFunctionGenerator::Pointer aifGenerator =
     mitk::AterialInputFunctionGenerator::New();
   aifGenerator->SetDynamicImage(this->m_selectedImage);
   aifGenerator->SetMask(this->m_selectedAIFMask);
 
   mitk::AIFBasedModelBase::AterialInputFunctionType aif = aifGenerator->GetAterialInputFunction();
   mitk::AIFBasedModelBase::TimeGridType aifTimeGrid = aifGenerator->GetAterialInputFunctionTimeGrid();
 
   //Model configuration (static parameters) can be done now
   modelParameterizer->SetAIF(aif);
   modelParameterizer->SetAIFTimeGrid(aifTimeGrid);
 
   this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
 
   //Compute ROI signal
   mitk::MaskedDynamicImageStatisticsGenerator::Pointer signalGenerator =
     mitk::MaskedDynamicImageStatisticsGenerator::New();
   signalGenerator->SetMask(m_selectedMask);
   signalGenerator->SetDynamicImage(m_selectedImage);
   signalGenerator->Generate();
 
   mitk::MaskedDynamicImageStatisticsGenerator::ResultType roiSignal = signalGenerator->GetMean();
 
   //Specify fitting strategy and criterion parameters
   mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
 
   //Parametrize fit generator
   fitGenerator->SetModelParameterizer(modelParameterizer);
   fitGenerator->SetMask(m_selectedMask);
   fitGenerator->SetFitFunctor(fitFunctor);
   fitGenerator->SetSignal(roiSignal);
   fitGenerator->SetTimeGrid(mitk::ExtractTimeGrid(m_selectedImage));
 
   generator = fitGenerator.GetPointer();
 
   std::string roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
 
   //Create model info
   modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
     m_selectedNode->GetData(), mitk::ModelFitConstants::FIT_TYPE_VALUE_ROIBASED(), this->GetFitName(), roiUID);
 
   mitk::ScalarListLookupTable::ValueType infoSignal;
 
   for (mitk::MaskedDynamicImageStatisticsGenerator::ResultType::const_iterator pos =
          roiSignal.begin(); pos != roiSignal.end(); ++pos)
   {
     infoSignal.push_back(*pos);
   }
 
   modelFitInfo->inputData.SetTableValue("ROI", infoSignal);
 
   infoSignal.clear();
 
   for (mitk::AIFBasedModelBase::AterialInputFunctionType::const_iterator pos = aif.begin();
        pos != aif.end(); ++pos)
   {
     infoSignal.push_back(*pos);
   }
 
   modelFitInfo->inputData.SetTableValue("AIF", infoSignal);
 }
 
 void PETDynamicView::DoFit(const mitk::modelFit::ModelFitInfo* fitSession,
                            mitk::ParameterFitImageGeneratorBase* generator)
 {
   std::stringstream message;
   message << "<font color='green'>" << "Fitting Data Set . . ." << "</font>";
   m_Controls.errorMessageLabel->setText(message.str().c_str());
   m_Controls.errorMessageLabel->show();
 
   /////////////////////////
   //create job and put it into the thread pool
   ParameterFitBackgroundJob* pJob = new ParameterFitBackgroundJob(generator, fitSession,
       this->m_selectedNode);
 
   pJob->setAutoDelete(true);
 
   connect(pJob, SIGNAL(Error(QString)), this, SLOT(OnJobError(QString)));
   connect(pJob, SIGNAL(Finished()), this, SLOT(OnJobFinished()));
   connect(pJob, SIGNAL(ResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType,
                        const ParameterFitBackgroundJob*)), this,
           SLOT(OnJobResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType,
                                         const ParameterFitBackgroundJob*)), Qt::BlockingQueuedConnection);
 
   connect(pJob, SIGNAL(JobProgress(double)), this, SLOT(OnJobProgress(double)));
   connect(pJob, SIGNAL(JobStatusChanged(QString)), this, SLOT(OnJobStatusChanged(QString)));
 
   QThreadPool* threadPool = QThreadPool::globalInstance();
   threadPool->start(pJob);
 }
 
 PETDynamicView::PETDynamicView() : m_FittingInProgress(false)
 {
-  m_selectedImage = NULL;
-  m_selectedMask = NULL;
+  m_selectedImage = nullptr;
+  m_selectedMask = nullptr;
 
   mitk::ModelFactoryBase::Pointer factory =
     mitk::OneTissueCompartmentModelFactory::New().GetPointer();
     m_FactoryStack.push_back(factory);
     factory = mitk::ExtendedOneTissueCompartmentModelFactory::New().GetPointer();
     m_FactoryStack.push_back(factory);
     factory = mitk::TwoTissueCompartmentModelFactory::New().GetPointer();
     m_FactoryStack.push_back(factory);
     factory = mitk::TwoTissueCompartmentFDGModelFactory::New().GetPointer();
     m_FactoryStack.push_back(factory);
     factory = mitk::NumericTwoTissueCompartmentModelFactory::New().GetPointer();
     m_FactoryStack.push_back(factory);
 
   mitk::NodePredicateDataType::Pointer isLabelSet = mitk::NodePredicateDataType::New("LabelSetImage");
   mitk::NodePredicateDataType::Pointer isImage = mitk::NodePredicateDataType::New("Image");
   mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   mitk::NodePredicateAnd::Pointer isLegacyMask = mitk::NodePredicateAnd::New(isImage, isBinary);
 
   mitk::NodePredicateOr::Pointer isMask = mitk::NodePredicateOr::New(isLegacyMask, isLabelSet);
   mitk::NodePredicateAnd::Pointer isNoMask = mitk::NodePredicateAnd::New(isImage, mitk::NodePredicateNot::New(isMask));
 
   this->m_IsMaskPredicate = mitk::NodePredicateAnd::New(isMask, mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))).GetPointer();
 
   this->m_IsNoMaskImagePredicate = mitk::NodePredicateAnd::New(isNoMask, mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))).GetPointer();
 
 }
 
 void PETDynamicView::OnJobFinished()
 {
   this->m_Controls.infoBox->append(QString("Fitting finished"));
   this->m_FittingInProgress = false;
 };
 
 void PETDynamicView::OnJobError(QString err)
 {
   MITK_ERROR << err.toStdString().c_str();
 
   m_Controls.infoBox->append(QString("<font color='red'><b>") + err + QString("</b></font>"));
 
 };
 
 void PETDynamicView::OnJobResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType results,
     const ParameterFitBackgroundJob* pJob)
 {
   //Store the resulting parameter fit image via convenience helper function in data storage
   //(handles the correct generation of the nodes and their properties)
   mitk::modelFit::StoreResultsInDataStorage(this->GetDataStorage(), results, pJob->GetParentNode());
 
   m_Controls.errorMessageLabel->setText("");
   m_Controls.errorMessageLabel->hide();
 };
 
 void PETDynamicView::OnJobProgress(double progress)
 {
   QString report = QString("Progress. ") + QString::number(progress);
   this->m_Controls.infoBox->append(report);
 };
 
 void PETDynamicView::OnJobStatusChanged(QString info)
 {
   this->m_Controls.infoBox->append(info);
 }
 
 
 void PETDynamicView::InitModelComboBox() const
 {
   this->m_Controls.comboModel->clear();
   this->m_Controls.comboModel->addItem(tr("No model selected"));
 
   for (ModelFactoryStackType::const_iterator pos = m_FactoryStack.begin();
        pos != m_FactoryStack.end(); ++pos)
   {
     this->m_Controls.comboModel->addItem(QString::fromStdString((*pos)->GetClassID()));
   }
 
   this->m_Controls.comboModel->setCurrentIndex(0);
 };
 
 mitk::ModelFitFunctorBase::Pointer PETDynamicView::CreateDefaultFitFunctor(
   const mitk::ModelParameterizerBase* parameterizer) const
 {
   mitk::LevenbergMarquardtModelFitFunctor::Pointer fitFunctor =
     mitk::LevenbergMarquardtModelFitFunctor::New();
   mitk::SumOfSquaredDifferencesFitCostFunction::Pointer evaluation =
     mitk::SumOfSquaredDifferencesFitCostFunction::New();
 
   fitFunctor->RegisterEvaluationParameter("sum_diff^2", evaluation);
 
   mitk::ChiSquareFitCostFunction::Pointer chi2 =
           mitk::ChiSquareFitCostFunction::New();
   fitFunctor->RegisterEvaluationParameter("Chi^2", chi2);
 
   mitk::ReducedChiSquareFitCostFunction::Pointer redchi2 =
           mitk::ReducedChiSquareFitCostFunction::New();
   fitFunctor->RegisterEvaluationParameter("redChi^2", redchi2);
 
 
 
   if (m_Controls.checkBox_Constraints->isChecked())
   {
     fitFunctor->SetConstraintChecker(m_modelConstraints);
   }
 
   mitk::ModelBase::Pointer refModel = parameterizer->GenerateParameterizedModel();
 
   ::itk::LevenbergMarquardtOptimizer::ScalesType scales;
   scales.SetSize(refModel->GetNumberOfParameters());
   scales.Fill(1.0);
   fitFunctor->SetScales(scales);
 
   return fitFunctor.GetPointer();
 }
 
 void PETDynamicView::GetAIF(mitk::AIFBasedModelBase::AterialInputFunctionType& aif,
                              mitk::AIFBasedModelBase::AterialInputFunctionType& aifTimeGrid)
 {
   if (this->m_Controls.radioAIFFile->isChecked())
   {
     aif.clear();
     aifTimeGrid.clear();
 
     aif.SetSize(AIFinputFunction.size());
     aifTimeGrid.SetSize(AIFinputGrid.size());
 
     aif.fill(0.0);
     aifTimeGrid.fill(0.0);
 
     itk::Array<double>::iterator aifPos = aif.begin();
 
     for (std::vector<double>::const_iterator pos = AIFinputFunction.begin();
          pos != AIFinputFunction.end(); ++pos, ++aifPos)
     {
       *aifPos = *pos;
     }
 
     itk::Array<double>::iterator gridPos = aifTimeGrid.begin();
 
     for (std::vector<double>::const_iterator pos = AIFinputGrid.begin(); pos != AIFinputGrid.end();
          ++pos, ++gridPos)
     {
       *gridPos = *pos;
     }
   }
   else if (this->m_Controls.radioAIFImage->isChecked())
   {
     aif.clear();
     aifTimeGrid.clear();
 
     mitk::AterialInputFunctionGenerator::Pointer aifGenerator =
       mitk::AterialInputFunctionGenerator::New();
 
     //Hematocrit level
     aifGenerator->SetHCL(this->m_Controls.HCLSpinBox->value());
 
     //mask settings
     this->m_selectedAIFMaskNode = m_Controls.comboAIFMask->GetSelectedNode();
     this->m_selectedAIFMask = dynamic_cast<mitk::Image*>(this->m_selectedAIFMaskNode->GetData());
 
     if (this->m_selectedAIFMask->GetTimeSteps() > 1)
     {
       MITK_INFO <<
                 "Selected AIF mask has multiple timesteps. Only use first timestep to mask model fit. AIF Mask name: "
                 <<
                 m_selectedAIFMaskNode->GetName() ;
       mitk::ImageTimeSelector::Pointer maskedImageTimeSelector = mitk::ImageTimeSelector::New();
       maskedImageTimeSelector->SetInput(this->m_selectedAIFMask);
       maskedImageTimeSelector->SetTimeNr(0);
       maskedImageTimeSelector->UpdateLargestPossibleRegion();
       this->m_selectedAIFMask = maskedImageTimeSelector->GetOutput();
     }
 
     if (this->m_selectedAIFMask.IsNotNull())
     {
       aifGenerator->SetMask(this->m_selectedAIFMask);
     }
 
     //image settings
     if (this->m_Controls.checkDedicatedAIFImage->isChecked())
     {
       this->m_selectedAIFImageNode = m_Controls.comboAIFImage->GetSelectedNode();
       this->m_selectedAIFImage = dynamic_cast<mitk::Image*>(this->m_selectedAIFImageNode->GetData());
     }
     else
     {
       this->m_selectedAIFImageNode = m_selectedNode;
       this->m_selectedAIFImage = m_selectedImage;
     }
 
 
     aifGenerator->SetDynamicImage(this->m_selectedAIFImage);
 
     aif = aifGenerator->GetAterialInputFunction();
     aifTimeGrid = aifGenerator->GetAterialInputFunctionTimeGrid();
   }
   else
   {
     mitkThrow() << "Cannot generate AIF. View is in a invalide state. No AIF mode selected.";
   }
 
 }
 
 
 void PETDynamicView::LoadAIFfromFile()
 {
   QFileDialog dialog;
   dialog.setNameFilter(tr("Images (*.csv"));
 
   QString fileName = dialog.getOpenFileName();
 
   m_Controls.aifFilePath->setText(fileName);
 
   std::string m_aifFilePath = fileName.toStdString();
   //Read Input
   typedef boost::tokenizer< boost::escaped_list_separator<char> > Tokenizer;
   /////////////////////////////////////////////////////////////////////////////////////////////////
   //AIF Data
 
   std::ifstream in1(m_aifFilePath.c_str());
 
   if (!in1.is_open())
   {
     m_Controls.errorMessageLabel->setText("Could not open AIF File!");
   }
 
 
   std::vector< std::string > vec1;
   std::string line1;
 
   while (getline(in1, line1))
   {
     Tokenizer tok(line1);
     vec1.assign(tok.begin(), tok.end());
 
     //        if (vec1.size() < 3) continue;
 
     this->AIFinputGrid.push_back(convertToDouble(vec1[0]));
     this->AIFinputFunction.push_back(convertToDouble(vec1[1]));
 
   }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.pharmacokinetics.simulation/src/internal/PerfusionDataSimulationView.cpp b/Plugins/org.mitk.gui.qt.pharmacokinetics.simulation/src/internal/PerfusionDataSimulationView.cpp
index a26db880b6..bccc9b24bc 100644
--- a/Plugins/org.mitk.gui.qt.pharmacokinetics.simulation/src/internal/PerfusionDataSimulationView.cpp
+++ b/Plugins/org.mitk.gui.qt.pharmacokinetics.simulation/src/internal/PerfusionDataSimulationView.cpp
@@ -1,1004 +1,1004 @@
 /*===================================================================
 
 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 <QMessageBox>
 
 #include "mitkWorkbenchUtil.h"
 
 #include "PerfusionDataSimulationView.h"
 
 #include "itkUnaryFunctorImageFilter.h"
 #include <boost/tokenizer.hpp>
 #include "mitkImageCast.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkITKImageImport.h"
 #include "mitkGaussianNoiseFunctor.h"
 #include "mitkTwoCompartmentExchangeModel.h"
 #include "mitkTwoCompartmentExchangeModelParameterizer.h"
 #include "mitkTwoCompartmentExchangeModelFactory.h"
 #include "mitkNumericTwoCompartmentExchangeModel.h"
 #include "mitkNumericTwoCompartmentExchangeModelParameterizer.h"
 #include "mitkNumericTwoCompartmentExchangeModelFactory.h"
 #include "mitkExtendedToftsModel.h"
 #include "mitkExtendedToftsModelFactory.h"
 #include "mitkExtendedToftsModelParameterizer.h"
 #include "mitkTwoTissueCompartmentModel.h"
 #include "mitkTwoTissueCompartmentModelParameterizer.h"
 #include "mitkTwoTissueCompartmentModelFactory.h"
 #include "mitkOneTissueCompartmentModel.h"
 #include "mitkOneTissueCompartmentModelParameterizer.h"
 #include "mitkOneTissueCompartmentModelFactory.h"
 #include "mitkModelSignalImageGenerator.h"
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateDataType.h>
 #include "mitkSimpleFunctorBase.h"
 #include "mitkArbitraryTimeGeometry.h"
 #include <iostream>
  #include <QFileDialog>
 
 const std::string PerfusionDataSimulationView::VIEW_ID = "org.mitk.gui.qt.pharmacokinetics.simulation";
 
 inline double convertToDouble(const std::string& data)
 {
   std::istringstream stepStream(data);
   stepStream.imbue(std::locale("C"));
   double value = 0.0;
 
   if (!(stepStream >> value) || !(stepStream.eof()))
   {
     mitkThrow() << "Cannot convert string to double. String: " << data;
   }
   return value;
 }
 
 inline double FindeMaxConcentration(std::vector<double> Concentration)
 {
     double maximum = Concentration[0];
     for (std::vector<double>::size_type i =0; i<Concentration.size(); ++i)
     {
         maximum = std::max(maximum, Concentration[i]);
     }
 return maximum;
 }
 
 void PerfusionDataSimulationView::SetFocus()
 {
     m_Controls.GenerateBtn->setFocus();
 }
 
 void PerfusionDataSimulationView::CreateQtPartControl(QWidget* parent)
 {
 	m_Controls.setupUi(parent);
     m_Controls.GenerateBtn->setEnabled(false);
 
     m_Controls.groupBox_TM->hide();
     m_Controls.groupBox_2CXM->hide();
     m_Controls.groupBox_2TCM->hide();
     m_Controls.groupBox_1TCM->hide();
     m_Controls.groupBox_CNR->hide();
 
     this->InitModelComboBox();
     /** #2 @todo Reduce code ?
      */
 
     m_Controls.comboBox_F->SetDataStorage(this->GetDataStorage());
     m_Controls.comboBox_F->SetPredicate(m_IsNotABinaryImagePredicate);
 
     m_Controls.comboBox_PS->SetDataStorage(this->GetDataStorage());
     m_Controls.comboBox_PS->SetPredicate(m_IsNotABinaryImagePredicate);
 
     m_Controls.comboBox_fp->SetDataStorage(this->GetDataStorage());
     m_Controls.comboBox_fp->SetPredicate(m_IsNotABinaryImagePredicate);
 
     m_Controls.comboBox_fi->SetDataStorage(this->GetDataStorage());
     m_Controls.comboBox_fi->SetPredicate(m_IsNotABinaryImagePredicate);
 
     m_Controls.comboBox_Ktrans->SetDataStorage(this->GetDataStorage());
     m_Controls.comboBox_Ktrans->SetPredicate(m_IsNotABinaryImagePredicate);
 
     m_Controls.comboBox_vp->SetDataStorage(this->GetDataStorage());
     m_Controls.comboBox_vp->SetPredicate(m_IsNotABinaryImagePredicate);
 
     m_Controls.comboBox_ve->SetDataStorage(this->GetDataStorage());
     m_Controls.comboBox_ve->SetPredicate(m_IsNotABinaryImagePredicate);
 
     m_Controls.comboBox_K1->SetDataStorage(this->GetDataStorage());
     m_Controls.comboBox_K1->SetPredicate(m_IsNotABinaryImagePredicate);
 
     m_Controls.comboBox_K2->SetDataStorage(this->GetDataStorage());
     m_Controls.comboBox_K2->SetPredicate(m_IsNotABinaryImagePredicate);
 
     m_Controls.comboBox_K3->SetDataStorage(this->GetDataStorage());
     m_Controls.comboBox_K3->SetPredicate(m_IsNotABinaryImagePredicate);
 
     m_Controls.comboBox_K4->SetDataStorage(this->GetDataStorage());
     m_Controls.comboBox_K4->SetPredicate(m_IsNotABinaryImagePredicate);
 
     m_Controls.comboBox_VB->SetDataStorage(this->GetDataStorage());
     m_Controls.comboBox_VB->SetPredicate(m_IsNotABinaryImagePredicate);
 
     m_Controls.comboBox_k1->SetDataStorage(this->GetDataStorage());
     m_Controls.comboBox_k1->SetPredicate(m_IsNotABinaryImagePredicate);
 
     m_Controls.comboBox_k2->SetDataStorage(this->GetDataStorage());
     m_Controls.comboBox_k2->SetPredicate(m_IsNotABinaryImagePredicate);
 
     connect(m_Controls.AifFileBtn, SIGNAL(clicked()), this, SLOT(LoadAIFFile()));
     connect(m_Controls.ModelSelection, SIGNAL(currentIndexChanged(int)), this, SLOT(OnModellSet(int)));
     connect(m_Controls.GenerateBtn, SIGNAL(clicked()), this, SLOT(OnGenerateDataButtonClicked()));
     connect(m_Controls.comboBox_F, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSimulationConfigurationChanged()));
     connect(m_Controls.comboBox_PS, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSimulationConfigurationChanged()));
     connect(m_Controls.comboBox_fp, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSimulationConfigurationChanged()));
     connect(m_Controls.comboBox_fi, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSimulationConfigurationChanged()));
     connect(m_Controls.comboBox_VB, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSimulationConfigurationChanged()));
     connect(m_Controls.comboBox_K1, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSimulationConfigurationChanged()));
     connect(m_Controls.comboBox_K2, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSimulationConfigurationChanged()));
     connect(m_Controls.comboBox_K3, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSimulationConfigurationChanged()));
     connect(m_Controls.comboBox_K4, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSimulationConfigurationChanged()));
     connect(m_Controls.comboBox_k1, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSimulationConfigurationChanged()));
     connect(m_Controls.comboBox_k2, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSimulationConfigurationChanged()));
     connect(m_Controls.comboBox_Ktrans, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSimulationConfigurationChanged()));
     connect(m_Controls.comboBox_vp, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSimulationConfigurationChanged()));
     connect(m_Controls.comboBox_ve, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSimulationConfigurationChanged()));
     connect(m_Controls.CNRSpinBox, SIGNAL(valueChanged(double)),this, SLOT(OnSimulationConfigurationChanged()));
     connect(m_Controls.NoiseCheckBox, SIGNAL(stateChanged(int)),this, SLOT(OnSimulationConfigurationChanged()));
 
 //    UpdateDataSelection();
 
   }
 
 void PerfusionDataSimulationView::UpdateDataSelection()
 {
 
 
 }
 
 //void PerfusionDataSimulationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
 //    const QList<mitk::DataNode::Pointer>& selectedNodes)
 //{
 //    UpdateDataSelection();
 //    m_Controls.GenerateBtn->setEnabled(CheckModelSettings());
 
 //}
 
 void PerfusionDataSimulationView::OnSimulationConfigurationChanged()
 {
 //    UpdateDataSelection();
 
     m_Controls.groupBox_CNR->setVisible(m_Controls.NoiseCheckBox->isChecked());
 
     this->m_CNR = m_Controls.CNRSpinBox->value();
 
     m_Controls.GenerateBtn->setEnabled( CheckModelSettings() );
 
 
 }
 
 
 void PerfusionDataSimulationView::OnModellSet(int index)
 {
-  m_selectedModelFactory = NULL;
+  m_selectedModelFactory = nullptr;
 
   if (index > 0)
   {
     if (static_cast<ModelFactoryStackType::size_type>(index) <= m_FactoryStack.size() )
     {
         m_selectedModelFactory = m_FactoryStack[index - 1];
     }
     else
     {
         MITK_WARN << "Invalid model index. Index outside of the factory stack. Factory stack size: "<< m_FactoryStack.size() << "; invalid index: "<< index;
     }
   }
 
-  bool isToftsFactory = dynamic_cast<mitk::ExtendedToftsModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL;
-  bool is2CXMFactory = dynamic_cast<mitk::TwoCompartmentExchangeModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL || dynamic_cast<mitk::NumericTwoCompartmentExchangeModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL;
-  bool is2TCMFactory = dynamic_cast<mitk::TwoTissueCompartmentModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL;
-  bool is1TCMFactory = dynamic_cast<mitk::OneTissueCompartmentModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL;
+  bool isToftsFactory = dynamic_cast<mitk::ExtendedToftsModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr;
+  bool is2CXMFactory = dynamic_cast<mitk::TwoCompartmentExchangeModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr || dynamic_cast<mitk::NumericTwoCompartmentExchangeModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr;
+  bool is2TCMFactory = dynamic_cast<mitk::TwoTissueCompartmentModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr;
+  bool is1TCMFactory = dynamic_cast<mitk::OneTissueCompartmentModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr;
 
   m_Controls.groupBox_TM->setVisible(isToftsFactory);
   m_Controls.groupBox_2CXM->setVisible(is2CXMFactory );
   m_Controls.groupBox_2TCM->setVisible(is2TCMFactory );
   m_Controls.groupBox_1TCM->setVisible(is1TCMFactory );
 
 
   m_Controls.GenerateBtn->setEnabled( CheckModelSettings() );
 //  UpdateDataSelection();
 
 
 }
 
 bool PerfusionDataSimulationView::CheckModelSettings()
 {
     bool ok = true;
     if(m_selectedModelFactory.IsNull())
     {
         return false;
     }
 
     if(this->m_AterialInputFunction.GetSize() == 0 || this->m_TimeGrid.GetSize() == 0)
     {
         return false;
 
     }
 
-    bool isToftsFactory = dynamic_cast<mitk::ExtendedToftsModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL;
-    bool is2CXMFactory = dynamic_cast<mitk::TwoCompartmentExchangeModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL || dynamic_cast<mitk::NumericTwoCompartmentExchangeModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL;
-    bool is2TCMFactory = dynamic_cast<mitk::TwoTissueCompartmentModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL;
-    bool is1TCMFactory = dynamic_cast<mitk::OneTissueCompartmentModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL;
+    bool isToftsFactory = dynamic_cast<mitk::ExtendedToftsModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr;
+    bool is2CXMFactory = dynamic_cast<mitk::TwoCompartmentExchangeModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr || dynamic_cast<mitk::NumericTwoCompartmentExchangeModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr;
+    bool is2TCMFactory = dynamic_cast<mitk::TwoTissueCompartmentModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr;
+    bool is1TCMFactory = dynamic_cast<mitk::OneTissueCompartmentModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr;
 
 
     if(isToftsFactory)
     {
         ok = ok && m_Controls.comboBox_Ktrans->GetSelectedNode().IsNotNull();
         ok = ok && m_Controls.comboBox_vp->GetSelectedNode().IsNotNull();
         ok = ok && m_Controls.comboBox_ve->GetSelectedNode().IsNotNull();
     }
     else if(is2CXMFactory)
     {
         ok = ok && m_Controls.comboBox_F->GetSelectedNode().IsNotNull();
         ok = ok && m_Controls.comboBox_PS->GetSelectedNode().IsNotNull();
         ok = ok && m_Controls.comboBox_fp->GetSelectedNode().IsNotNull();
         ok = ok && m_Controls.comboBox_fi->GetSelectedNode().IsNotNull();
     }
 
     else if(is2TCMFactory)
     {
         ok = ok && m_Controls.comboBox_K1->GetSelectedNode().IsNotNull();
         ok = ok && m_Controls.comboBox_K2->GetSelectedNode().IsNotNull();
         ok = ok && m_Controls.comboBox_K3->GetSelectedNode().IsNotNull();
         ok = ok && m_Controls.comboBox_K4->GetSelectedNode().IsNotNull();
         ok = ok && m_Controls.comboBox_VB->GetSelectedNode().IsNotNull();
     }
     else if(is1TCMFactory)
     {
         ok = ok && m_Controls.comboBox_k1->GetSelectedNode().IsNotNull();
         ok = ok && m_Controls.comboBox_k2->GetSelectedNode().IsNotNull();
      }
 
     else
     {
         return false;
 
     }
     if(m_Controls.NoiseCheckBox->isChecked())
     {
         if(m_CNR !=0 && m_MaxConcentration !=0)
         {
             this->m_Sigma = m_MaxConcentration/m_CNR;
         }
         if(m_Sigma==0)
         {
             return false;
         }
     }
 
 
 
     return ok;
 
 }
 
 
 void PerfusionDataSimulationView::InitModelComboBox() const
 {
   this->m_Controls.ModelSelection->clear();
   this->m_Controls.ModelSelection->addItem(tr("No model selected"));
 
   for (ModelFactoryStackType::const_iterator pos = m_FactoryStack.begin(); pos != m_FactoryStack.end(); ++pos)
   {
     this->m_Controls.ModelSelection->addItem(QString::fromStdString((*pos)->GetClassID()));
   }
   this->m_Controls.ModelSelection->setCurrentIndex(0);
 };
 
 
 void PerfusionDataSimulationView::LoadAIFFile()
 {
   QFileDialog dialog;
   dialog.setNameFilter(tr("Images (*.csv"));
 
   QString fileName = dialog.getOpenFileName();
 
   m_Controls.AifFilePath->setText( fileName );
 
   std::string aifFilePath = fileName.toStdString();
 
   //Read Input
   typedef boost::tokenizer< boost::escaped_list_separator<char> > Tokenizer;
   /////////////////////////////////////////////////////////////////////////////////////////////////
   //AIF Data
 
   std::vector<double> inputFunction;
   std::vector<double> inputGrid;
 
   std::ifstream in1(aifFilePath.c_str());
 
   if(!in1.is_open())
   {
       m_Controls.errorMessageLabel->setText("Could not open AIF File!");
   }
 
 
   std::vector< std::string > vec1;
   std::string line1;
 
   while (getline(in1,line1))
   {
       Tokenizer tok(line1);
       vec1.assign(tok.begin(),tok.end());
 
 //        if (vec1.size() < 3) continue;
 
       inputGrid.push_back(convertToDouble(vec1[0]));
       inputFunction.push_back(convertToDouble(vec1[1]));
 
   }
 
   this->m_MaxConcentration = FindeMaxConcentration(inputFunction);
 
   itk::Array<double> aif;
   itk::Array<double> grid;
 
   aif.SetSize(inputFunction.size());
   grid.SetSize(inputGrid.size());
 
   aif.fill(0.0);
   grid.fill(0.0);
 
   itk::Array<double>::iterator aifPos = aif.begin();
   for(std::vector<double>::const_iterator pos = inputFunction.begin(); pos != inputFunction.end(); ++pos, ++aifPos)
   {
       *aifPos = *pos;
   }
   itk::Array<double>::iterator gridPos = grid.begin();
   for(std::vector<double>::const_iterator pos = inputGrid.begin(); pos != inputGrid.end(); ++pos, ++gridPos)
   {
       *gridPos = *pos;
   }
 
   this->m_AterialInputFunction = aif;
   this->m_TimeGrid = grid;
 
 
   m_Controls.GenerateBtn->setEnabled( CheckModelSettings() );
 //  UpdateDataSelection();
 
 
 
 }
 /** @todo #2 Same function for Numeric and analytic version of FillParameterMap2CXM
  */
 void PerfusionDataSimulationView::FillParameterMap2CXM()
 {
     ParameterMapType stack;
 
     mitk::DataNode::Pointer m_selectedNode = m_Controls.comboBox_F->GetSelectedNode();
     mitk::Image::Pointer m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::TwoCompartmentExchangeModel::NAME_PARAMETER_F,m_selectedImage));
 
     m_selectedNode = m_Controls.comboBox_PS->GetSelectedNode();
     m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::TwoCompartmentExchangeModel::NAME_PARAMETER_PS,m_selectedImage));
 
     m_selectedNode = m_Controls.comboBox_fp->GetSelectedNode();
     m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::TwoCompartmentExchangeModel::NAME_PARAMETER_vp,m_selectedImage));
 
     m_selectedNode = m_Controls.comboBox_fi->GetSelectedNode();
     m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::TwoCompartmentExchangeModel::NAME_PARAMETER_ve,m_selectedImage));
 
     this->m_ParameterImageMap = stack;
 
 }
 
 
 void PerfusionDataSimulationView::FillParameterMapNumeric2CXM()
 {
     ParameterMapType stack;
 
     mitk::DataNode::Pointer m_selectedNode = m_Controls.comboBox_F->GetSelectedNode();
     mitk::Image::Pointer m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::NumericTwoCompartmentExchangeModel::NAME_PARAMETER_F,m_selectedImage));
 
     m_selectedNode = m_Controls.comboBox_PS->GetSelectedNode();
     m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::NumericTwoCompartmentExchangeModel::NAME_PARAMETER_PS,m_selectedImage));
 
     m_selectedNode = m_Controls.comboBox_fp->GetSelectedNode();
     m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::NumericTwoCompartmentExchangeModel::NAME_PARAMETER_vp,m_selectedImage));
 
     m_selectedNode = m_Controls.comboBox_fi->GetSelectedNode();
     m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::NumericTwoCompartmentExchangeModel::NAME_PARAMETER_ve,m_selectedImage));
 
     this->m_ParameterImageMap = stack;
 
 }
 
 
 void PerfusionDataSimulationView::FillParameterMapETM()
 {
     ParameterMapType stack;
 
     mitk::DataNode::Pointer m_selectedNode = m_Controls.comboBox_Ktrans->GetSelectedNode();
     mitk::Image::Pointer m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::ExtendedToftsModel::NAME_PARAMETER_Ktrans,m_selectedImage));
 
     m_selectedNode = m_Controls.comboBox_vp->GetSelectedNode();
     m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::ExtendedToftsModel::NAME_PARAMETER_vp,m_selectedImage));
 
     m_selectedNode = m_Controls.comboBox_ve->GetSelectedNode();
     m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::ExtendedToftsModel::NAME_PARAMETER_ve,m_selectedImage));
 
 
     this->m_ParameterImageMap = stack;
 
 }
 
 void PerfusionDataSimulationView::FillParameterMap2TCM()
 {
     ParameterMapType stack;
 
     mitk::DataNode::Pointer m_selectedNode = m_Controls.comboBox_K1->GetSelectedNode();
     mitk::Image::Pointer m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::TwoTissueCompartmentModel::NAME_PARAMETER_K1,m_selectedImage));
 
     m_selectedNode = m_Controls.comboBox_K2->GetSelectedNode();
     m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::TwoTissueCompartmentModel::NAME_PARAMETER_k2,m_selectedImage));
 
     m_selectedNode = m_Controls.comboBox_K3->GetSelectedNode();
     m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::TwoTissueCompartmentModel::NAME_PARAMETER_k3,m_selectedImage));
 
     m_selectedNode = m_Controls.comboBox_K4->GetSelectedNode();
     m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::TwoTissueCompartmentModel::NAME_PARAMETER_k4,m_selectedImage));
 
     m_selectedNode = m_Controls.comboBox_VB->GetSelectedNode();
     m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::TwoTissueCompartmentModel::NAME_PARAMETER_VB,m_selectedImage));
 
     this->m_ParameterImageMap = stack;
 
 }
 
 void PerfusionDataSimulationView::FillParameterMap1TCM()
 {
     ParameterMapType stack;
 
     mitk::DataNode::Pointer m_selectedNode = m_Controls.comboBox_k1->GetSelectedNode();
     mitk::Image::Pointer m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::OneTissueCompartmentModel::NAME_PARAMETER_k1,m_selectedImage));
 
     m_selectedNode = m_Controls.comboBox_k2->GetSelectedNode();
     m_selectedImage = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     stack.insert(std::make_pair(mitk::OneTissueCompartmentModel::NAME_PARAMETER_k2,m_selectedImage));
 
     this->m_ParameterImageMap = stack;
 
 }
 
 void PerfusionDataSimulationView::OnGenerateDataButtonClicked()
 {
     mitk::Image::Pointer m_DynamicImage = mitk::Image::New();
 
-    bool isToftsFactory = dynamic_cast<mitk::ExtendedToftsModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL;
-    bool isPhysBrixFactory = dynamic_cast<mitk::TwoCompartmentExchangeModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL;
-    bool isNumPhysBrixFactory = dynamic_cast<mitk::NumericTwoCompartmentExchangeModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL;
-    bool is2TCMFactory = dynamic_cast<mitk::TwoTissueCompartmentModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL;
-    bool is1TCMFactory = dynamic_cast<mitk::OneTissueCompartmentModelFactory*>(m_selectedModelFactory.GetPointer()) != NULL;
+    bool isToftsFactory = dynamic_cast<mitk::ExtendedToftsModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr;
+    bool isPhysBrixFactory = dynamic_cast<mitk::TwoCompartmentExchangeModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr;
+    bool isNumPhysBrixFactory = dynamic_cast<mitk::NumericTwoCompartmentExchangeModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr;
+    bool is2TCMFactory = dynamic_cast<mitk::TwoTissueCompartmentModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr;
+    bool is1TCMFactory = dynamic_cast<mitk::OneTissueCompartmentModelFactory*>(m_selectedModelFactory.GetPointer()) != nullptr;
 
 
     if(isToftsFactory)
     {
        this->FillParameterMapETM();
         m_DynamicImage = this->GenerateETModelData();
     }
 
     if (isPhysBrixFactory)
     {
         this->FillParameterMap2CXM();
         m_DynamicImage = this->Generate2CXModelData();
     }
 
     if (isNumPhysBrixFactory)
     {
         this->FillParameterMapNumeric2CXM();
         m_DynamicImage = this->GenerateNumeric2CXModelData();
     }
 
     if (is2TCMFactory)
     {
         this->FillParameterMap2TCM();
         m_DynamicImage = this->Generate2TCModelData();
     }
     if (is1TCMFactory)
     {
         this->FillParameterMap1TCM();
         m_DynamicImage = this->Generate1TCModelData();
     }
 
 
 
     mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
     std::string nameOfResultImage = "SimulationData_";
     nameOfResultImage.append(m_selectedModelFactory->GetModelDisplayName());
     resultNode->SetProperty("name", mitk::StringProperty::New(nameOfResultImage) );
     resultNode->SetData(m_DynamicImage); // set data of new node
     this->GetDataStorage()->Add(resultNode);
 
 
 }
 
 mitk::Image::Pointer PerfusionDataSimulationView::Generate2CXModelData()
 {
 mitk::ModelSignalImageGenerator::Pointer generator = mitk::ModelSignalImageGenerator::New();
 mitk::TwoCompartmentExchangeModelParameterizer::Pointer modelParameterizer = mitk::TwoCompartmentExchangeModelParameterizer::New();
 
 /** @todo #2  necessary? Generator need to have a map with Parameters in order of Model in order to pass vector parameters correctly to Model.
  * I wanted to make it independend from the order the images are passed on
  */
 for(ParameterMapType::const_iterator pos = this->m_ParameterImageMap.begin(); pos != this->m_ParameterImageMap.end(); ++pos)
 {
     if(pos->first == mitk::TwoCompartmentExchangeModel::NAME_PARAMETER_F)
     {
         generator->SetParameterInputImage(mitk::TwoCompartmentExchangeModel::POSITION_PARAMETER_F, pos->second);
     }
     if(pos->first == mitk::TwoCompartmentExchangeModel::NAME_PARAMETER_PS)
     {
         generator->SetParameterInputImage(mitk::TwoCompartmentExchangeModel::POSITION_PARAMETER_PS, pos->second);
     }
     if(pos->first == mitk::TwoCompartmentExchangeModel::NAME_PARAMETER_ve)
     {
         generator->SetParameterInputImage(mitk::TwoCompartmentExchangeModel::POSITION_PARAMETER_ve, pos->second);
     }
     if(pos->first == mitk::TwoCompartmentExchangeModel::NAME_PARAMETER_vp)
     {
         generator->SetParameterInputImage(mitk::TwoCompartmentExchangeModel::POSITION_PARAMETER_vp, pos->second);
     }
 }
 
 modelParameterizer->SetAIF(this->m_AterialInputFunction);
 modelParameterizer->SetAIFTimeGrid(this->m_TimeGrid);
 modelParameterizer->SetDefaultTimeGrid(this->m_TimeGrid);
 
 generator->SetParameterizer(modelParameterizer);
 
 mitk::Image::Pointer generatedImage = generator->GetGeneratedImage();
 
  mitk::Image::Pointer resultImage = mitk::Image::New();
 if(m_Controls.NoiseCheckBox->isChecked())
 {
     typedef itk::Image<double,3> ImageType;
 
     mitk::Image::Pointer tempImage = mitk::Image::New();
     tempImage->Initialize(generatedImage);
 
     mitk::ArbitraryTimeGeometry* timeGeometry = dynamic_cast<mitk::ArbitraryTimeGeometry*> (generatedImage->GetTimeGeometry());
 
     tempImage->SetTimeGeometry(timeGeometry);
 
     ImageType::Pointer itkImage = ImageType::New();
     mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
     imageTimeSelector->SetInput(generatedImage);
 
     for(unsigned int i = 0; i< generatedImage->GetTimeSteps(); ++i)
     {
         imageTimeSelector->SetTimeNr(i);
         imageTimeSelector->UpdateLargestPossibleRegion();
 
         mitk::Image::Pointer mitkInputImage = imageTimeSelector->GetOutput();
 
         mitk::CastToItkImage(mitkInputImage, itkImage );
 
         typedef mitk::GaussianNoiseFunctor<double,double> NoiseFunctorType;
         typedef itk::UnaryFunctorImageFilter<ImageType,ImageType, NoiseFunctorType > NoiseFilterType;
         NoiseFilterType::Pointer noiseFilter = NoiseFilterType::New();
         NoiseFunctorType noiseFunctor;
         noiseFunctor.SetMean(0.0);
         noiseFunctor.SetSigma(this->m_Sigma);
         noiseFilter->SetFunctor(noiseFunctor);
 
         noiseFilter->SetInput(itkImage);
 
         mitk::Image::Pointer outputImage = mitk::ImportItkImage(noiseFilter->GetOutput())->Clone();
 
         mitk::ImageReadAccessor accessor(outputImage);
         tempImage->SetVolume(accessor.GetData(), i);
     }
 
    resultImage = tempImage->Clone();
 }
 else
 {
     resultImage = generatedImage;
 }
 return resultImage;
 }
 
 
 /** @todo #2  Synergie? Function implementation for every Model to complicated?
  */
 mitk::Image::Pointer PerfusionDataSimulationView::GenerateNumeric2CXModelData()
 {
 mitk::ModelSignalImageGenerator::Pointer generator = mitk::ModelSignalImageGenerator::New();
 mitk::NumericTwoCompartmentExchangeModelParameterizer::Pointer modelParameterizer = mitk::NumericTwoCompartmentExchangeModelParameterizer::New();
 
 for(ParameterMapType::const_iterator pos = this->m_ParameterImageMap.begin(); pos != this->m_ParameterImageMap.end(); ++pos)
 {
     if(pos->first == mitk::NumericTwoCompartmentExchangeModel::NAME_PARAMETER_F)
     {
         generator->SetParameterInputImage(mitk::NumericTwoCompartmentExchangeModel::POSITION_PARAMETER_F, pos->second);
     }
     if(pos->first == mitk::NumericTwoCompartmentExchangeModel::NAME_PARAMETER_PS)
     {
         generator->SetParameterInputImage(mitk::NumericTwoCompartmentExchangeModel::POSITION_PARAMETER_PS, pos->second);
     }
     if(pos->first == mitk::NumericTwoCompartmentExchangeModel::NAME_PARAMETER_ve)
     {
         generator->SetParameterInputImage(mitk::NumericTwoCompartmentExchangeModel::POSITION_PARAMETER_ve, pos->second);
     }
     if(pos->first == mitk::NumericTwoCompartmentExchangeModel::NAME_PARAMETER_vp)
     {
         generator->SetParameterInputImage(mitk::NumericTwoCompartmentExchangeModel::POSITION_PARAMETER_vp, pos->second);
     }
 }
 
 modelParameterizer->SetAIF(this->m_AterialInputFunction);
 modelParameterizer->SetAIFTimeGrid(this->m_TimeGrid);
 modelParameterizer->SetDefaultTimeGrid(this->m_TimeGrid);
 modelParameterizer->SetODEINTStepSize(0.05);
 
 generator->SetParameterizer(modelParameterizer);
 
 mitk::Image::Pointer generatedImage = generator->GetGeneratedImage();
 
 
 mitk::Image::Pointer resultImage = mitk::Image::New();
 if(m_Controls.NoiseCheckBox->isChecked())
 {
    typedef itk::Image<double,3> ImageType;
 
    mitk::Image::Pointer tempImage = mitk::Image::New();
    tempImage->Initialize(generatedImage);
 
    mitk::ArbitraryTimeGeometry* timeGeometry = dynamic_cast<mitk::ArbitraryTimeGeometry*> (generatedImage->GetTimeGeometry());
 
    tempImage->SetTimeGeometry(timeGeometry);
 
    ImageType::Pointer itkImage = ImageType::New();
    mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
    imageTimeSelector->SetInput(generatedImage);
 
    for(unsigned int i = 0; i< generatedImage->GetTimeSteps(); ++i)
    {
        imageTimeSelector->SetTimeNr(i);
        imageTimeSelector->UpdateLargestPossibleRegion();
 
        mitk::Image::Pointer mitkInputImage = imageTimeSelector->GetOutput();
 
        mitk::CastToItkImage(mitkInputImage, itkImage );
 
        typedef mitk::GaussianNoiseFunctor<double,double> NoiseFunctorType;
        typedef itk::UnaryFunctorImageFilter<ImageType,ImageType, NoiseFunctorType > NoiseFilterType;
        NoiseFilterType::Pointer noiseFilter = NoiseFilterType::New();
        NoiseFunctorType noiseFunctor;
        noiseFunctor.SetMean(0.0);
        noiseFunctor.SetSigma(this->m_Sigma);
        noiseFilter->SetFunctor(noiseFunctor);
 
        noiseFilter->SetInput(itkImage);
 
        mitk::Image::Pointer outputImage = mitk::ImportItkImage(noiseFilter->GetOutput())->Clone();
 
        mitk::ImageReadAccessor accessor(outputImage);
        tempImage->SetVolume(accessor.GetData(), i);
    }
 
   resultImage = tempImage->Clone();
 }
 else
 {
    resultImage = generatedImage;
 }
 return resultImage;
 }
 
 mitk::Image::Pointer PerfusionDataSimulationView::GenerateETModelData()
 {
 mitk::ModelSignalImageGenerator::Pointer generator = mitk::ModelSignalImageGenerator::New();
 mitk::ExtendedToftsModelParameterizer::Pointer modelParameterizer = mitk::ExtendedToftsModelParameterizer::New();
 
 for(ParameterMapType::const_iterator pos = this->m_ParameterImageMap.begin(); pos != this->m_ParameterImageMap.end(); ++pos)
 {
     if(pos->first == mitk::ExtendedToftsModel::NAME_PARAMETER_Ktrans)
     {
         generator->SetParameterInputImage(mitk::ExtendedToftsModel::POSITION_PARAMETER_Ktrans, pos->second);
     }
     if(pos->first == mitk::ExtendedToftsModel::NAME_PARAMETER_vp)
     {
         generator->SetParameterInputImage(mitk::ExtendedToftsModel::POSITION_PARAMETER_vp, pos->second);
     }
     if(pos->first == mitk::ExtendedToftsModel::NAME_PARAMETER_ve)
     {
         generator->SetParameterInputImage(mitk::ExtendedToftsModel::POSITION_PARAMETER_ve, pos->second);
     }
 
 }
 
 modelParameterizer->SetAIF(this->m_AterialInputFunction);
 modelParameterizer->SetAIFTimeGrid(this->m_TimeGrid);
 modelParameterizer->SetDefaultTimeGrid(this->m_TimeGrid);
 
 generator->SetParameterizer(modelParameterizer);
 
 mitk::Image::Pointer generatedImage = generator->GetGeneratedImage();
 
 
 mitk::Image::Pointer resultImage = mitk::Image::New();
 if(m_Controls.NoiseCheckBox->isChecked())
 {
    typedef itk::Image<double,3> ImageType;
 
    mitk::Image::Pointer tempImage = mitk::Image::New();
    tempImage->Initialize(generatedImage);
 
    mitk::ArbitraryTimeGeometry* timeGeometry = dynamic_cast<mitk::ArbitraryTimeGeometry*> (generatedImage->GetTimeGeometry());
 
    tempImage->SetTimeGeometry(timeGeometry);
 
    ImageType::Pointer itkImage = ImageType::New();
    mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
    imageTimeSelector->SetInput(generatedImage);
 
    for(unsigned int i = 0; i< generatedImage->GetTimeSteps(); ++i)
    {
        imageTimeSelector->SetTimeNr(i);
        imageTimeSelector->UpdateLargestPossibleRegion();
 
        mitk::Image::Pointer mitkInputImage = imageTimeSelector->GetOutput();
 
        mitk::CastToItkImage(mitkInputImage, itkImage );
 
        typedef mitk::GaussianNoiseFunctor<double,double> NoiseFunctorType;
        typedef itk::UnaryFunctorImageFilter<ImageType,ImageType, NoiseFunctorType > NoiseFilterType;
        NoiseFilterType::Pointer noiseFilter = NoiseFilterType::New();
        NoiseFunctorType noiseFunctor;
        noiseFunctor.SetMean(0.0);
        noiseFunctor.SetSigma(this->m_Sigma);
        noiseFilter->SetFunctor(noiseFunctor);
 
        noiseFilter->SetInput(itkImage);
 
        mitk::Image::Pointer outputImage = mitk::ImportItkImage(noiseFilter->GetOutput())->Clone();
 
        mitk::ImageReadAccessor accessor(outputImage);
        tempImage->SetVolume(accessor.GetData(), i);
    }
 
   resultImage = tempImage->Clone();
 }
 else
 {
    resultImage = generatedImage;
 }
 return resultImage;
 }
 
 
 mitk::Image::Pointer PerfusionDataSimulationView::Generate2TCModelData()
 {
 mitk::ModelSignalImageGenerator::Pointer generator = mitk::ModelSignalImageGenerator::New();
 mitk::TwoTissueCompartmentModelParameterizer::Pointer modelParameterizer = mitk::TwoTissueCompartmentModelParameterizer::New();
 
 
 for(ParameterMapType::const_iterator pos = this->m_ParameterImageMap.begin(); pos != this->m_ParameterImageMap.end(); ++pos)
 {
     if(pos->first == mitk::TwoTissueCompartmentModel::NAME_PARAMETER_K1)
     {
         generator->SetParameterInputImage(mitk::TwoTissueCompartmentModel::POSITION_PARAMETER_K1, pos->second);
     }
     if(pos->first == mitk::TwoTissueCompartmentModel::NAME_PARAMETER_k2)
     {
         generator->SetParameterInputImage(mitk::TwoTissueCompartmentModel::POSITION_PARAMETER_k2, pos->second);
     }
     if(pos->first == mitk::TwoTissueCompartmentModel::NAME_PARAMETER_k3)
     {
         generator->SetParameterInputImage(mitk::TwoTissueCompartmentModel::POSITION_PARAMETER_k3, pos->second);
     }
     if(pos->first == mitk::TwoTissueCompartmentModel::NAME_PARAMETER_k4)
     {
         generator->SetParameterInputImage(mitk::TwoTissueCompartmentModel::POSITION_PARAMETER_k4, pos->second);
     }
     if(pos->first == mitk::TwoTissueCompartmentModel::NAME_PARAMETER_VB)
     {
         generator->SetParameterInputImage(mitk::TwoTissueCompartmentModel::POSITION_PARAMETER_VB, pos->second);
     }
 
 }
 
 modelParameterizer->SetAIF(this->m_AterialInputFunction);
 modelParameterizer->SetAIFTimeGrid(this->m_TimeGrid);
 modelParameterizer->SetDefaultTimeGrid(this->m_TimeGrid);
 
 generator->SetParameterizer(modelParameterizer);
 
 mitk::Image::Pointer generatedImage = generator->GetGeneratedImage();
 
  mitk::Image::Pointer resultImage = mitk::Image::New();
 if(m_Controls.NoiseCheckBox->isChecked())
 {
     typedef itk::Image<double,3> ImageType;
 
     mitk::Image::Pointer tempImage = mitk::Image::New();
     tempImage->Initialize(generatedImage);
 
     mitk::ArbitraryTimeGeometry* timeGeometry = dynamic_cast<mitk::ArbitraryTimeGeometry*> (generatedImage->GetTimeGeometry());
 
     tempImage->SetTimeGeometry(timeGeometry);
 
     ImageType::Pointer itkImage = ImageType::New();
     mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
     imageTimeSelector->SetInput(generatedImage);
 
     for(unsigned int i = 0; i< generatedImage->GetTimeSteps(); ++i)
     {
         imageTimeSelector->SetTimeNr(i);
         imageTimeSelector->UpdateLargestPossibleRegion();
 
         mitk::Image::Pointer mitkInputImage = imageTimeSelector->GetOutput();
 
         mitk::CastToItkImage(mitkInputImage, itkImage );
 
         typedef mitk::GaussianNoiseFunctor<double,double> NoiseFunctorType;
         typedef itk::UnaryFunctorImageFilter<ImageType,ImageType, NoiseFunctorType > NoiseFilterType;
         NoiseFilterType::Pointer noiseFilter = NoiseFilterType::New();
         NoiseFunctorType noiseFunctor;
         noiseFunctor.SetMean(0.0);
         noiseFunctor.SetSigma(this->m_Sigma);
         noiseFilter->SetFunctor(noiseFunctor);
 
         noiseFilter->SetInput(itkImage);
 
         mitk::Image::Pointer outputImage = mitk::ImportItkImage(noiseFilter->GetOutput())->Clone();
 
         mitk::ImageReadAccessor accessor(outputImage);
         tempImage->SetVolume(accessor.GetData(), i);
     }
 
    resultImage = tempImage->Clone();
 }
 else
 {
     resultImage = generatedImage;
 }
 return resultImage;
 }
 
 
 mitk::Image::Pointer PerfusionDataSimulationView::Generate1TCModelData()
 {
 mitk::ModelSignalImageGenerator::Pointer generator = mitk::ModelSignalImageGenerator::New();
 mitk::OneTissueCompartmentModelParameterizer::Pointer modelParameterizer = mitk::OneTissueCompartmentModelParameterizer::New();
 
 
 for(ParameterMapType::const_iterator pos = this->m_ParameterImageMap.begin(); pos != this->m_ParameterImageMap.end(); ++pos)
 {
     if(pos->first == mitk::OneTissueCompartmentModel::NAME_PARAMETER_k1)
     {
         generator->SetParameterInputImage(mitk::OneTissueCompartmentModel::POSITION_PARAMETER_k1, pos->second);
     }
     if(pos->first == mitk::OneTissueCompartmentModel::NAME_PARAMETER_k2)
     {
         generator->SetParameterInputImage(mitk::OneTissueCompartmentModel::POSITION_PARAMETER_k2, pos->second);
     }
 
 }
 
 modelParameterizer->SetAIF(this->m_AterialInputFunction);
 modelParameterizer->SetAIFTimeGrid(this->m_TimeGrid);
 modelParameterizer->SetDefaultTimeGrid(this->m_TimeGrid);
 
 generator->SetParameterizer(modelParameterizer);
 
 mitk::Image::Pointer generatedImage = generator->GetGeneratedImage();
 
  mitk::Image::Pointer resultImage = mitk::Image::New();
 if(m_Controls.NoiseCheckBox->isChecked())
 {
     typedef itk::Image<double,3> ImageType;
 
     mitk::Image::Pointer tempImage = mitk::Image::New();
     tempImage->Initialize(generatedImage);
 
     mitk::ArbitraryTimeGeometry* timeGeometry = dynamic_cast<mitk::ArbitraryTimeGeometry*> (generatedImage->GetTimeGeometry());
 
     tempImage->SetTimeGeometry(timeGeometry);
 
     ImageType::Pointer itkImage = ImageType::New();
     mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
     imageTimeSelector->SetInput(generatedImage);
 
     for(unsigned int i = 0; i< generatedImage->GetTimeSteps(); ++i)
     {
         imageTimeSelector->SetTimeNr(i);
         imageTimeSelector->UpdateLargestPossibleRegion();
 
         mitk::Image::Pointer mitkInputImage = imageTimeSelector->GetOutput();
 
         mitk::CastToItkImage(mitkInputImage, itkImage );
 
         typedef mitk::GaussianNoiseFunctor<double,double> NoiseFunctorType;
         typedef itk::UnaryFunctorImageFilter<ImageType,ImageType, NoiseFunctorType > NoiseFilterType;
         NoiseFilterType::Pointer noiseFilter = NoiseFilterType::New();
         NoiseFunctorType noiseFunctor;
         noiseFunctor.SetMean(0.0);
         noiseFunctor.SetSigma(this->m_Sigma);
         noiseFilter->SetFunctor(noiseFunctor);
 
         noiseFilter->SetInput(itkImage);
 
         mitk::Image::Pointer outputImage = mitk::ImportItkImage(noiseFilter->GetOutput())->Clone();
 
         mitk::ImageReadAccessor accessor(outputImage);
         tempImage->SetVolume(accessor.GetData(), i);
     }
 
    resultImage = tempImage->Clone();
 }
 else
 {
     resultImage = generatedImage;
 }
 return resultImage;
 }
 
 
 PerfusionDataSimulationView::PerfusionDataSimulationView()
 {
      m_Sigma = 0;
      m_CNR=0;
      m_MaxConcentration=0;
-     m_selectedModelFactory = NULL;
+     m_selectedModelFactory = nullptr;
 
 
      mitk::ModelFactoryBase::Pointer factory = mitk::ExtendedToftsModelFactory::New().GetPointer();
      m_FactoryStack.push_back(factory);
      factory = mitk::TwoCompartmentExchangeModelFactory::New().GetPointer();
      m_FactoryStack.push_back(factory);
      factory = mitk::NumericTwoCompartmentExchangeModelFactory::New().GetPointer();
      m_FactoryStack.push_back(factory);
      factory = mitk::TwoTissueCompartmentModelFactory::New().GetPointer();
      m_FactoryStack.push_back(factory);
      factory = mitk::OneTissueCompartmentModelFactory::New().GetPointer();
      m_FactoryStack.push_back(factory);
 
 
 
      m_IsNotABinaryImagePredicate = mitk::NodePredicateAnd::New(
                  mitk::TNodePredicateDataType<mitk::Image>::New(),
                  mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true))),
                  mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))).GetPointer();
 
 }
diff --git a/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/src/internal/PAImageProcessing.cpp b/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/src/internal/PAImageProcessing.cpp
index 2a72c7db02..2ca878ddc2 100644
--- a/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/src/internal/PAImageProcessing.cpp
+++ b/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/src/internal/PAImageProcessing.cpp
@@ -1,1147 +1,1147 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "PAImageProcessing.h"
 
 // Qt
 #include <QMessageBox>
 #include <QApplication>
 #include <QMetaType>
 #include <QFileDialog>
 
 //mitk image
 #include <mitkImage.h>
 #include "mitkPhotoacousticFilterService.h"
 #include "mitkCastToFloatImageFilter.h"
 #include "mitkBeamformingFilter.h"
 
 //other
 #include <thread>
 #include <functional>
 #include <mitkIOUtil.h>
 
 #define GPU_BATCH_SIZE 32
 
 const std::string PAImageProcessing::VIEW_ID = "org.mitk.views.paimageprocessing";
 
 PAImageProcessing::PAImageProcessing() : m_ResampleSpacing(0), m_UseLogfilter(false), m_FilterBank(mitk::PhotoacousticFilterService::New())
 {
   qRegisterMetaType<mitk::Image::Pointer>();
   qRegisterMetaType<std::string>();
 }
 
 void PAImageProcessing::SetFocus()
 {
   m_Controls.buttonApplyBModeFilter->setFocus();
 }
 
 void PAImageProcessing::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   connect(m_Controls.buttonApplyBModeFilter, SIGNAL(clicked()), this, SLOT(StartBmodeThread()));
   connect(m_Controls.Geometry, SIGNAL(currentIndexChanged(int)), this, SLOT(ChangedProbe()));
   connect(m_Controls.DoResampling, SIGNAL(clicked()), this, SLOT(UseResampling()));
   connect(m_Controls.Logfilter, SIGNAL(clicked()), this, SLOT(UseLogfilter()));
   connect(m_Controls.ResamplingValue, SIGNAL(valueChanged(double)), this, SLOT(SetResampling()));
   connect(m_Controls.buttonApplyBeamforming, SIGNAL(clicked()), this, SLOT(StartBeamformingThread()));
   connect(m_Controls.buttonApplyCropFilter, SIGNAL(clicked()), this, SLOT(StartCropThread()));
   connect(m_Controls.buttonApplyBandpass, SIGNAL(clicked()), this, SLOT(StartBandpassThread()));
   connect(m_Controls.UseImageSpacing, SIGNAL(clicked()), this, SLOT(UseImageSpacing()));
   connect(m_Controls.ScanDepth, SIGNAL(valueChanged(double)), this, SLOT(UpdateImageInfo()));
   connect(m_Controls.SpeedOfSound, SIGNAL(valueChanged(double)), this, SLOT(UpdateImageInfo()));
   connect(m_Controls.SpeedOfSound, SIGNAL(valueChanged(double)), this, SLOT(ChangedSOSBeamforming()));
   connect(m_Controls.BPSpeedOfSound, SIGNAL(valueChanged(double)), this, SLOT(ChangedSOSBandpass()));
   connect(m_Controls.Samples, SIGNAL(valueChanged(int)), this, SLOT(UpdateImageInfo()));
   connect(m_Controls.UseImageSpacing, SIGNAL(clicked()), this, SLOT(UpdateImageInfo()));
   connect(m_Controls.boundLow, SIGNAL(valueChanged(int)), this, SLOT(LowerSliceBoundChanged()));
   connect(m_Controls.boundHigh, SIGNAL(valueChanged(int)), this, SLOT(UpperSliceBoundChanged()));
   connect(m_Controls.Partial, SIGNAL(clicked()), this, SLOT(SliceBoundsEnabled()));
   connect(m_Controls.BatchProcessing, SIGNAL(clicked()), this, SLOT(BatchProcessing()));
   connect(m_Controls.StepBeamforming, SIGNAL(clicked()), this, SLOT(UpdateSaveBoxes()));
   connect(m_Controls.StepCropping, SIGNAL(clicked()), this, SLOT(UpdateSaveBoxes()));
   connect(m_Controls.StepBandpass, SIGNAL(clicked()), this, SLOT(UpdateSaveBoxes()));
   connect(m_Controls.StepBMode, SIGNAL(clicked()), this, SLOT(UpdateSaveBoxes()));
   connect(m_Controls.UseSignalDelay, SIGNAL(clicked()), this, SLOT(UseSignalDelay()));
   connect(m_Controls.IsBFImage, SIGNAL(clicked()), this, SLOT(UpdateImageInfo()));
   UpdateSaveBoxes();
   UseSignalDelay();
   m_Controls.DoResampling->setChecked(false);
   m_Controls.ResamplingValue->setEnabled(false);
   m_Controls.progressBar->setMinimum(0);
   m_Controls.progressBar->setMaximum(100);
   m_Controls.progressBar->setVisible(false);
   m_Controls.UseImageSpacing->setToolTip("Image spacing of y-Axis must be in us, x-Axis in mm.");
   m_Controls.UseImageSpacing->setToolTipDuration(5000);
   m_Controls.ProgressInfo->setVisible(false);
   m_Controls.UseGPUBmode->hide();
 
 #ifndef PHOTOACOUSTICS_USE_GPU
   m_Controls.UseGPUBf->setEnabled(false);
   m_Controls.UseGPUBf->setChecked(false);
   m_Controls.UseGPUBmode->setEnabled(false);
   m_Controls.UseGPUBmode->setChecked(false);
 #endif
 
   UseImageSpacing();
   ChangedProbe();
 }
 
 void PAImageProcessing::ChangedProbe()
 {
   if (m_Controls.Geometry->currentText() == "Concave")
   {
     m_Controls.ProbeRadius->setEnabled(true);
   }
   else
   {
     m_Controls.ProbeRadius->setEnabled(false);
   }
 }
 
 void PAImageProcessing::UseSignalDelay()
 {
   if (m_Controls.UseSignalDelay->isChecked())
   {
     m_Controls.SignalDelay->setEnabled(true);
   }
   else
   {
     m_Controls.SignalDelay->setEnabled(false);
   }
 }
 
 void PAImageProcessing::ChangedSOSBandpass()
 {
   m_Controls.SpeedOfSound->setValue(m_Controls.BPSpeedOfSound->value());
 }
 
 void PAImageProcessing::ChangedSOSBeamforming()
 {
   m_Controls.BPSpeedOfSound->setValue(m_Controls.SpeedOfSound->value());
 }
 
 std::vector<std::string> splitpath(
   const std::string& str
   , const std::set<char> delimiters)
 {
   std::vector<std::string> result;
 
   char const* pch = str.c_str();
   char const* start = pch;
   for (; *pch; ++pch)
   {
     if (delimiters.find(*pch) != delimiters.end())
     {
       if (start != pch)
       {
         std::string str(start, pch);
         result.push_back(str);
       }
       else
       {
         result.push_back("");
       }
       start = pch + 1;
     }
   }
   result.push_back(start);
 
   return result;
 }
 
 void PAImageProcessing::UpdateSaveBoxes()
 {
   if (m_Controls.StepBeamforming->isChecked())
     m_Controls.SaveBeamforming->setEnabled(true);
   else
     m_Controls.SaveBeamforming->setEnabled(false);
 
   if (m_Controls.StepCropping->isChecked())
     m_Controls.SaveCropping->setEnabled(true);
   else
     m_Controls.SaveCropping->setEnabled(false);
 
   if (m_Controls.StepBandpass->isChecked())
     m_Controls.SaveBandpass->setEnabled(true);
   else
     m_Controls.SaveBandpass->setEnabled(false);
 
   if (m_Controls.StepBMode->isChecked())
     m_Controls.SaveBMode->setEnabled(true);
   else
     m_Controls.SaveBMode->setEnabled(false);
 }
 
 void PAImageProcessing::BatchProcessing()
 {
   QFileDialog LoadDialog(nullptr, "Select Files to be processed");
   LoadDialog.setFileMode(QFileDialog::FileMode::ExistingFiles);
   LoadDialog.setNameFilter(tr("Images (*.nrrd)"));
   LoadDialog.setViewMode(QFileDialog::Detail);
 
   QStringList fileNames;
   if (LoadDialog.exec())
     fileNames = LoadDialog.selectedFiles();
 
   QString saveDir = QFileDialog::getExistingDirectory(nullptr, tr("Select Directory To Save To"),
     "",
     QFileDialog::ShowDirsOnly
     | QFileDialog::DontResolveSymlinks);
 
   DisableControls();
 
   std::set<char> delims{ '/' };
 
   bool doSteps[] = { m_Controls.StepBeamforming->isChecked(), m_Controls.StepCropping->isChecked() , m_Controls.StepBandpass->isChecked(), m_Controls.StepBMode->isChecked() };
   bool saveSteps[] = { m_Controls.SaveBeamforming->isChecked(), m_Controls.SaveCropping->isChecked() , m_Controls.SaveBandpass->isChecked(), m_Controls.SaveBMode->isChecked() };
 
   for (int fileNumber = 0; fileNumber < fileNames.size(); ++fileNumber)
   {
     m_Controls.progressBar->setValue(0);
     m_Controls.progressBar->setVisible(true);
     m_Controls.ProgressInfo->setVisible(true);
     m_Controls.ProgressInfo->setText("loading file");
 
     QString filename = fileNames.at(fileNumber);
     auto split = splitpath(filename.toStdString(), delims);
     std::string imageName = split.at(split.size() - 1);
 
     // remove ".nrrd"
     imageName = imageName.substr(0, imageName.size() - 5);
 
     mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(filename.toStdString().c_str());
     auto BFconfig = CreateBeamformingSettings(image);
 
     // Beamforming
     if (doSteps[0])
     {
       if (m_Controls.UseSignalDelay->isChecked())
       {
         float signalDelay = m_Controls.SignalDelay->value();
         if (signalDelay != 0)
         {
           int cropPixels = std::round(signalDelay / BFconfig->GetTimeSpacing() / 1000000);
           MITK_INFO << cropPixels;
           int errCode = 0;
           image = m_FilterBank->ApplyCropping(image, cropPixels, 0, 0, 0, 0, 0, &errCode);
 
           if (errCode == -1)
           {
             QMessageBox Msgbox;
             Msgbox.setText("It has been attempted to cut off more pixels than the image contains. Aborting batch processing.");
             Msgbox.exec();
             m_Controls.progressBar->setVisible(false);
             EnableControls();
             return;
           }
 
           BFconfig = mitk::BeamformingSettings::New(BFconfig->GetPitchInMeters(), BFconfig->GetSpeedOfSound(),
             BFconfig->GetTimeSpacing(), BFconfig->GetAngle(), BFconfig->GetIsPhotoacousticImage(), BFconfig->GetSamplesPerLine(),
             BFconfig->GetReconstructionLines(), image->GetDimensions(), BFconfig->GetReconstructionDepth(),
             BFconfig->GetUseGPU(), BFconfig->GetGPUBatchSize(), BFconfig->GetApod(),
             BFconfig->GetApodizationArraySize(), BFconfig->GetAlgorithm(), BFconfig->GetGeometry(), BFconfig->GetProbeRadius());
         }
       }
 
       std::function<void(int, std::string)> progressHandle = [this](int progress, std::string progressInfo) {
         this->UpdateProgress(progress, progressInfo);
       };
       m_Controls.progressBar->setValue(100);
 
       image = m_FilterBank->ApplyBeamforming(image, BFconfig, progressHandle);
 
       if (saveSteps[0])
       {
         std::string saveFileName = saveDir.toStdString() + "/" + imageName + " beamformed" + ".nrrd";
         mitk::IOUtil::Save(image, saveFileName);
       }
     }
 
     // Cropping
     if (doSteps[1])
     {
       m_Controls.ProgressInfo->setText("cropping image");
 
       int errCode = 0;
       image = m_FilterBank->ApplyCropping(image, m_Controls.CutoffAbove->value(), m_Controls.CutoffBelow->value(), m_Controls.CutoffRight->value(), m_Controls.CutoffLeft->value(), 0, 0, &errCode);
 
       if (errCode == -1)
       {
         QMessageBox Msgbox;
         Msgbox.setText("It has been attempted to cut off more pixels than the image contains. Aborting batch processing.");
         Msgbox.exec();
         m_Controls.progressBar->setVisible(false);
         EnableControls();
         return;
       }
 
       if (saveSteps[1])
       {
         std::string saveFileName = saveDir.toStdString() + "/" + imageName + " cropped" + ".nrrd";
         mitk::IOUtil::Save(image, saveFileName);
       }
     }
 
     // Bandpass
     if (doSteps[2])
     {
       m_Controls.ProgressInfo->setText("applying bandpass");
       float recordTime = image->GetDimension(1)*image->GetGeometry()->GetSpacing()[1] / 1000 / m_Controls.BPSpeedOfSound->value();
       // add a safeguard so the program does not chrash when applying a Bandpass that reaches out of the bounds of the image
       float maxFrequency = 1 / (recordTime / image->GetDimension(1)) * image->GetDimension(1) / 2 / 2 / 1000;
       float BPHighPass = 1000000 * m_Controls.BPhigh->value(); // [Hz]
       float BPLowPass = maxFrequency - 1000000 * m_Controls.BPlow->value(); // [Hz]
 
       if (BPLowPass > maxFrequency)
       {
         QMessageBox Msgbox;
         Msgbox.setText("LowPass too low, disabled it.");
         Msgbox.exec();
 
         BPLowPass = 0;
       }
       if (BPLowPass < 0)
       {
         QMessageBox Msgbox;
         Msgbox.setText("LowPass too high, disabled it.");
         Msgbox.exec();
 
         BPLowPass = 0;
       }
       if (BPHighPass > maxFrequency)
       {
         QMessageBox Msgbox;
         Msgbox.setText("HighPass too high, disabled it.");
         Msgbox.exec();
 
         BPHighPass = 0;
       }
       if (BPHighPass > maxFrequency - BPLowPass)
       {
         QMessageBox Msgbox;
         Msgbox.setText("HighPass higher than LowPass, disabled both.");
         Msgbox.exec();
 
         BPHighPass = 0;
         BPLowPass = 0;
       }
 
       image = m_FilterBank->ApplyBandpassFilter(image, BPHighPass, BPLowPass,
         m_Controls.BPFalloffHigh->value(),
         m_Controls.BPFalloffLow->value(),
         BFconfig->GetTimeSpacing(),
         BFconfig->GetSpeedOfSound(),
         m_Controls.IsBFImage->isChecked());
 
       if (saveSteps[2])
       {
         std::string saveFileName = saveDir.toStdString() + "/" + imageName + " bandpassed" + ".nrrd";
         mitk::IOUtil::Save(image, saveFileName);
       }
     }
     // Bmode
     if (doSteps[3])
     {
       m_Controls.ProgressInfo->setText("applying bmode filter");
 
       if (m_Controls.BModeMethod->currentText() == "Absolute Filter")
         image = m_FilterBank->ApplyBmodeFilter(image, mitk::PhotoacousticFilterService::BModeMethod::Abs, m_UseLogfilter);
       else if (m_Controls.BModeMethod->currentText() == "Envelope Detection")
         image = m_FilterBank->ApplyBmodeFilter(image, mitk::PhotoacousticFilterService::BModeMethod::EnvelopeDetection, m_UseLogfilter);
 
       if (m_ResampleSpacing != 0)
       {
         double desiredSpacing[2]{ image->GetGeometry()->GetSpacing()[0], m_ResampleSpacing };
 
         image = m_FilterBank->ApplyResampling(image, desiredSpacing);
       }
 
       if (saveSteps[3])
       {
         std::string saveFileName = saveDir.toStdString() + "/" + imageName + " bmode" + ".nrrd";
         mitk::IOUtil::Save(image, saveFileName);
       }
     }
     m_Controls.progressBar->setVisible(false);
   }
 
   EnableControls();
 }
 
 void PAImageProcessing::StartBeamformingThread()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataStorage::Pointer storage = this->GetDataStorage();
 
   mitk::DataNode::Pointer node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
-    QMessageBox::information(NULL, "Template", "Please load and select an image before starting image processing.");
+    QMessageBox::information(nullptr, "Template", "Please load and select an image before starting image processing.");
     return;
   }
 
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>(data);
     if (image)
     {
       auto BFconfig = CreateBeamformingSettings(image);
       std::stringstream message;
       std::string name;
       message << "Performing beamforming for image ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
         m_OldNodeName = name;
       }
       else
         m_OldNodeName = " ";
 
       message << ".";
       MITK_INFO << message.str();
 
       m_Controls.progressBar->setValue(0);
       m_Controls.progressBar->setVisible(true);
       m_Controls.ProgressInfo->setVisible(true);
       m_Controls.ProgressInfo->setText("started");
       DisableControls();
 
       BeamformingThread *thread = new BeamformingThread();
       connect(thread, &BeamformingThread::result, this, &PAImageProcessing::HandleResults);
       connect(thread, &BeamformingThread::updateProgress, this, &PAImageProcessing::UpdateProgress);
       connect(thread, &BeamformingThread::finished, thread, &QObject::deleteLater);
 
       thread->setConfig(BFconfig);
 
       if (m_Controls.UseSignalDelay->isChecked())
         thread->setSignalDelay(m_Controls.SignalDelay->value());
 
       thread->setInputImage(image);
       thread->setFilterBank(m_FilterBank);
 
       MITK_INFO << "Started new thread for Beamforming";
       thread->start();
     }
   }
 }
 
 void PAImageProcessing::HandleResults(mitk::Image::Pointer image, std::string nameExtension)
 {
   if (image == nullptr)
   {
     QMessageBox Msgbox;
     Msgbox.setText("An error has occurred during processing; please see the console output.");
     Msgbox.exec();
 
     // disable progress bar
     m_Controls.progressBar->setVisible(false);
     m_Controls.ProgressInfo->setVisible(false);
     EnableControls();
 
     return;
   }
   MITK_INFO << "Handling results...";
   auto newNode = mitk::DataNode::New();
   newNode->SetData(image);
 
   newNode->SetName(m_OldNodeName + nameExtension);
 
   // update level window for the current dynamic range
   mitk::LevelWindow levelWindow;
   newNode->GetLevelWindow(levelWindow);
   levelWindow.SetAuto(image, true, true);
   newNode->SetLevelWindow(levelWindow);
 
   // add new node to data storage
   this->GetDataStorage()->Add(newNode);
 
   // disable progress bar
   m_Controls.progressBar->setVisible(false);
   m_Controls.ProgressInfo->setVisible(false);
   EnableControls();
 
   // update rendering
   mitk::RenderingManager::GetInstance()->InitializeViews(image->GetGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   MITK_INFO << "Handling results...[Done]";
 }
 
 void PAImageProcessing::StartBmodeThread()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataStorage::Pointer storage = this->GetDataStorage();
 
   mitk::DataNode::Pointer node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
-    QMessageBox::information(NULL, "Template", "Please load and select an image before starting image processing.");
+    QMessageBox::information(nullptr, "Template", "Please load and select an image before starting image processing.");
     return;
   }
 
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>(data);
     if (image)
     {
       std::stringstream message;
       std::string name;
       message << "Performing image processing for image ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
         m_OldNodeName = name;
       }
       else
         m_OldNodeName = " ";
 
       message << ".";
       MITK_INFO << message.str();
 
       DisableControls();
 
       BmodeThread *thread = new BmodeThread();
       connect(thread, &BmodeThread::result, this, &PAImageProcessing::HandleResults);
       connect(thread, &BmodeThread::finished, thread, &QObject::deleteLater);
 
       bool useGPU = m_Controls.UseGPUBmode->isChecked();
 
       if (m_Controls.BModeMethod->currentText() == "Absolute Filter")
         thread->setConfig(m_UseLogfilter, m_ResampleSpacing, mitk::PhotoacousticFilterService::BModeMethod::Abs, useGPU);
       else if (m_Controls.BModeMethod->currentText() == "Envelope Detection")
         thread->setConfig(m_UseLogfilter, m_ResampleSpacing, mitk::PhotoacousticFilterService::BModeMethod::EnvelopeDetection, useGPU);
       thread->setInputImage(image);
       thread->setFilterBank(m_FilterBank);
 
       MITK_INFO << "Started new thread for Image Processing";
       thread->start();
     }
   }
 }
 
 void PAImageProcessing::StartCropThread()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataStorage::Pointer storage = this->GetDataStorage();
 
   mitk::DataNode::Pointer node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
-    QMessageBox::information(NULL, "Template", "Please load and select an image before starting image cropping.");
+    QMessageBox::information(nullptr, "Template", "Please load and select an image before starting image cropping.");
     return;
   }
 
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>(data);
     if (image)
     {
       std::stringstream message;
       std::string name;
       message << "Performing image cropping for image ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
         m_OldNodeName = name;
       }
       else
         m_OldNodeName = " ";
 
       message << ".";
       MITK_INFO << message.str();
 
       DisableControls();
 
       CropThread *thread = new CropThread();
       connect(thread, &CropThread::result, this, &PAImageProcessing::HandleResults);
       connect(thread, &CropThread::finished, thread, &QObject::deleteLater);
 
       if(m_Controls.Partial->isChecked())
         thread->setConfig(m_Controls.CutoffAbove->value(), m_Controls.CutoffBelow->value(), m_Controls.CutoffRight->value(), m_Controls.CutoffLeft->value(), m_Controls.boundLow->value(), m_Controls.boundHigh->value());
       else
         thread->setConfig(m_Controls.CutoffAbove->value(), m_Controls.CutoffBelow->value(), m_Controls.CutoffRight->value(), m_Controls.CutoffLeft->value(), 0, image->GetDimension(2) - 1);
 
       thread->setInputImage(image);
       thread->setFilterBank(m_FilterBank);
 
       MITK_INFO << "Started new thread for Image Cropping";
       thread->start();
     }
   }
 }
 
 void PAImageProcessing::StartBandpassThread()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataStorage::Pointer storage = this->GetDataStorage();
 
   mitk::DataNode::Pointer node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
-    QMessageBox::information(NULL, "Template", "Please load and select an image before applying a bandpass filter.");
+    QMessageBox::information(nullptr, "Template", "Please load and select an image before applying a bandpass filter.");
     return;
   }
 
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>(data);
     if (image)
     {
       auto config = CreateBeamformingSettings(image);
       std::stringstream message;
       std::string name;
       message << "Performing Bandpass filter on image ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
         m_OldNodeName = name;
       }
       else
         m_OldNodeName = " ";
 
       message << ".";
       MITK_INFO << message.str();
 
       DisableControls();
 
       BandpassThread *thread = new BandpassThread();
       connect(thread, &BandpassThread::result, this, &PAImageProcessing::HandleResults);
       connect(thread, &BandpassThread::finished, thread, &QObject::deleteLater);
 
       float BPHighPass = 1000000.0f * m_Controls.BPhigh->value(); // [Now in Hz]
       float BPLowPass = 1000000.0f * m_Controls.BPlow->value(); // [Now in Hz]
 
       thread->setConfig(BPHighPass, BPLowPass, m_Controls.BPFalloffLow->value(), m_Controls.BPFalloffHigh->value(), 
         config->GetTimeSpacing(), config->GetSpeedOfSound(), m_Controls.IsBFImage->isChecked());
       thread->setInputImage(image);
       thread->setFilterBank(m_FilterBank);
 
       MITK_INFO << "Started new thread for Bandpass filter";
       thread->start();
     }
   }
 }
 
 void PAImageProcessing::SliceBoundsEnabled()
 {
   if (!m_Controls.Partial->isChecked())
   {
     m_Controls.boundLow->setEnabled(false);
     m_Controls.boundHigh->setEnabled(false);
     return;
   }
   else
   {
     m_Controls.boundLow->setEnabled(true);
     m_Controls.boundHigh->setEnabled(true);
   }
 }
 
 void PAImageProcessing::UpperSliceBoundChanged()
 {
   if (m_Controls.boundLow->value() > m_Controls.boundHigh->value())
   {
     m_Controls.boundLow->setValue(m_Controls.boundHigh->value());
   }
 }
 
 void PAImageProcessing::LowerSliceBoundChanged()
 {
   if (m_Controls.boundLow->value() > m_Controls.boundHigh->value())
   {
     m_Controls.boundHigh->setValue(m_Controls.boundLow->value());
   }
 }
 
 void PAImageProcessing::UpdateProgress(int progress, std::string progressInfo)
 {
   if (progress < 100)
     m_Controls.progressBar->setValue(progress);
   else
     m_Controls.progressBar->setValue(100);
   m_Controls.ProgressInfo->setText(progressInfo.c_str());
   qApp->processEvents();
 }
 
 void PAImageProcessing::PAMessageBox(std::string message)
 {
   if (0 != message.compare("noMessage"))
   {
     QMessageBox msgBox;
     msgBox.setText(message.c_str());
     msgBox.exec();
   }
 }
 
 void PAImageProcessing::UpdateImageInfo()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataNode::Pointer node = nodes.front();
 
   if (!node)
   {
     // Nothing selected
     return;
   }
 
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>(data);
 
     if (image)
     {
       // beamforming configs
       if (m_Controls.UseImageSpacing->isChecked())
       {
         m_Controls.ElementCount->setValue(image->GetDimension(0));
         m_Controls.Pitch->setValue(image->GetGeometry()->GetSpacing()[0]);
       }
 
       m_Controls.boundLow->setMaximum(image->GetDimension(2) - 1);
       m_Controls.boundHigh->setMaximum(image->GetDimension(2) - 1);
 
       float speedOfSound = m_Controls.SpeedOfSound->value(); // [m/s]
       std::stringstream frequency;
       float timeSpacing;
       if (m_Controls.UseImageSpacing->isChecked())
       {
         timeSpacing = image->GetGeometry()->GetSpacing()[1] / 1000000.0f;
         MITK_INFO << "Calculated Scan Depth of " << (image->GetDimension(1)*image->GetGeometry()->GetSpacing()[1] /
           1000000) * speedOfSound * 100 / 2 << "cm";
       }
       else
       {
         timeSpacing = (2 * m_Controls.ScanDepth->value() / 1000 / speedOfSound) / image->GetDimension(1);
       }
       float maxFrequency = (1 / timeSpacing) / 2;
       if(m_Controls.IsBFImage->isChecked())
         maxFrequency = ( 1 / (image->GetGeometry()->GetSpacing()[1] / 1e3 / speedOfSound)) / 2;
       frequency << maxFrequency / 1e6; //[MHz]
       frequency << "MHz";
 
       m_Controls.BPhigh->setMaximum(maxFrequency / 1e6);
       m_Controls.BPlow->setMaximum(maxFrequency / 1e6);
 
       frequency << " is the maximal allowed frequency for the selected image.";
       m_Controls.BPhigh->setToolTip(frequency.str().c_str());
       m_Controls.BPlow->setToolTip(frequency.str().c_str());
       m_Controls.BPhigh->setToolTipDuration(5000);
       m_Controls.BPlow->setToolTipDuration(5000);
     }
   }
 }
 
 void PAImageProcessing::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
   const QList<mitk::DataNode::Pointer>& nodes)
 {
   // iterate all selected objects, adjust warning visibility
   foreach(mitk::DataNode::Pointer node, nodes)
   {
     if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
     {
       m_Controls.labelWarning->setVisible(false);
       m_Controls.buttonApplyBModeFilter->setEnabled(true);
       m_Controls.labelWarning2->setVisible(false);
       m_Controls.buttonApplyCropFilter->setEnabled(true);
       m_Controls.labelWarning3->setVisible(false);
       m_Controls.buttonApplyBandpass->setEnabled(true);
       m_Controls.labelWarning4->setVisible(false);
       m_Controls.buttonApplyBeamforming->setEnabled(true);
       UpdateImageInfo();
       return;
     }
   }
   m_Controls.labelWarning->setVisible(true);
   m_Controls.buttonApplyBModeFilter->setEnabled(false);
   m_Controls.labelWarning2->setVisible(true);
   m_Controls.buttonApplyCropFilter->setEnabled(false);
   m_Controls.labelWarning3->setVisible(true);
   m_Controls.buttonApplyBandpass->setEnabled(false);
   m_Controls.labelWarning4->setVisible(true);
   m_Controls.buttonApplyBeamforming->setEnabled(false);
 }
 
 void PAImageProcessing::UseResampling()
 {
   if (m_Controls.DoResampling->isChecked())
   {
     m_Controls.ResamplingValue->setEnabled(true);
     m_ResampleSpacing = m_Controls.ResamplingValue->value();
   }
   else
   {
     m_Controls.ResamplingValue->setEnabled(false);
     m_ResampleSpacing = 0;
   }
 }
 
 void PAImageProcessing::UseLogfilter()
 {
   m_UseLogfilter = m_Controls.Logfilter->isChecked();
 }
 
 void PAImageProcessing::SetResampling()
 {
   m_ResampleSpacing = m_Controls.ResamplingValue->value();
 }
 
 mitk::BeamformingSettings::Pointer PAImageProcessing::CreateBeamformingSettings(mitk::Image::Pointer image)
 {
   mitk::BeamformingSettings::BeamformingAlgorithm algorithm = mitk::BeamformingSettings::BeamformingAlgorithm::DAS;
   if ("DAS" == m_Controls.BFAlgorithm->currentText())
     algorithm = mitk::BeamformingSettings::BeamformingAlgorithm::DAS;
   else if ("DMAS" == m_Controls.BFAlgorithm->currentText())
     algorithm = mitk::BeamformingSettings::BeamformingAlgorithm::DMAS;
   else if ("sDMAS" == m_Controls.BFAlgorithm->currentText())
     algorithm = mitk::BeamformingSettings::BeamformingAlgorithm::sDMAS;
 
   mitk::BeamformingSettings::Apodization apod = mitk::BeamformingSettings::Apodization::Box;
   if ("Von Hann" == m_Controls.Apodization->currentText())
   {
     apod = mitk::BeamformingSettings::Apodization::Hann;
   }
   else if ("Hamming" == m_Controls.Apodization->currentText())
   {
     apod = mitk::BeamformingSettings::Apodization::Hamm;
   }
   else if ("Box" == m_Controls.Apodization->currentText())
   {
     apod = mitk::BeamformingSettings::Apodization::Box;
   }
 
   float pitchInMeters = m_Controls.Pitch->value() / 1000; // [m]
   float speedOfSound = m_Controls.SpeedOfSound->value(); // [m/s]
   unsigned int samplesPerLine = m_Controls.Samples->value();
   unsigned int reconstructionLines = m_Controls.Lines->value();
   unsigned int apodizatonArraySize = m_Controls.Lines->value();
   float angle = m_Controls.Angle->value(); // [deg]
   bool useGPU = m_Controls.UseGPUBf->isChecked();
 
   float timeSpacing;
   if (m_Controls.UseImageSpacing->isChecked())
   {
     timeSpacing = image->GetGeometry()->GetSpacing()[1] / 1000000.0f;
     MITK_INFO << "Calculated Scan Depth of " << (image->GetDimension(1)*image->GetGeometry()->GetSpacing()[1] /
       1000000) * speedOfSound * 100 << "cm";
   }
   else
   {
     timeSpacing = (2 * m_Controls.ScanDepth->value() / 1000 / speedOfSound) / image->GetDimension(1);
   }
 
   bool isPAImage = true;
   if ("US Image" == m_Controls.ImageType->currentText())
   {
     isPAImage = false;
   }
   else if ("PA Image" == m_Controls.ImageType->currentText())
   {
     isPAImage = true;
   }
 
   float reconstructionDepth = m_Controls.ReconstructionDepth->value() / 1000.f; // [m]
 
   mitk::BeamformingSettings::ProbeGeometry geometry = mitk::BeamformingSettings::ProbeGeometry::Linear;
   if ("Linear" == m_Controls.Geometry->currentText())
   {
     geometry = mitk::BeamformingSettings::ProbeGeometry::Linear;
   }
   else if ("Concave" == m_Controls.Geometry->currentText())
   {
     geometry = mitk::BeamformingSettings::ProbeGeometry::Concave;
   }
   float probeRadius = m_Controls.ProbeRadius->value()/1000.f; // [m]
 
   return mitk::BeamformingSettings::New(pitchInMeters,
     speedOfSound, timeSpacing, angle, isPAImage, samplesPerLine, reconstructionLines,
     image->GetDimensions(), reconstructionDepth, useGPU, GPU_BATCH_SIZE, apod,
     apodizatonArraySize, algorithm, geometry, probeRadius);
 }
 
 void PAImageProcessing::EnableControls()
 {
   m_Controls.BatchProcessing->setEnabled(true);
   m_Controls.StepBeamforming->setEnabled(true);
   m_Controls.StepBandpass->setEnabled(true);
   m_Controls.StepCropping->setEnabled(true);
   m_Controls.StepBMode->setEnabled(true);
 
   UpdateSaveBoxes();
 
   m_Controls.DoResampling->setEnabled(true);
   UseResampling();
   m_Controls.Logfilter->setEnabled(true);
   m_Controls.BModeMethod->setEnabled(true);
   m_Controls.buttonApplyBModeFilter->setEnabled(true);
 
   m_Controls.CutoffAbove->setEnabled(true);
   m_Controls.CutoffBelow->setEnabled(true);
   m_Controls.buttonApplyCropFilter->setEnabled(true);
   m_Controls.BPSpeedOfSound->setEnabled(true);
   m_Controls.buttonApplyBandpass->setEnabled(true);
 
   m_Controls.Partial->setEnabled(true);
   m_Controls.boundHigh->setEnabled(true);
   m_Controls.boundLow->setEnabled(true);
   m_Controls.BFAlgorithm->setEnabled(true);
   m_Controls.ReconstructionDepth->setEnabled(true);
   m_Controls.ImageType->setEnabled(true);
   m_Controls.Apodization->setEnabled(true);
 
 #ifdef PHOTOACOUSTICS_USE_GPU
   m_Controls.UseGPUBf->setEnabled(true);
   m_Controls.UseGPUBmode->setEnabled(true);
 #endif
 
   m_Controls.BPhigh->setEnabled(true);
   m_Controls.BPlow->setEnabled(true);
   m_Controls.BPFalloffLow->setEnabled(true);
   m_Controls.BPFalloffHigh->setEnabled(true);
   m_Controls.UseImageSpacing->setEnabled(true);
   UseImageSpacing();
   m_Controls.Pitch->setEnabled(true);
   m_Controls.ElementCount->setEnabled(true);
   m_Controls.SpeedOfSound->setEnabled(true);
   m_Controls.Samples->setEnabled(true);
   m_Controls.Lines->setEnabled(true);
   m_Controls.Angle->setEnabled(true);
   m_Controls.buttonApplyBeamforming->setEnabled(true);
   m_Controls.UseSignalDelay->setEnabled(true);
   m_Controls.SignalDelay->setEnabled(true);
 }
 
 void PAImageProcessing::DisableControls()
 {
   m_Controls.BatchProcessing->setEnabled(false);
   m_Controls.StepBeamforming->setEnabled(false);
   m_Controls.StepBandpass->setEnabled(false);
   m_Controls.StepCropping->setEnabled(false);
   m_Controls.StepBMode->setEnabled(false);
   m_Controls.SaveBeamforming->setEnabled(false);
   m_Controls.SaveBandpass->setEnabled(false);
   m_Controls.SaveCropping->setEnabled(false);
   m_Controls.SaveBMode->setEnabled(false);
 
   m_Controls.DoResampling->setEnabled(false);
   m_Controls.ResamplingValue->setEnabled(false);
   m_Controls.Logfilter->setEnabled(false);
   m_Controls.BModeMethod->setEnabled(false);
   m_Controls.buttonApplyBModeFilter->setEnabled(false);
 
   m_Controls.CutoffAbove->setEnabled(false);
   m_Controls.CutoffBelow->setEnabled(false);
   m_Controls.buttonApplyCropFilter->setEnabled(false);
   m_Controls.BPSpeedOfSound->setEnabled(false);
   m_Controls.buttonApplyBandpass->setEnabled(false);
 
   m_Controls.Partial->setEnabled(false);
   m_Controls.boundHigh->setEnabled(false);
   m_Controls.boundLow->setEnabled(false);
   m_Controls.BFAlgorithm->setEnabled(false);
   m_Controls.ReconstructionDepth->setEnabled(false);
   m_Controls.ImageType->setEnabled(false);
   m_Controls.Apodization->setEnabled(false);
 
 #ifdef PHOTOACOUSTICS_USE_GPU
   m_Controls.UseGPUBf->setEnabled(false);
   m_Controls.UseGPUBmode->setEnabled(false);
 #endif
 
   m_Controls.BPhigh->setEnabled(false);
   m_Controls.BPlow->setEnabled(false);
   m_Controls.BPFalloffLow->setEnabled(false);
   m_Controls.BPFalloffHigh->setEnabled(false);
   m_Controls.UseImageSpacing->setEnabled(false);
   m_Controls.ScanDepth->setEnabled(false);
   m_Controls.Pitch->setEnabled(false);
   m_Controls.ElementCount->setEnabled(false);
   m_Controls.SpeedOfSound->setEnabled(false);
   m_Controls.Samples->setEnabled(false);
   m_Controls.Lines->setEnabled(false);
   m_Controls.Angle->setEnabled(false);
   m_Controls.buttonApplyBeamforming->setEnabled(false);
   m_Controls.UseSignalDelay->setEnabled(false);
   m_Controls.SignalDelay->setEnabled(false);
 }
 
 void PAImageProcessing::UseImageSpacing()
 {
   if (m_Controls.UseImageSpacing->isChecked())
   {
     m_Controls.ScanDepth->setDisabled(true);
   }
   else
   {
     m_Controls.ScanDepth->setEnabled(true);
   }
 }
 
 #include <mitkImageReadAccessor.h>
 
 void BeamformingThread::run()
 {
   if (m_SignalDelay != 0)
   {
     int cropPixels = std::round(m_SignalDelay / m_BFconfig->GetTimeSpacing() / 1000000);
     MITK_INFO << cropPixels;
     int errCode = 0;
     m_InputImage = m_FilterBank->ApplyCropping(m_InputImage, cropPixels, 0, 0, 0, 0, 0, &errCode);
 
     m_BFconfig = mitk::BeamformingSettings::New(m_BFconfig->GetPitchInMeters(), m_BFconfig->GetSpeedOfSound(),
       m_BFconfig->GetTimeSpacing(), m_BFconfig->GetAngle(), m_BFconfig->GetIsPhotoacousticImage(), m_BFconfig->GetSamplesPerLine(),
       m_BFconfig->GetReconstructionLines(), m_InputImage->GetDimensions(), m_BFconfig->GetReconstructionDepth(),
       m_BFconfig->GetUseGPU(), m_BFconfig->GetGPUBatchSize(), m_BFconfig->GetApod(),
       m_BFconfig->GetApodizationArraySize(), m_BFconfig->GetAlgorithm(), m_BFconfig->GetGeometry(), m_BFconfig->GetProbeRadius());
   }
 
   mitk::Image::Pointer resultImage;
   std::function<void(int, std::string)> progressHandle = [this](int progress, std::string progressInfo) {
     emit updateProgress(progress, progressInfo);
   };
   resultImage = m_FilterBank->ApplyBeamforming(m_InputImage, m_BFconfig, progressHandle);
   emit result(resultImage, "_bf");
 }
 
 void BeamformingThread::setConfig(mitk::BeamformingSettings::Pointer BFconfig)
 {
   m_BFconfig = BFconfig;
 }
 
 void BeamformingThread::setSignalDelay(float delay)
 {
   m_SignalDelay = delay;
 }
 
 void BeamformingThread::setInputImage(mitk::Image::Pointer image)
 {
   m_InputImage = image;
 }
 
 void BmodeThread::run()
 {
   mitk::Image::Pointer resultImage = m_FilterBank->ApplyBmodeFilter(m_InputImage,
     m_Method, m_UseLogfilter);
 
   if (m_ResampleSpacing != 0)
   {
     double desiredSpacing[2]{ m_InputImage->GetGeometry()->GetSpacing()[0], m_ResampleSpacing };
     resultImage = m_FilterBank->ApplyResampling(resultImage, desiredSpacing);
   }
   emit result(resultImage, "_bmode");
 }
 
 void BmodeThread::setConfig(bool useLogfilter, double resampleSpacing, mitk::PhotoacousticFilterService::BModeMethod method, bool useGPU)
 {
   m_UseLogfilter = useLogfilter;
   m_ResampleSpacing = resampleSpacing;
   m_Method = method;
   m_UseGPU = useGPU;
 }
 
 void BmodeThread::setInputImage(mitk::Image::Pointer image)
 {
   m_InputImage = image;
 }
 
 void CropThread::run()
 {
   mitk::Image::Pointer resultImage;
 
   int errCode = 0;
 
   resultImage = m_FilterBank->ApplyCropping(m_InputImage, m_CutAbove, m_CutBelow, m_CutRight, m_CutLeft, m_CutSliceFirst, (m_InputImage->GetDimension(2) - 1)  - m_CutSliceLast, &errCode);
   if (errCode == -1)
   {
     emit result(nullptr, "_cropped");
     return;
   }
   emit result(resultImage, "_cropped");
 }
 
 void CropThread::setConfig(unsigned int CutAbove, unsigned int CutBelow, unsigned int CutRight, unsigned int CutLeft, unsigned int CutSliceFirst, unsigned int CutSliceLast)
 {
   m_CutAbove = CutAbove;
   m_CutBelow = CutBelow;
   m_CutRight = CutRight;
   m_CutLeft = CutLeft;
 
   m_CutSliceLast = CutSliceLast;
   m_CutSliceFirst = CutSliceFirst;
 }
 
 void CropThread::setInputImage(mitk::Image::Pointer image)
 {
   m_InputImage = image;
 }
 
 void BandpassThread::run()
 {
   mitk::Image::Pointer resultImage = m_FilterBank->ApplyBandpassFilter(m_InputImage, m_BPHighPass, m_BPLowPass, m_TukeyAlphaHighPass, m_TukeyAlphaLowPass, m_TimeSpacing, m_SpeedOfSound, m_IsBFImage);
   emit result(resultImage, "_bandpassed");
 }
 
 void BandpassThread::setConfig(float BPHighPass, float BPLowPass, float TukeyAlphaHighPass, float TukeyAlphaLowPass, float TimeSpacing, float SpeedOfSound, bool IsBFImage)
 {
   m_BPHighPass = BPHighPass;
   m_BPLowPass = BPLowPass;
   m_TukeyAlphaHighPass = TukeyAlphaHighPass;
   m_TukeyAlphaLowPass = TukeyAlphaLowPass;
   m_TimeSpacing = TimeSpacing;
   m_SpeedOfSound = SpeedOfSound;
   m_IsBFImage = IsBFImage;
 }
 
 void BandpassThread::setInputImage(mitk::Image::Pointer image)
 {
   m_InputImage = image;
 }
diff --git a/Plugins/org.mitk.gui.qt.pointsetinteraction/src/internal/QmitkPointSetInteractionView.cpp b/Plugins/org.mitk.gui.qt.pointsetinteraction/src/internal/QmitkPointSetInteractionView.cpp
index 85a41651a3..3f99a45f20 100755
--- a/Plugins/org.mitk.gui.qt.pointsetinteraction/src/internal/QmitkPointSetInteractionView.cpp
+++ b/Plugins/org.mitk.gui.qt.pointsetinteraction/src/internal/QmitkPointSetInteractionView.cpp
@@ -1,148 +1,148 @@
 /*===================================================================
 
 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 related includes
 #include "QmitkPointSetInteractionView.h"
 #include "ui_QmitkPointSetInteractionViewControls.h"
 
 #include <berryIWorkbenchWindow.h>
 #include <berryISelectionService.h>
 #include <QInputDialog>
 #include <QLineEdit>
 #include <mitkProperties.h>
 #include <QmitkPointListWidget.h>
 #include <mitkDataNodeObject.h>
 #include <mitkDataNodeSelection.h>
 
 const std::string QmitkPointSetInteractionView::VIEW_ID = "org.mitk.views.pointsetinteraction";
 
 
 QmitkPointSetInteractionView::QmitkPointSetInteractionView( QObject* /*parent*/ )
-: m_Controls(0)
+: m_Controls(nullptr)
 {
 }
 
 QmitkPointSetInteractionView::~QmitkPointSetInteractionView()
 {
 }
 
 void QmitkPointSetInteractionView::CreateQtPartControl( QWidget *parent )
 {
   m_Controls = new Ui::QmitkPointSetInteractionControls;
   m_Controls->setupUi(parent);
   m_Controls->m_PbAddPointSet->connect( m_Controls->m_PbAddPointSet, SIGNAL( clicked() )
     , this, SLOT( OnAddPointSetClicked() ) );
 
     if (mitk::IRenderWindowPart *renderWindowPart = GetRenderWindowPart())
   {
     // let the point set widget know about the render window part (crosshair updates)
     RenderWindowPartActivated(renderWindowPart);
   }
 }
 
 void QmitkPointSetInteractionView::SetFocus()
 {
   m_Controls->m_PbAddPointSet->setFocus();
 }
 
 void QmitkPointSetInteractionView::OnAddPointSetClicked()
 {
   //Ask for the name of the point set
   bool ok = false;
   QString name = QInputDialog::getText( QApplication::activeWindow()
     , tr("Add point set..."), tr("Enter name for the new point set"), QLineEdit::Normal, tr("PointSet"), &ok );
   if ( ! ok || name.isEmpty() )
     return;
 
   //
   //Create a new empty pointset
   //
   mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
   //
   // Create a new data tree node
   //
   mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New();
   //
   // fill the data tree node with the appropriate information
   //
   pointSetNode->SetData( pointSet );
   pointSetNode->SetProperty( "name", mitk::StringProperty::New( name.toStdString() ) );
   pointSetNode->SetProperty( "opacity", mitk::FloatProperty::New( 1 ) );
   pointSetNode->SetColor( 1.0, 1.0, 0.0 );
   //
   // add the node to the ds
   //
   this->GetDataStorage()->Add(pointSetNode);
 
   // make new selection and emulate selection for this
   berry::IWorkbenchPart::Pointer nullPart;
   QList<mitk::DataNode::Pointer> selection;
   selection.push_back(pointSetNode);
   this->OnSelectionChanged(nullPart, selection);
 }
 
 void QmitkPointSetInteractionView::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
 {
   mitk::DataNode::Pointer selectedNode;
 
   if(!nodes.empty())
     selectedNode = nodes.front();
 
   mitk::PointSet::Pointer pointSet;
 
   if(selectedNode.IsNotNull())
     pointSet = dynamic_cast<mitk::PointSet*>(selectedNode->GetData());
 
   if (pointSet.IsNotNull())
   {
     m_SelectedPointSetNode = selectedNode;
     m_Controls->m_CurrentPointSetLabel->setText(QString::fromStdString(selectedNode->GetName()));
     m_Controls->m_PointListWidget->SetPointSetNode(selectedNode);
   }
   else
   {
     m_Controls->m_CurrentPointSetLabel->setText(tr("None"));
     m_Controls->m_PointListWidget->SetPointSetNode(nullptr);
   }
 }
 
 void QmitkPointSetInteractionView::NodeChanged( const mitk::DataNode* node )
 {
   if(node == m_SelectedPointSetNode && m_Controls->m_CurrentPointSetLabel->text().toStdString() != node->GetName())
   {
     m_Controls->m_CurrentPointSetLabel->setText(QString::fromStdString(node->GetName()));
   }
 }
 
 void QmitkPointSetInteractionView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if(m_Controls)
   {
     m_Controls->m_PointListWidget->AddSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
     m_Controls->m_PointListWidget->AddSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
     m_Controls->m_PointListWidget->AddSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
   }
 }
 
 void QmitkPointSetInteractionView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if(m_Controls)
   {
     m_Controls->m_PointListWidget->RemoveSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
     m_Controls->m_PointListWidget->RemoveSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
     m_Controls->m_PointListWidget->RemoveSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.pointsetinteraction/src/internal/QmitkPointSetInteractionView.h b/Plugins/org.mitk.gui.qt.pointsetinteraction/src/internal/QmitkPointSetInteractionView.h
index 1eb9133db3..b8b27f6caa 100755
--- a/Plugins/org.mitk.gui.qt.pointsetinteraction/src/internal/QmitkPointSetInteractionView.h
+++ b/Plugins/org.mitk.gui.qt.pointsetinteraction/src/internal/QmitkPointSetInteractionView.h
@@ -1,63 +1,63 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #if !defined(QmitkPointSetInteraction_H__INCLUDED)
 #define QmitkPointSetInteraction_H__INCLUDED
 
 #include <berryISelectionListener.h>
 #include <QmitkAbstractView.h>
 #include <mitkILifecycleAwarePart.h>
 #include <mitkIRenderWindowPartListener.h>
 #include <mitkWeakPointer.h>
 #include <mitkDataNode.h>
 
 namespace Ui
 {
 class QmitkPointSetInteractionControls;
 };
 
 /*!
 \brief QmitkPointSetInteractionView
 */
 class QmitkPointSetInteractionView : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   Q_OBJECT
 
 public:
   static const std::string VIEW_ID;
 
-  QmitkPointSetInteractionView(QObject *parent=0);
+  QmitkPointSetInteractionView(QObject *parent=nullptr);
   ~QmitkPointSetInteractionView() override;
 
 
   void CreateQtPartControl(QWidget *parent) override;
 
   ///
   /// Sets the focus to an internal widget.
   ///
   void SetFocus() override;
 
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
   void NodeChanged(const mitk::DataNode* node) override;
   void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override;
 protected slots:
   void OnAddPointSetClicked();
 protected:
   Ui::QmitkPointSetInteractionControls * m_Controls;
   mitk::WeakPointer<mitk::DataNode> m_SelectedPointSetNode;
 };
 #endif // !defined(QmitkPointSetInteraction_H__INCLUDED)
diff --git a/Plugins/org.mitk.gui.qt.preprocessing.resampling/src/internal/QmitkPreprocessingResamplingView.cpp b/Plugins/org.mitk.gui.qt.preprocessing.resampling/src/internal/QmitkPreprocessingResamplingView.cpp
index 47556da11c..591643dc1b 100644
--- a/Plugins/org.mitk.gui.qt.preprocessing.resampling/src/internal/QmitkPreprocessingResamplingView.cpp
+++ b/Plugins/org.mitk.gui.qt.preprocessing.resampling/src/internal/QmitkPreprocessingResamplingView.cpp
@@ -1,460 +1,460 @@
 /*===================================================================
 
 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 "QmitkPreprocessingResamplingView.h"
 
 // QT includes (GUI)
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qmessagebox.h>
 
 // Berry includes (selection service)
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // MITK includes (GUI)
 #include "QmitkStdMultiWidget.h"
 #include "QmitkDataNodeSelectionProvider.h"
 #include "mitkDataNodeObject.h"
 
 // MITK includes (general)
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateDimension.h"
 #include "mitkNodePredicateAnd.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkVectorImageMapper2D.h"
 #include "mitkProperties.h"
 
 // Includes for image casting between ITK and MITK
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 
 // ITK includes (general)
 #include <itkVectorImage.h>
 #include <itkImageFileWriter.h>
 
 // Resampling
 #include <itkResampleImageFilter.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkBSplineInterpolateImageFunction.h>
 #include <itkCastImageFilter.h>
 #include <itkLinearInterpolateImageFunction.h>
 
 #include <itkRescaleIntensityImageFilter.h>
 #include <itkShiftScaleImageFilter.h>
 
 // STD
 #include <cmath>
 
 
 // Convenient Definitions
 typedef itk::Image<double, 3>                                                           ImageType;
 typedef itk::Image<unsigned char, 3>                                                    SegmentationImageType;
 typedef itk::Image<double, 3>                                                           DoubleImageType;
 typedef itk::Image<itk::Vector<float,3>, 3>                                             VectorImageType;
 
 typedef itk::ResampleImageFilter< ImageType, ImageType >                                ResampleImageFilterType;
 typedef itk::ResampleImageFilter< ImageType, ImageType >                                ResampleImageFilterType2;
 typedef itk::CastImageFilter< ImageType, DoubleImageType >                               ImagePTypeToFloatPTypeCasterType;
 
 typedef itk::LinearInterpolateImageFunction< ImageType, double >                        LinearInterpolatorType;
 typedef itk::NearestNeighborInterpolateImageFunction< ImageType, double >               NearestInterpolatorType;
 typedef itk::BSplineInterpolateImageFunction<ImageType, double>                         BSplineInterpolatorType;
 
 
 QmitkPreprocessingResampling::QmitkPreprocessingResampling()
 : QmitkAbstractView(),
-  m_Controls(NULL),
-  m_SelectedImageNode(NULL),
-  m_TimeStepperAdapter(NULL)
+  m_Controls(nullptr),
+  m_SelectedImageNode(nullptr),
+  m_TimeStepperAdapter(nullptr)
 {
 }
 
 QmitkPreprocessingResampling::~QmitkPreprocessingResampling()
 {
 }
 
 void QmitkPreprocessingResampling::CreateQtPartControl(QWidget *parent)
 {
-  if (m_Controls == NULL)
+  if (m_Controls == nullptr)
   {
     m_Controls = new Ui::QmitkPreprocessingResamplingViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
     mitk::NodePredicateDataType::Pointer imagePredicate = mitk::NodePredicateDataType::New("Image");
   }
 
   m_SelectedImageNode = mitk::DataStorageSelection::New(this->GetDataStorage(), false);
 
   // Setup Controls
   this->m_Controls->cbParam4->clear();
   this->m_Controls->cbParam4->insertItem(LINEAR, "Linear");
   this->m_Controls->cbParam4->insertItem(NEAREST, "Nearest neighbor");
   this->m_Controls->cbParam4->insertItem(SPLINE, "B-Spline");
 
 }
 
 void QmitkPreprocessingResampling::CreateConnections()
 {
   if ( m_Controls )
   {
     connect((QObject*)(m_Controls->btnDoIt), SIGNAL(clicked()), (QObject*) this, SLOT(StartButtonClicked()));
     connect((QObject*)(m_Controls->buttonExecuteOnMultipleImages), SIGNAL(clicked()), (QObject*) this, SLOT(StartMultipleImagesButtonClicked()));
     connect( (QObject*)(m_Controls->cbParam4), SIGNAL( activated(int) ), this, SLOT( SelectInterpolator(int) ) );
   }
 }
 
 void QmitkPreprocessingResampling::InternalGetTimeNavigationController()
 {
   auto renwin_part = GetRenderWindowPart();
   if( renwin_part != nullptr )
   {
     auto tnc = renwin_part->GetTimeNavigationController();
     if( tnc != nullptr )
     {
       m_TimeStepperAdapter = new QmitkStepperAdapter((QObject*) m_Controls->sliceNavigatorTime, tnc->GetTime(), "sliceNavigatorTimeFromBIP");
     }
   }
 }
 
 void QmitkPreprocessingResampling::SetFocus()
 {
 }
 
 //datamanager selection changed
 void QmitkPreprocessingResampling::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
 {
   ResetOneImageOpPanel();
   //any nodes there?
   if (!nodes.empty())
   {
     // reset GUI
     m_Controls->sliceNavigatorTime->setEnabled(false);
     m_Controls->leImage1->setText(tr("Select an Image in Data Manager"));
 
     m_SelectedNodes.clear();
 
     for (mitk::DataNode* _DataNode : nodes)
     {
       m_SelectedImageNode->RemoveAllNodes();
       *m_SelectedImageNode = _DataNode;
       mitk::Image::Pointer tempImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData());
 
       //no image
       if (tempImage.IsNull() || (tempImage->IsInitialized() == false))
       {
         if (m_SelectedNodes.size() < 1)
         {
           m_Controls->leImage1->setText(tr("Not an image."));
         }
         continue;
       }
 
       //2D image
       if (tempImage->GetDimension() < 3)
       {
         if (m_SelectedNodes.size() < 1)
         {
           m_Controls->leImage1->setText(tr("2D images are not supported."));
         }
         continue;
       }
 
       if (m_SelectedNodes.size() < 1)
       {
         m_Controls->leImage1->setText(QString(m_SelectedImageNode->GetNode()->GetName().c_str()));
         mitk::Vector3D aSpacing = tempImage->GetGeometry()->GetSpacing();
         std::string text("x-spacing (" + std::to_string(aSpacing[0]) + ")");
         m_Controls->tlParam1->setText(text.c_str());
         text = "y-spacing (" + std::to_string(aSpacing[1]) + ")";
         m_Controls->tlParam2->setText(text.c_str());
         text = "z-spacing (" + std::to_string(aSpacing[2]) + ")";
         m_Controls->tlParam3->setText(text.c_str());
 
         if (tempImage->GetDimension() > 3)
         {
           // try to retrieve the TNC (for 4-D Processing )
           this->InternalGetTimeNavigationController();
 
           m_Controls->sliceNavigatorTime->setEnabled(true);
           m_Controls->tlTime->setEnabled(true);
         }
       }
       m_SelectedNodes.push_back(_DataNode);
     }
     if (m_SelectedNodes.size() > 0)
     {
       *m_SelectedImageNode = m_SelectedNodes[0];
     }
     ResetParameterPanel();
   }
 }
 
 void QmitkPreprocessingResampling::ResetOneImageOpPanel()
 {
   m_Controls->tlTime->setEnabled(false);
   m_Controls->btnDoIt->setEnabled(false);
   m_Controls->buttonExecuteOnMultipleImages->setEnabled(false);
   m_Controls->cbHideOrig->setEnabled(false);
   m_Controls->leImage1->setText(tr("Select an Image in Data Manager"));
   m_Controls->tlParam1->setText("x-spacing");
   m_Controls->tlParam1->setText("y-spacing");
   m_Controls->tlParam1->setText("z-spacing");
 }
 
 void QmitkPreprocessingResampling::ResetParameterPanel()
 {
   m_Controls->btnDoIt->setEnabled(true);
   m_Controls->buttonExecuteOnMultipleImages->setEnabled(true);
   m_Controls->cbHideOrig->setEnabled(true);
 }
 
 void QmitkPreprocessingResampling::ResetTwoImageOpPanel()
 {
 }
 
 void QmitkPreprocessingResampling::StartMultipleImagesButtonClicked()
 {
   for (auto currentSelectedNode : m_SelectedNodes)
   {
     m_SelectedImageNode->RemoveAllNodes();
     *m_SelectedImageNode = currentSelectedNode;
     StartButtonClicked();
   }
 }
 
 void QmitkPreprocessingResampling::StartButtonClicked()
 {
   if(!m_SelectedImageNode->GetNode()) return;
 
   this->BusyCursorOn();
 
   mitk::Image::Pointer newImage;
 
   try
   {
     newImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData());
   }
   catch ( std::exception &e )
   {
   QString exceptionString = tr("An error occured during image loading:\n");
   exceptionString.append( e.what() );
-    QMessageBox::warning( NULL, "Preprocessing - Resampling: ", exceptionString , QMessageBox::Ok, QMessageBox::NoButton );
+    QMessageBox::warning( nullptr, "Preprocessing - Resampling: ", exceptionString , QMessageBox::Ok, QMessageBox::NoButton );
     this->BusyCursorOff();
     return;
   }
 
   // check if input image is valid, casting does not throw exception when casting from 'NULL-Object'
   if ( (! newImage) || (newImage->IsInitialized() == false) )
   {
     this->BusyCursorOff();
 
-    QMessageBox::warning( NULL, "Preprocessing - Resampling", tr("Input image is broken or not initialized. Returning."), QMessageBox::Ok, QMessageBox::NoButton );
+    QMessageBox::warning( nullptr, "Preprocessing - Resampling", tr("Input image is broken or not initialized. Returning."), QMessageBox::Ok, QMessageBox::NoButton );
     return;
   }
 
   // check if operation is done on 4D a image time step
   if(newImage->GetDimension() > 3)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
     timeSelector->SetInput(newImage);
     timeSelector->SetTimeNr( ((QmitkSliderNavigatorWidget*)m_Controls->sliceNavigatorTime)->GetPos() );
     timeSelector->Update();
     newImage = timeSelector->GetOutput();
   }
 
   // check if image or vector image
   ImageType::Pointer itkImage = ImageType::New();
   VectorImageType::Pointer itkVecImage = VectorImageType::New();
 
   int isVectorImage = newImage->GetPixelType().GetNumberOfComponents();
 
   if(isVectorImage > 1)
   {
     CastToItkImage( newImage, itkVecImage );
   }
   else
   {
     CastToItkImage( newImage, itkImage );
   }
 
   std::stringstream nameAddition("");
 
   double dparam1 = m_Controls->dsbParam1->value();
   double dparam2 = m_Controls->dsbParam2->value();
   double dparam3 = m_Controls->dsbParam3->value();
 
   try{
 
       std::string selectedInterpolator;
       ResampleImageFilterType::Pointer resampler = ResampleImageFilterType::New();
       switch (m_SelectedInterpolation)
       {
       case LINEAR:
         {
           LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
           resampler->SetInterpolator(interpolator);
           selectedInterpolator = "Linear";
           break;
         }
       case NEAREST:
         {
           NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New();
           resampler->SetInterpolator(interpolator);
           selectedInterpolator = "Nearest";
           break;
       }
       case SPLINE:
       {
         BSplineInterpolatorType::Pointer interpolator = BSplineInterpolatorType::New();
         interpolator->SetSplineOrder(3);
         resampler->SetInterpolator(interpolator);
         selectedInterpolator = "B-Spline";
         break;
       }
       default:
         {
           LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
           resampler->SetInterpolator(interpolator);
           selectedInterpolator = "Linear";
           break;
         }
       }
       resampler->SetInput( itkImage );
       resampler->SetOutputOrigin( itkImage->GetOrigin() );
 
       ImageType::SizeType input_size = itkImage->GetLargestPossibleRegion().GetSize();
       ImageType::SpacingType input_spacing = itkImage->GetSpacing();
 
       ImageType::SizeType output_size;
       ImageType::SpacingType output_spacing;
 
       if (dparam1 > 0)
       {
         output_size[0] = std::ceil(input_size[0] * (input_spacing[0] / dparam1));
         output_spacing[0] = dparam1;
       }
       else
       {
         output_size[0] = std::ceil(input_size[0] * (-1.0 / dparam1));
         output_spacing[0] = -1.0*input_spacing[0] * dparam1;
       }
       if (dparam2 > 0)
       {
         output_size[1] = std::ceil(input_size[1] * (input_spacing[1] / dparam2));
         output_spacing[1] = dparam2;
       }
       else
       {
         output_size[1] = std::ceil(input_size[1] * (-1.0 / dparam2));
         output_spacing[1] = -1.0*input_spacing[1] * dparam2;
       }
       if (dparam3 > 0)
       {
         output_size[2] = std::ceil(input_size[2] * (input_spacing[2] / dparam3));
         output_spacing[2] = dparam3;
       }
       else
       {
         output_size[2] = std::ceil(input_size[2] * (-1.0 / dparam3));
         output_spacing[2] = -1.0*input_spacing[2] * dparam3;
       }
 
       resampler->SetSize( output_size );
       resampler->SetOutputSpacing( output_spacing );
       resampler->SetOutputDirection( itkImage->GetDirection() );
 
       resampler->UpdateLargestPossibleRegion();
 
       ImageType::Pointer resampledImage = resampler->GetOutput();
 
       newImage = mitk::ImportItkImage( resampledImage )->Clone();
       nameAddition << "_Resampled_" << selectedInterpolator;
       std::cout << "Resampling successful." << std::endl;
   }
   catch (...)
   {
     this->BusyCursorOff();
-    QMessageBox::warning(NULL, "Warning", "Problem when applying filter operation. Check your input...");
+    QMessageBox::warning(nullptr, "Warning", "Problem when applying filter operation. Check your input...");
     return;
   }
 
   newImage->DisconnectPipeline();
 
   // adjust level/window to new image
   mitk::LevelWindow levelwindow;
   levelwindow.SetAuto( newImage );
   mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
   levWinProp->SetLevelWindow( levelwindow );
 
   // compose new image name
   std::string name = m_SelectedImageNode->GetNode()->GetName();
   if (name.find(".pic.gz") == name.size() -7 )
   {
     name = name.substr(0,name.size() -7);
   }
   name.append( nameAddition.str() );
 
   // create final result MITK data storage node
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty( "levelwindow", levWinProp );
   result->SetProperty( "name", mitk::StringProperty::New( name.c_str() ) );
   result->SetData( newImage );
 
   // for vector images, a different mapper is needed
   if(isVectorImage > 1)
   {
     mitk::VectorImageMapper2D::Pointer mapper =
       mitk::VectorImageMapper2D::New();
     result->SetMapper(1,mapper);
   }
 
   // add new image to data storage and set as active to ease further processing
   GetDataStorage()->Add( result, m_SelectedImageNode->GetNode() );
   if ( m_Controls->cbHideOrig->isChecked() == true )
     m_SelectedImageNode->GetNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
 
   // show the results
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   this->BusyCursorOff();
 }
 
 void QmitkPreprocessingResampling::SelectInterpolator(int interpolator)
 {
   switch (interpolator)
   {
   case 0:
     {
       m_SelectedInterpolation = LINEAR;
       break;
     }
   case 1:
     {
       m_SelectedInterpolation = NEAREST;
       break;
     }
   case 2:
   {
     m_SelectedInterpolation = SPLINE;
   }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonView.cpp b/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonView.cpp
index ccce177567..281c11b20b 100644
--- a/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonView.cpp
+++ b/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonView.cpp
@@ -1,101 +1,101 @@
 /*===================================================================
 
 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 "QmitkPythonView.h"
 #include <QmitkCtkPythonShell.h>
 #include "mitkPluginActivator.h"
 #include <QmitkPythonVariableStackTableView.h>
 #include <QmitkPythonTextEditor.h>
 #include <QmitkPythonSnippets.h>
 
 #include <QHeaderView>
 #include <QSplitter>
 #include <QGridLayout>
 
 const std::string QmitkPythonView::VIEW_ID = "org.mitk.views.python";
 
 struct QmitkPythonViewData
 {
     // widget
     QmitkPythonVariableStackTableView* m_PythonVariableStackTableView;
     QmitkPythonSnippets* m_PythonSnippets;
 
     QmitkCtkPythonShell* m_PythonShell;
     QmitkPythonTextEditor* m_TextEditor;
 };
 
 QmitkPythonView::QmitkPythonView()
     : d( new QmitkPythonViewData )
 {
-    d->m_PythonVariableStackTableView = 0;
-    d->m_PythonShell = 0;
+    d->m_PythonVariableStackTableView = nullptr;
+    d->m_PythonShell = nullptr;
 }
 
 QmitkPythonView::~QmitkPythonView()
 {
     delete d;
 }
 
 void QmitkPythonView::CreateQtPartControl(QWidget* parent)
 {
     d->m_PythonVariableStackTableView = new QmitkPythonVariableStackTableView;
     d->m_PythonVariableStackTableView->SetDataStorage(this->GetDataStorage());
     //d->m_PythonVariableStackTableView->horizontalHeader()->setResizeMode(QHeaderView::Interactive);
 
     QString snippetsFilePath = mitk::PluginActivator::m_XmlFilePath;
     MITK_DEBUG("QmitkPythonView") << "got snippetsFilePath " << snippetsFilePath.toStdString();
 
     d->m_PythonSnippets = new QmitkPythonSnippets(snippetsFilePath);
 
     MITK_DEBUG("QmitkPythonView") << "initializing varStackSnippetsTab";
     QTabWidget* varStackSnippetsTab = new QTabWidget;
     varStackSnippetsTab->addTab( d->m_PythonVariableStackTableView, "Variable Stack" );
     varStackSnippetsTab->addTab( d->m_PythonSnippets, "Snippets" );
     varStackSnippetsTab->setTabPosition( QTabWidget::South );
 
     MITK_DEBUG("QmitkPythonView") << "initializing m_PythonShell";
     d->m_PythonShell = new QmitkCtkPythonShell;
 
     MITK_DEBUG("QmitkPythonView") << "initializing m_TextEditor";
     d->m_TextEditor = new QmitkPythonTextEditor;
 
     MITK_DEBUG("QmitkPythonView") << "initializing tabWidgetConsoleEditor";
     QTabWidget* tabWidgetConsoleEditor = new QTabWidget;
     tabWidgetConsoleEditor->addTab( d->m_PythonShell, "Console" );
     tabWidgetConsoleEditor->addTab( d->m_TextEditor, "Text Editor" );
     tabWidgetConsoleEditor->setTabPosition( QTabWidget::South );
 
     QList<int> sizes;
     sizes << 1 << 3;
     QSplitter* splitter = new QSplitter;
     splitter->addWidget(varStackSnippetsTab);
     splitter->addWidget(tabWidgetConsoleEditor);
     splitter->setStretchFactor ( 0, 1 );
     splitter->setStretchFactor ( 1, 3 );
 
     QGridLayout* layout = new QGridLayout;
     layout->addWidget( splitter, 0, 0 );
     parent->setLayout(layout);
 
     MITK_DEBUG("QmitkPythonView") << "creating connections for m_PythonSnippets";
     connect( d->m_PythonSnippets, SIGNAL(PasteCommandRequested(QString)), d->m_PythonShell, SLOT(Paste(QString)) );
     connect( d->m_PythonSnippets, SIGNAL(PasteCommandRequested(QString)), d->m_TextEditor, SLOT(Paste(QString)) );
 }
 
 void QmitkPythonView::SetFocus()
 {
     d->m_PythonShell->setFocus();
 }
diff --git a/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkGIFConfigurationPanel.cpp b/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkGIFConfigurationPanel.cpp
index 56fc0d851f..c5b1e19246 100644
--- a/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkGIFConfigurationPanel.cpp
+++ b/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkGIFConfigurationPanel.cpp
@@ -1,221 +1,221 @@
 /*===================================================================
 
 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 "QmitkGIFConfigurationPanel.h"
 
 
 // QT
 #include <qwidget.h>
 #include <qboxlayout.h>
 #include <qformlayout.h>
 
 #include <qpushbutton.h>
 #include <qlabel.h>
 #include <qtextedit.h>
 #include <qlineedit.h>
 #include <qspinbox.h>
 
 #include <mitkLog.h>
 
 
 mitkUI::GIFConfigurationPanel::GIFConfigurationPanel(QWidget * parent, mitk::AbstractGlobalImageFeature::Pointer calculator) :
   QWidget(parent),
   m_FeatureCalculator(calculator)
 {
   QVBoxLayout * lay = new QVBoxLayout;
 
   QHBoxLayout * checkboxLayout = new QHBoxLayout;
   m_CheckCalculateFeature = new QCheckBox;
   m_CheckCalculateFeature->setText(m_FeatureCalculator->GetFeatureClassName().c_str());
   m_ButtonShowAdditionalConfiguration = new QPushButton;
   m_ButtonShowAdditionalConfiguration->setText("+");
   m_ButtonShowAdditionalConfiguration->setMaximumWidth(30);
   m_ButtonShowAdditionalConfiguration->setCheckable(true);
 
   checkboxLayout->addWidget(m_CheckCalculateFeature);
   checkboxLayout->addWidget(m_ButtonShowAdditionalConfiguration);
   lay->addItem(checkboxLayout);
 
   QFormLayout * argumentLayout = new QFormLayout;
   QLabel * label1 = new QLabel("Use Argument");
   QLabel * label2 = new QLabel("Argument Value");
   argumentLayout->addRow(label1, label2);
 
   mitkCommandLineParser parser;
   m_FeatureCalculator->AddArguments(parser);
   std::vector < std::map<std::string, us::Any> > argumentList = parser.getArgumentList();
   for (auto argument : argumentList)
   {
     QString longarg(argument["longarg"].ToString().c_str());
     if (longarg.contains("::"))
     {
 
       QCheckBox * argumentBox = new QCheckBox;
-      QWidget * secondWidget = NULL;
+      QWidget * secondWidget = nullptr;
       argumentBox->setText(longarg);
 
       mitkCommandLineParser::Type type = us::any_cast<mitkCommandLineParser::Type>(argument["valuetype"]);
       switch (type)
       {
       case mitkCommandLineParser::Bool:
         secondWidget = new QCheckBox;
         break;
       case mitkCommandLineParser::String:
       {
         QLineEdit* lineEdit = new QLineEdit;
         secondWidget = lineEdit;
         break;
       }
       case mitkCommandLineParser::Int:
       {
         QSpinBox* spinBox = new QSpinBox();
         spinBox->setMinimum(std::numeric_limits<int>::min());
         spinBox->setMaximum(std::numeric_limits<int>::max());
         secondWidget = spinBox;
         break;
       }
       case mitkCommandLineParser::Float:
       {
         QDoubleSpinBox* spindBox = new QDoubleSpinBox;
         spindBox->setMinimum(std::numeric_limits<double>::lowest());
         spindBox->setMaximum(std::numeric_limits<double>::max());
         secondWidget = spindBox;
         break;
       }
       default:
         secondWidget = new QLabel("unkonw type");
       }
 
       argumentLayout->addRow(argumentBox, secondWidget);
     }
   }
   if (argumentList.size() < 2)
   {
     m_ButtonShowAdditionalConfiguration->setVisible(false);
   }
   m_GroupBoxArguments = new QGroupBox;
   m_GroupBoxArguments->setTitle("");
   m_GroupBoxArguments->setLayout(argumentLayout);
   m_GroupBoxArguments->setVisible(false);
   lay->addWidget(m_GroupBoxArguments);
   //lay->addItem(argumentLayout);
 
 
   // Buttons see https://joekuan.wordpress.com/2015/09/23/list-of-qt-icons/
   // Resolution https://itk.org/Doxygen/html/classitk_1_1RecursiveMultiResolutionPyramidImageFilter.html
   // Wavelet https://code.google.com/archive/p/nwave/source/default/source
 
   this->setLayout(lay);
 
   connect((QObject*)(m_ButtonShowAdditionalConfiguration), SIGNAL(clicked(bool)), this, SLOT(OnSButtonShowAdditionalConfigurationPressed(bool)));
 }
 
 void
 mitkUI::GIFConfigurationPanel::OnSButtonShowAdditionalConfigurationPressed(bool /*status*/)
 {
   if (m_ButtonShowAdditionalConfiguration->isChecked())
   {
     m_ButtonShowAdditionalConfiguration->setText("-");
     m_GroupBoxArguments->setVisible(true);
   }
   else
   {
     m_ButtonShowAdditionalConfiguration->setText("+");
     m_GroupBoxArguments->setVisible(false);
   }
 }
 
 void
 mitkUI::GIFConfigurationPanel::CalculateFeaturesUsingParameters(const mitk::Image::Pointer & feature, const mitk::Image::Pointer &mask, std::map < std::string, us::Any> parameter, mitk::AbstractGlobalImageFeature::FeatureListType &featureList)
 {
   parameter[m_FeatureCalculator->GetLongName()] = us::Any(true);
 
   if (m_CheckCalculateFeature->isChecked())
   {
     for (int i = 0; i < m_GroupBoxArguments->layout()->count(); i+=2)
     {
       QCheckBox * argumentBox = dynamic_cast<QCheckBox* >(m_GroupBoxArguments->layout()->itemAt(i)->widget());
-      if (argumentBox != NULL)
+      if (argumentBox != nullptr)
       {
         if (argumentBox->isChecked() == false)
         {
           continue;
         }
         std::string argumentName = argumentBox->text().toStdString();
 
 
         QCheckBox * paramBool = dynamic_cast<QCheckBox*>(m_GroupBoxArguments->layout()->itemAt(i + 1)->widget());
         QLineEdit * paramText = dynamic_cast<QLineEdit*>(m_GroupBoxArguments->layout()->itemAt(i + 1)->widget());
         QSpinBox * paramInt = dynamic_cast<QSpinBox*>(m_GroupBoxArguments->layout()->itemAt(i + 1)->widget());
         QDoubleSpinBox * paramFloat = dynamic_cast<QDoubleSpinBox*>(m_GroupBoxArguments->layout()->itemAt(i + 1)->widget());
 
-        if (paramBool == NULL && paramText == NULL && paramInt == NULL && paramFloat == NULL)
+        if (paramBool == nullptr && paramText == nullptr && paramInt == nullptr && paramFloat == nullptr)
         {
           continue;
         }
 
         us::Any value;
-        if (paramBool != NULL)
+        if (paramBool != nullptr)
         {
           value = us::Any(paramBool->isChecked());
         }
-        if (paramText != NULL)
+        if (paramText != nullptr)
         {
           value = us::Any(paramText->text().toStdString());
         }
-        if (paramInt != NULL)
+        if (paramInt != nullptr)
         {
           value = us::Any(paramInt->value());
         }
-        if (paramFloat != NULL)
+        if (paramFloat != nullptr)
         {
           value = us::Any(float(paramFloat->value()));
         }
 
         parameter[argumentName] = value;
         MITK_INFO << argumentName << " : " << value.ToString();
       }
     }
     auto tmpPointer = m_FeatureCalculator->Clone();
     mitk::AbstractGlobalImageFeature::Pointer tmpCalc = dynamic_cast<mitk::AbstractGlobalImageFeature*>(tmpPointer.GetPointer());
     for (auto item : parameter)
     {
       MITK_INFO << item.first << " : " << item.second.ToString();
     }
     tmpCalc->SetParameter(parameter);
     bool calculateSliceWise = false;
     int slice = 0;
     if (parameter.count("slice-wise"))
     {
       slice = us::any_cast<int>(parameter["slice-wise"]);
       calculateSliceWise = true;
     }
     if (parameter.count("encode-parameter-in-name"))
     {
       bool encodeParameter = us::any_cast<bool>(parameter["encode-parameter-in-name"]);
       tmpCalc->SetEncodeParameters(encodeParameter);
     }
     if (calculateSliceWise)
     {
       tmpCalc->CalculateFeaturesSliceWiseUsingParameters(feature, mask, slice, featureList);
     }
     else
     {
       tmpCalc->CalculateFeaturesUsingParameters(feature, mask, mask, featureList);
     }
   }
 }
 
diff --git a/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsArithmetricView.cpp b/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsArithmetricView.cpp
index 520c405bd1..1bc57dd3b6 100644
--- a/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsArithmetricView.cpp
+++ b/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsArithmetricView.cpp
@@ -1,478 +1,478 @@
 /*===================================================================
 
 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 "QmitkRadiomicsArithmetricView.h"
 
 // QT includes (GUI)
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qmessagebox.h>
 
 // Berry includes (selection service)
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // MITK includes (GUI)
 #include <QmitkDataStorageComboBox.h>
 #include "QmitkDataNodeSelectionProvider.h"
 #include "mitkDataNodeObject.h"
 
 // MITK includes (general
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkProperties.h>
 #include <mitkArithmeticOperation.h>
 
 // Specific GUI Includes
 #include "QmitkGIFConfigurationPanel.h"
 
 QmitkRadiomicsArithmetric::QmitkRadiomicsArithmetric()
 : QmitkAbstractView(),
   m_Controls(nullptr)
 {
 }
 
 QmitkRadiomicsArithmetric::~QmitkRadiomicsArithmetric()
 {
 
 }
 
 void QmitkRadiomicsArithmetric::CreateQtPartControl(QWidget *parent)
 {
   if (m_Controls == nullptr)
   {
     m_Controls = new Ui::QmitkRadiomicsArithmetricViewControls;
     m_Controls->setupUi(parent);
 
     QLabel * label1 = new QLabel("Image: ");
     QmitkDataStorageComboBox * cb_inputimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::Image>::New());
     m_Controls->m_InputImageGroup->layout()->addWidget(label1);
     m_Controls->m_InputImageGroup->layout()->addWidget(cb_inputimage);
 
     QLabel * label2 = new QLabel("Second Image: ");
     QmitkDataStorageComboBox * cb_inputimage2 = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::Image>::New());
     m_Controls->secondImageWidget->layout()->addWidget(label2);
     m_Controls->secondImageWidget->layout()->addWidget(cb_inputimage2);
 
     this->CreateConnections();
   }
 }
 
 void QmitkRadiomicsArithmetric::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->buttonTan), SIGNAL(clicked() ), this, SLOT(TanButton()));
     connect((QObject*)(m_Controls->buttonATan), SIGNAL(clicked()), this, SLOT(ATanButton()));
     connect((QObject*)(m_Controls->buttonCos), SIGNAL(clicked()), this, SLOT(CosButton()));
     connect((QObject*)(m_Controls->buttonACos), SIGNAL(clicked()), this, SLOT(ACosButton()));
     connect((QObject*)(m_Controls->buttonSin), SIGNAL(clicked()), this, SLOT(SinButton()));
     connect((QObject*)(m_Controls->buttonASin), SIGNAL(clicked()), this, SLOT(ASinButton()));
     connect((QObject*)(m_Controls->buttonSquare), SIGNAL(clicked()), this, SLOT(SquareButton()));
     connect((QObject*)(m_Controls->buttonSqrt), SIGNAL(clicked()), this, SLOT(SqrtButton()));
     connect((QObject*)(m_Controls->buttonAbs), SIGNAL(clicked()), this, SLOT(AbsButton()));
     connect((QObject*)(m_Controls->buttonExp), SIGNAL(clicked()), this, SLOT(ExpButton()));
     connect((QObject*)(m_Controls->buttonExpNeg), SIGNAL(clicked()), this, SLOT(ExpNegButton()));
     connect((QObject*)(m_Controls->buttonLog10), SIGNAL(clicked()), this, SLOT(Log10Button()));
 
     connect((QObject*)(m_Controls->buttonAddLeft), SIGNAL(clicked()), this, SLOT(AddLeftButton()));
     connect((QObject*)(m_Controls->buttonSubLeft), SIGNAL(clicked()), this, SLOT(SubLeftButton()));
     connect((QObject*)(m_Controls->buttonSubRight), SIGNAL(clicked()), this, SLOT(SubRightButton()));
     connect((QObject*)(m_Controls->buttonMulLeft), SIGNAL(clicked()), this, SLOT(MulLeftButton()));
     connect((QObject*)(m_Controls->buttonDivLeft), SIGNAL(clicked()), this, SLOT(DivLeftButton()));
     connect((QObject*)(m_Controls->buttonDivRight), SIGNAL(clicked()), this, SLOT(DivRightButton()));
 
     connect((QObject*)(m_Controls->buttonAdd), SIGNAL(clicked()), this, SLOT(AddButton()));
     connect((QObject*)(m_Controls->buttonSub), SIGNAL(clicked()), this, SLOT(SubButton()));
     connect((QObject*)(m_Controls->buttonMul), SIGNAL(clicked()), this, SLOT(MulButton()));
     connect((QObject*)(m_Controls->buttonDiv), SIGNAL(clicked()), this, SLOT(DivButton()));
   }
 }
 
 mitk::Image::Pointer QmitkRadiomicsArithmetric::GetFirstImage()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
-  mitk::BaseData* baseDataRawImage = NULL;
+  mitk::BaseData* baseDataRawImage = nullptr;
 
   mitk::Image::Pointer raw_image;
   std::string nodeName;
   if ((cb_image->GetSelectedNode().IsNotNull()))
   {
     baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
     nodeName = cb_image->GetSelectedNode()->GetName();
   }
-  if ((baseDataRawImage != NULL))
+  if ((baseDataRawImage != nullptr))
   {
     raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the images that shlould be used.");
     msgBox.exec();
-    return NULL;
+    return nullptr;
   }
   if (raw_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
-    return NULL;
+    return nullptr;
   }
 
   return raw_image;
 }
 
 mitk::Image::Pointer QmitkRadiomicsArithmetric::GetSecondImage()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->secondImageWidget->layout()->itemAt(1)->widget());
-  mitk::BaseData* baseDataRawImage = NULL;
+  mitk::BaseData* baseDataRawImage = nullptr;
 
   mitk::Image::Pointer raw_image;
   std::string nodeName;
   if ((cb_image->GetSelectedNode().IsNotNull()))
   {
     baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
     nodeName = cb_image->GetSelectedNode()->GetName();
   }
-  if ((baseDataRawImage != NULL))
+  if ((baseDataRawImage != nullptr))
   {
     raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the second images that should be used.");
     msgBox.exec();
-    return NULL;
+    return nullptr;
   }
   if (raw_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
-    return NULL;
+    return nullptr;
   }
 
   return raw_image;
 }
 
 
 void QmitkRadiomicsArithmetric::AddImageToNode(mitk::Image::Pointer image, std::string nameAddition)
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
   std::string nodeName;
   if ((cb_image->GetSelectedNode().IsNotNull()))
   {
     nodeName = cb_image->GetSelectedNode()->GetName();
   }
 
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty("name", mitk::StringProperty::New(nodeName + nameAddition));
   result->SetData(image);
   GetDataStorage()->Add(result, cb_image->GetSelectedNode());
 }
 
 
 void QmitkRadiomicsArithmetric::TanButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Tan(firstImage, asDouble);
   AddImageToNode(result, "::Tan");
 }
 
 void QmitkRadiomicsArithmetric::ATanButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Tan(firstImage, asDouble);
   AddImageToNode(result, "::ATan");
 }
 
 void QmitkRadiomicsArithmetric::CosButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Cos(firstImage, asDouble);
   AddImageToNode(result, "::Cos");
 }
 
 void QmitkRadiomicsArithmetric::ACosButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Acos(firstImage, asDouble);
   AddImageToNode(result, "::ACos");
 }
 
 void QmitkRadiomicsArithmetric::SinButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Sin(firstImage, asDouble);
   AddImageToNode(result, "::Sin");
 }
 
 void QmitkRadiomicsArithmetric::ASinButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Asin(firstImage, asDouble);
   AddImageToNode(result, "::ASin");
 }
 
 void QmitkRadiomicsArithmetric::SquareButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Square(firstImage, asDouble);
   AddImageToNode(result, "::Square");
 }
 
 void QmitkRadiomicsArithmetric::SqrtButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Sqrt(firstImage, asDouble);
   AddImageToNode(result, "::Sqrt");
 }
 
 void QmitkRadiomicsArithmetric::AbsButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Abs(firstImage, asDouble);
   AddImageToNode(result, "::Abs");
 }
 
 void QmitkRadiomicsArithmetric::ExpButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Exp(firstImage, asDouble);
   AddImageToNode(result, "::Exp");
 }
 
 void QmitkRadiomicsArithmetric::ExpNegButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::ExpNeg(firstImage, asDouble);
   AddImageToNode(result, "::ExpNeg");
 }
 
 void QmitkRadiomicsArithmetric::Log10Button()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Log10(firstImage, asDouble);
   AddImageToNode(result, "::Log10");
 }
 
 void QmitkRadiomicsArithmetric::AddLeftButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   double value = m_Controls->m_DoubleValue->value();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Add(firstImage, value, asDouble);
   AddImageToNode(result, "::Add");
 }
 
 void QmitkRadiomicsArithmetric::SubLeftButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   double value = m_Controls->m_DoubleValue->value();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Subtract(firstImage, value, asDouble);
   AddImageToNode(result, "::Sub");
 }
 
 void QmitkRadiomicsArithmetric::SubRightButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   double value = m_Controls->m_DoubleValue->value();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Subtract(value, firstImage, asDouble);
   AddImageToNode(result, "::Sub");
 }
 
 void QmitkRadiomicsArithmetric::MulLeftButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   double value = m_Controls->m_DoubleValue->value();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Multiply(firstImage, value, asDouble);
   AddImageToNode(result, "::Mul");
 }
 
 void QmitkRadiomicsArithmetric::DivLeftButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   double value = m_Controls->m_DoubleValue->value();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Divide(firstImage, value, asDouble);
   AddImageToNode(result, "::Div");
 }
 
 void QmitkRadiomicsArithmetric::DivRightButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   double value = m_Controls->m_DoubleValue->value();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Divide(value, firstImage,asDouble);
   AddImageToNode(result, "::Div");
 }
 
 void QmitkRadiomicsArithmetric::AddButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   mitk::Image::Pointer secondImage = GetSecondImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Add(firstImage, secondImage, asDouble);
   AddImageToNode(result, "::Add");
 }
 
 void QmitkRadiomicsArithmetric::MulButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   mitk::Image::Pointer secondImage = GetSecondImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Multiply(firstImage, secondImage, asDouble);
   AddImageToNode(result, "::Mul");
 }
 
 void QmitkRadiomicsArithmetric::SubButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   mitk::Image::Pointer secondImage = GetSecondImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Subtract(firstImage, secondImage, asDouble);
   AddImageToNode(result, "::Sub");
 }
 
 void QmitkRadiomicsArithmetric::DivButton()
 {
   mitk::Image::Pointer firstImage = GetFirstImage();
   mitk::Image::Pointer secondImage = GetSecondImage();
   bool asDouble = m_Controls->m_ResultAsDouble->isChecked();
   if (firstImage.IsNull())
   {
     return;
   }
   auto result = mitk::ArithmeticOperation::Divide(firstImage, secondImage, asDouble);
   AddImageToNode(result, "::Div");
 }
 
 void QmitkRadiomicsArithmetric::SetFocus()
 {
 }
 
 //datamanager selection changed
 void QmitkRadiomicsArithmetric::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
 {
   //any nodes there?
   if (!nodes.empty())
   {
 
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsMaskProcessingView.cpp b/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsMaskProcessingView.cpp
index 745f311609..8c2f486f6a 100644
--- a/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsMaskProcessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsMaskProcessingView.cpp
@@ -1,205 +1,205 @@
 /*===================================================================
 
 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 "QmitkRadiomicsMaskProcessingView.h"
 
 // QT includes (GUI)
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qmessagebox.h>
 
 // Berry includes (selection service)
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // MITK includes (GUI)
 #include <QmitkDataStorageComboBox.h>
 #include "QmitkDataNodeSelectionProvider.h"
 #include "mitkDataNodeObject.h"
 
 // MITK includes (general
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkProperties.h>
 #include <mitkTransformationOperation.h>
 #include <mitkLabelSetImage.h>
 
 // Specific GUI Includes
 #include <mitkMaskCleaningOperation.h>
 
 QmitkRadiomicsMaskProcessing::QmitkRadiomicsMaskProcessing()
 : QmitkAbstractView(),
   m_Controls(nullptr)
 {
 }
 
 QmitkRadiomicsMaskProcessing::~QmitkRadiomicsMaskProcessing()
 {
   //berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   //if(s)
   //  s->RemoveSelectionListener(m_SelectionListener);
 }
 
 void QmitkRadiomicsMaskProcessing::CreateQtPartControl(QWidget *parent)
 {
   if (m_Controls == nullptr)
   {
     m_Controls = new Ui::QmitkRadiomicsMaskProcessingViewControls;
     m_Controls->setupUi(parent);
 
     QLabel * label1 = new QLabel("Image: ");
     QLabel * label2 = new QLabel("Mask: ");
     QmitkDataStorageComboBox * cb_inputimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::Image>::New());
     QmitkDataStorageComboBox * cb_maskimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
     m_Controls->m_InputImageGroup->layout()->addWidget(label1);
     m_Controls->m_InputImageGroup->layout()->addWidget(cb_inputimage);
     m_Controls->m_InputImageGroup->layout()->addWidget(label2);
     m_Controls->m_InputImageGroup->layout()->addWidget(cb_maskimage);
 
     this->CreateConnections();
   }
 }
 
 void QmitkRadiomicsMaskProcessing::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->maskBasedExecutionButton), SIGNAL(clicked() ), this, SLOT(executeButtonIntervalBasedMaskClearning() ) );
     connect((QObject*)(m_Controls->outlierRemoveButton), SIGNAL(clicked()), this, SLOT(executeButtonMaskOutlierRemoval()));
   }
 }
 
 void QmitkRadiomicsMaskProcessing::executeButtonIntervalBasedMaskClearning()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
   QmitkDataStorageComboBox * cb_maskimage = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(3)->widget());
-  mitk::BaseData* baseDataRawImage = NULL;
-  mitk::BaseData* baseDataMaskImage = NULL;
+  mitk::BaseData* baseDataRawImage = nullptr;
+  mitk::BaseData* baseDataMaskImage = nullptr;
 
   mitk::Image::Pointer raw_image;
   mitk::Image::Pointer mask_image;
   std::string nodeName;
 
   if ((cb_image->GetSelectedNode().IsNotNull()) && (cb_maskimage->GetSelectedNode().IsNotNull()))
   {
     baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
     baseDataMaskImage = (cb_maskimage->GetSelectedNode()->GetData());
     nodeName = cb_maskimage->GetSelectedNode()->GetName();
   }
-  if ((baseDataRawImage != NULL) && (baseDataMaskImage != NULL))
+  if ((baseDataRawImage != nullptr) && (baseDataMaskImage != nullptr))
   {
     raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
     mask_image = dynamic_cast<mitk::Image *>(baseDataMaskImage);
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the images that shlould be used.");
     msgBox.exec();
     return;
   }
   if (raw_image.IsNull() || mask_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
     return;
   }
 
   bool lowerLimitOn = m_Controls->lowerOn->isChecked();
   bool upperLimitOn = m_Controls->upperOn->isChecked();
   double lowerLimit = m_Controls->lowerLimitSpinbox->value();
   double upperLimit = m_Controls->spinboxUpperValue->value();
 
 
   auto image = mitk::MaskCleaningOperation::RangeBasedMasking(raw_image, mask_image, lowerLimitOn, lowerLimit, upperLimitOn, upperLimit);
 
   mitk::LabelSetImage::Pointer labelResult = mitk::LabelSetImage::New();
   labelResult->InitializeByLabeledImage(image);
   mitk::LabelSetImage::Pointer oldLabelSet = dynamic_cast<mitk::LabelSetImage *>(mask_image.GetPointer());
   labelResult->AddLabelSetToLayer(labelResult->GetActiveLayer(), oldLabelSet->GetLabelSet());
 
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty("name", mitk::StringProperty::New(nodeName+"::MaskRange"));
   result->SetData(labelResult);
   GetDataStorage()->Add(result, cb_image->GetSelectedNode());
 }
 
 void QmitkRadiomicsMaskProcessing::executeButtonMaskOutlierRemoval()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
   QmitkDataStorageComboBox * cb_maskimage = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(3)->widget());
-  mitk::BaseData* baseDataRawImage = NULL;
-  mitk::BaseData* baseDataMaskImage = NULL;
+  mitk::BaseData* baseDataRawImage = nullptr;
+  mitk::BaseData* baseDataMaskImage = nullptr;
 
   mitk::Image::Pointer raw_image;
   mitk::Image::Pointer mask_image;
   std::string nodeName;
 
   if ((cb_image->GetSelectedNode().IsNotNull()) && (cb_maskimage->GetSelectedNode().IsNotNull()))
   {
     baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
     baseDataMaskImage = (cb_maskimage->GetSelectedNode()->GetData());
     nodeName = cb_maskimage->GetSelectedNode()->GetName();
   }
-  if ((baseDataRawImage != NULL) && (baseDataMaskImage != NULL))
+  if ((baseDataRawImage != nullptr) && (baseDataMaskImage != nullptr))
   {
     raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
     mask_image = dynamic_cast<mitk::Image *>(baseDataMaskImage);
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the images that shlould be used.");
     msgBox.exec();
     return;
   }
   if (raw_image.IsNull() || mask_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
     return;
   }
 
   auto image = mitk::MaskCleaningOperation::MaskOutlierFiltering(raw_image, mask_image);
 
   mitk::LabelSetImage::Pointer labelResult = mitk::LabelSetImage::New();
   labelResult->InitializeByLabeledImage(image);
   mitk::LabelSetImage::Pointer oldLabelSet = dynamic_cast<mitk::LabelSetImage *>(mask_image.GetPointer());
   labelResult->AddLabelSetToLayer(labelResult->GetActiveLayer(), oldLabelSet->GetLabelSet());
 
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty("name", mitk::StringProperty::New(nodeName + "::MaskOutlier"));
   result->SetData(labelResult);
   GetDataStorage()->Add(result, cb_image->GetSelectedNode());
 }
 
 void QmitkRadiomicsMaskProcessing::SetFocus()
 {
 }
 
 //datamanager selection changed
 void QmitkRadiomicsMaskProcessing::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
 {
   //any nodes there?
   if (!nodes.empty())
   {
 
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsStatisticView.cpp b/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsStatisticView.cpp
index 3f7296a1ff..1cf4823b55 100644
--- a/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsStatisticView.cpp
+++ b/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsStatisticView.cpp
@@ -1,330 +1,330 @@
 /*===================================================================
 
 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 "QmitkRadiomicsStatisticView.h"
 
 // QT includes (GUI)
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qmessagebox.h>
 #include <QApplication>
 #include <QClipboard>
 
 // Berry includes (selection service)
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // MITK includes (GUI)
 #include <QmitkDataStorageComboBox.h>
 #include "QmitkDataNodeSelectionProvider.h"
 #include "mitkDataNodeObject.h"
 
 // MITK includes (general)
 #include "mitkLabelSetImage.h"
 #include <mitkAbstractGlobalImageFeature.h>
 #include <mitkGIFCooccurenceMatrix.h>
 #include <mitkGIFCooccurenceMatrix2.h>
 #include <mitkGIFGreyLevelRunLength.h>
 #include <mitkGIFFirstOrderStatistics.h>
 #include <mitkGIFFirstOrderHistogramStatistics.h>
 #include <mitkGIFFirstOrderNumericStatistics.h>
 #include <mitkGIFVolumetricStatistics.h>
 #include <mitkGIFVolumetricDensityStatistics.h>
 #include <mitkGIFGreyLevelSizeZone.h>
 #include <mitkGIFGreyLevelDistanceZone.h>
 #include <mitkGIFImageDescriptionFeatures.h>
 #include <mitkGIFLocalIntensity.h>
 #include <mitkGIFCurvatureStatistic.h>
 #include <mitkGIFIntensityVolumeHistogramFeatures.h>
 #include <mitkGIFNeighbourhoodGreyToneDifferenceFeatures.h>
 #include <mitkGIFNeighbouringGreyLevelDependenceFeatures.h>
 
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateDimension.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkProperties.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkImageStatisticsHolder.h>
 
 // Includes for image casting between ITK and MITK
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 
 // Specific GUI Includes
 #include "QmitkGIFConfigurationPanel.h"
 
 QmitkRadiomicsStatistic::QmitkRadiomicsStatistic()
 : QmitkAbstractView(),
   m_Controls(nullptr)
 {
 }
 
 QmitkRadiomicsStatistic::~QmitkRadiomicsStatistic()
 {
   //berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   //if(s)
   //  s->RemoveSelectionListener(m_SelectionListener);
 }
 
 void QmitkRadiomicsStatistic::CreateQtPartControl(QWidget *parent)
 {
   if (m_Controls == nullptr)
   {
     mitk::GIFImageDescriptionFeatures::Pointer ipCalculator = mitk::GIFImageDescriptionFeatures::New(); // Commented 2, Tested
     mitk::GIFFirstOrderStatistics::Pointer firstOrderCalculator = mitk::GIFFirstOrderStatistics::New(); //Commented 2
     mitk::GIFFirstOrderHistogramStatistics::Pointer firstOrderHistoCalculator = mitk::GIFFirstOrderHistogramStatistics::New(); // Commented 2, Tested
     mitk::GIFFirstOrderNumericStatistics::Pointer firstOrderNumericCalculator = mitk::GIFFirstOrderNumericStatistics::New(); // Commented 2, Tested
     mitk::GIFVolumetricStatistics::Pointer volCalculator = mitk::GIFVolumetricStatistics::New();   // Commented 2, Tested
     mitk::GIFVolumetricDensityStatistics::Pointer voldenCalculator = mitk::GIFVolumetricDensityStatistics::New(); // Commented 2, Tested
     mitk::GIFCooccurenceMatrix::Pointer coocCalculator = mitk::GIFCooccurenceMatrix::New(); // Commented 2, Will not be tested
     mitk::GIFCooccurenceMatrix2::Pointer cooc2Calculator = mitk::GIFCooccurenceMatrix2::New(); //Commented 2
     mitk::GIFNeighbouringGreyLevelDependenceFeature::Pointer ngldCalculator = mitk::GIFNeighbouringGreyLevelDependenceFeature::New(); //Commented 2, Tested
     mitk::GIFGreyLevelRunLength::Pointer rlCalculator = mitk::GIFGreyLevelRunLength::New(); // Commented 2
     mitk::GIFGreyLevelSizeZone::Pointer glszCalculator = mitk::GIFGreyLevelSizeZone::New(); // Commented 2, Tested
     mitk::GIFGreyLevelDistanceZone::Pointer gldzCalculator = mitk::GIFGreyLevelDistanceZone::New(); //Commented 2, Tested
     mitk::GIFLocalIntensity::Pointer lociCalculator = mitk::GIFLocalIntensity::New(); //Commented 2, Tested
     mitk::GIFIntensityVolumeHistogramFeatures::Pointer ivohCalculator = mitk::GIFIntensityVolumeHistogramFeatures::New(); // Commented 2
     mitk::GIFNeighbourhoodGreyToneDifferenceFeatures::Pointer ngtdCalculator = mitk::GIFNeighbourhoodGreyToneDifferenceFeatures::New(); //Commented 2, Tested
     mitk::GIFCurvatureStatistic::Pointer curvCalculator = mitk::GIFCurvatureStatistic::New(); //Commented 2, Tested
 
     std::vector<mitk::AbstractGlobalImageFeature::Pointer> features;
     features.push_back(volCalculator.GetPointer());
     features.push_back(voldenCalculator.GetPointer());
     features.push_back(curvCalculator.GetPointer());
     features.push_back(firstOrderCalculator.GetPointer());
     features.push_back(firstOrderNumericCalculator.GetPointer());
     features.push_back(firstOrderHistoCalculator.GetPointer());
     features.push_back(ivohCalculator.GetPointer());
     features.push_back(lociCalculator.GetPointer());
     features.push_back(cooc2Calculator.GetPointer());
     features.push_back(ngldCalculator.GetPointer());
     features.push_back(rlCalculator.GetPointer());
     features.push_back(glszCalculator.GetPointer());
     features.push_back(gldzCalculator.GetPointer());
     features.push_back(ipCalculator.GetPointer());
     features.push_back(ngtdCalculator.GetPointer());
 
     m_Controls = new Ui::QmitkRadiomicsStatisticViewControls;
     m_Controls->setupUi(parent);
 
     for (auto cFeature : features)
     {
       mitkUI::GIFConfigurationPanel* gifPanel = new mitkUI::GIFConfigurationPanel(parent, cFeature);
       m_Controls->m_FeaturesGroup->layout()->addWidget(gifPanel);
     }
 
     QLabel * label1 = new QLabel("Image: ");
     QLabel * label2 = new QLabel("Mask: ");
     QmitkDataStorageComboBox * cb_inputimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::Image>::New());
     QmitkDataStorageComboBox * cb_maskimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
     m_Controls->m_InputImageGroup->layout()->addWidget(label1);
     m_Controls->m_InputImageGroup->layout()->addWidget(cb_inputimage);
     m_Controls->m_InputImageGroup->layout()->addWidget(label2);
     m_Controls->m_InputImageGroup->layout()->addWidget(cb_maskimage);
 
     this->CreateConnections();
 
     //setup predictaes for combobox
 
     mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
     mitk::NodePredicateDataType::Pointer imagePredicate = mitk::NodePredicateDataType::New("Image");
 
 
   }
 }
 
 void QmitkRadiomicsStatistic::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->buttonExecute), SIGNAL(clicked() ), this, SLOT(executeButtonPressed() ) );
     connect((QObject*)(m_Controls->buttonExecuteAndAppend), SIGNAL(clicked()), this, SLOT(executeAndAppendButtonPressed()));
     connect((QObject*)(m_Controls->buttonTableToClipboard), SIGNAL(clicked()), this, SLOT(copyToClipboardButtonPressed()));
   }
 }
 
 std::map < std::string, us::Any> QmitkRadiomicsStatistic::GenerateParameters()
 {
   std::map < std::string, us::Any> parameter;
 
   if (m_Controls->m_SetMinimumIntensity->isChecked())
   {
     parameter["minimum-intensity"] = us::Any(float(m_Controls->m_ParamMinimumIntensity->value()));
   }
   if (m_Controls->m_SetMaximumIntensity->isChecked())
   {
     parameter["maximum-intensity"] = us::Any(float(m_Controls->m_ParamMaximumIntensity->value()));
   }
   if (m_Controls->m_SetNumberOfBins->isChecked())
   {
     parameter["bins"] = us::Any(m_Controls->m_ParamBins->value());
   }
   if (m_Controls->m_SetBinSize->isChecked())
   {
     parameter["binsize"] = us::Any(float(m_Controls->m_ParamBinSize->value()));
   }
   if (m_Controls->m_SetIgnoreBinSize->isChecked())
   {
     parameter["ignore-mask-for-histogram"] = us::Any(m_Controls->m_ParamIgnoreMask->isChecked());
   }
   if (m_Controls->m_SetEncodeParameterInName->isChecked())
   {
     parameter["encode-parameter-in-name"] = us::Any(m_Controls->m_ParamEncodeName->isChecked());
   }
   if (m_Controls->m_SetDirectionParameter->isChecked())
   {
     parameter["direction"] = us::Any(m_Controls->m_ParamDirection->value());
   }
   if (m_Controls->m_SetSliceWiseParameter->isChecked())
   {
     parameter["slice-wise"] = us::Any(m_Controls->m_ParamSliceWise->value());
   }
 
   return parameter;
 }
 
 void QmitkRadiomicsStatistic::executeButtonPressed()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
   QmitkDataStorageComboBox * cb_maskimage = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(3)->widget());
-  mitk::BaseData* baseDataRawImage = NULL;
-  mitk::BaseData* baseDataMaskImage = NULL;
+  mitk::BaseData* baseDataRawImage = nullptr;
+  mitk::BaseData* baseDataMaskImage = nullptr;
 
   mitk::Image::Pointer raw_image;
   mitk::Image::Pointer mask_image;
   QString imageName;
   QString maskName;
 
   if ((cb_image->GetSelectedNode().IsNotNull() ) && (cb_maskimage->GetSelectedNode().IsNotNull()))
   {
     imageName = cb_image->GetSelectedNode()->GetName().c_str();
     maskName = cb_maskimage->GetSelectedNode()->GetName().c_str();
     baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
     baseDataMaskImage = (cb_maskimage->GetSelectedNode()->GetData());
   }
-  if ((baseDataRawImage != NULL) && (baseDataMaskImage != NULL))
+  if ((baseDataRawImage != nullptr) && (baseDataMaskImage != nullptr))
   {
     raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
     mask_image = dynamic_cast<mitk::Image *>(baseDataMaskImage);
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the images that shlould be used.");
     msgBox.exec();
     return;
   }
   if (raw_image.IsNull() || mask_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
     return;
   }
 
   mitk::AbstractGlobalImageFeature::FeatureListType stats;
   for (int i = 0; i < m_Controls->m_FeaturesGroup->layout()->count(); ++i)
   {
     auto parameter = this->GenerateParameters();
 
     mitkUI::GIFConfigurationPanel* gifPanel = dynamic_cast<mitkUI::GIFConfigurationPanel*>(m_Controls->m_FeaturesGroup->layout()->itemAt(i)->widget());
-    if (gifPanel == NULL)
+    if (gifPanel == nullptr)
       continue;
     gifPanel->CalculateFeaturesUsingParameters(raw_image, mask_image, parameter, stats);
   }
 
   m_Controls->m_ResultTable->setRowCount(stats.size());
 
   for (std::size_t i = 0; i < stats.size(); ++i)
   {
     m_Controls->m_ResultTable->setItem(i, 0, new QTableWidgetItem(imageName));
     m_Controls->m_ResultTable->setItem(i, 1, new QTableWidgetItem(maskName));
     m_Controls->m_ResultTable->setItem(i, 2, new QTableWidgetItem(stats[i].first.c_str()));
     m_Controls->m_ResultTable->setItem(i, 3, new QTableWidgetItem(QString::number(stats[i].second)));
   }
   }
 
 void QmitkRadiomicsStatistic::executeAndAppendButtonPressed()
 {
   std::vector<QTableWidgetItem *> elementImage;
   std::vector<QTableWidgetItem *> elementMask;
   std::vector<QTableWidgetItem *> elementText;
   std::vector<QTableWidgetItem *> elementValue;
 
   for (int i = 0; i < m_Controls->m_ResultTable->rowCount(); ++i)
   {
     auto itemImage = m_Controls->m_ResultTable->item(i, 0)->clone();
     auto itemMask = m_Controls->m_ResultTable->item(i, 1)->clone();
     auto itemText = m_Controls->m_ResultTable->item(i, 2)->clone();
     auto itemValue = m_Controls->m_ResultTable->item(i, 3)->clone();
     elementImage.push_back(itemImage);
     elementMask.push_back(itemMask);
     elementText.push_back(itemText);
     elementValue.push_back(itemValue);
   }
 
   executeButtonPressed();
 
   std::size_t oldSize = m_Controls->m_ResultTable->rowCount();
   m_Controls->m_ResultTable->setRowCount(oldSize + elementText.size());
 
   for (std::size_t i = 0; i < elementText.size(); ++i)
   {
     m_Controls->m_ResultTable->setItem(i + oldSize, 0, elementImage[i]);
     m_Controls->m_ResultTable->setItem(i + oldSize, 1, elementMask[i]);
     m_Controls->m_ResultTable->setItem(i+oldSize, 2, elementText[i]);
     m_Controls->m_ResultTable->setItem(i+oldSize, 3, elementValue[i]);
   }
 }
 
 void QmitkRadiomicsStatistic::copyToClipboardButtonPressed()
 {
   QString selectedText;
   for (int i = 0; i < m_Controls->m_ResultTable->rowCount(); ++i)
   {
     auto itemImage = m_Controls->m_ResultTable->item(i, 0);
     auto itemMask = m_Controls->m_ResultTable->item(i, 1);
     auto itemText = m_Controls->m_ResultTable->item(i, 2);
     auto itemValue = m_Controls->m_ResultTable->item(i, 3);
     selectedText.append(itemImage->text());
     selectedText.append(";");
     selectedText.append(itemMask->text());
     selectedText.append(";");
     selectedText.append(itemText->text());
     selectedText.append(";");
     selectedText.append(itemValue->text());
     selectedText.append("\n");
   }
   QApplication::clipboard()->setText(selectedText);
 }
 
 void QmitkRadiomicsStatistic::SetFocus()
 {
 }
 
 //datamanager selection changed
 void QmitkRadiomicsStatistic::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
 {
   //any nodes there?
   if (!nodes.empty())
   {
 
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsTransformationView.cpp b/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsTransformationView.cpp
index 88ad07f15f..803df97cc5 100644
--- a/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsTransformationView.cpp
+++ b/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsTransformationView.cpp
@@ -1,379 +1,379 @@
 /*===================================================================
 
 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 "QmitkRadiomicsTransformationView.h"
 
 // QT includes (GUI)
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qmessagebox.h>
 
 // Berry includes (selection service)
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // MITK includes (GUI)
 #include <QmitkDataStorageComboBox.h>
 #include "QmitkDataNodeSelectionProvider.h"
 #include "mitkDataNodeObject.h"
 
 // MITK includes (general
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkProperties.h>
 #include <mitkTransformationOperation.h>
 #include <mitkLabelSetImage.h>
 
 // Specific GUI Includes
 #include "QmitkGIFConfigurationPanel.h"
 
 QmitkRadiomicsTransformation::QmitkRadiomicsTransformation()
 : QmitkAbstractView(),
   m_Controls(nullptr)
 {
 }
 
 QmitkRadiomicsTransformation::~QmitkRadiomicsTransformation()
 {
   //berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   //if(s)
   //  s->RemoveSelectionListener(m_SelectionListener);
 }
 
 void QmitkRadiomicsTransformation::CreateQtPartControl(QWidget *parent)
 {
   if (m_Controls == nullptr)
   {
     m_Controls = new Ui::QmitkRadiomicsTransformationViewControls;
     m_Controls->setupUi(parent);
 
     QLabel * label1 = new QLabel("Image: ");
     QmitkDataStorageComboBox * cb_inputimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::Image>::New());
     m_Controls->m_InputImageGroup->layout()->addWidget(label1);
     m_Controls->m_InputImageGroup->layout()->addWidget(cb_inputimage);
 
     this->CreateConnections();
   }
 }
 
 void QmitkRadiomicsTransformation::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->buttonExecuteMultiresolution), SIGNAL(clicked() ), this, SLOT(executeButtonMultiResolutionPressed() ) );
     connect((QObject*)(m_Controls->m_WaveletExecuteButton), SIGNAL(clicked()), this, SLOT(executeButtonWaveletPressed()));
     connect((QObject*)(m_Controls->m_ExecuteLOG), SIGNAL(clicked()), this, SLOT(executeButtonLoGPressed()));
     connect((QObject*)(m_Controls->buttonResampleImage), SIGNAL(clicked()), this, SLOT(executeButtonResamplingPressed()));
 
   }
 }
 
 void QmitkRadiomicsTransformation::executeButtonMultiResolutionPressed()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
-  mitk::BaseData* baseDataRawImage = NULL;
+  mitk::BaseData* baseDataRawImage = nullptr;
 
   mitk::Image::Pointer raw_image;
   std::string nodeName;
   if ((cb_image->GetSelectedNode().IsNotNull() ) )
   {
     baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
     nodeName = cb_image->GetSelectedNode()->GetName();
   }
-  if ((baseDataRawImage != NULL))
+  if ((baseDataRawImage != nullptr))
   {
     raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the images that shlould be used.");
     msgBox.exec();
     return;
   }
   if (raw_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
     return;
   }
 
   unsigned int numberOfLevels = m_Controls->m_NumberOfLevels->value();
   bool resultAsDouble = m_Controls->m_resultAsDouble->isChecked();
 
   auto results = mitk::TransformationOperation::MultiResolution(raw_image, numberOfLevels, resultAsDouble);
   unsigned int level = 1;
   for (auto image : results)
   {
     mitk::DataNode::Pointer result = mitk::DataNode::New();
     result->SetProperty("name", mitk::StringProperty::New(nodeName+"::MultiRes::Level-"+us::Any(numberOfLevels-level).ToString()));
     result->SetData(image);
     GetDataStorage()->Add(result, cb_image->GetSelectedNode());
     ++level;
   }
 }
 
 void QmitkRadiomicsTransformation::executeButtonWaveletPressed()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
-  mitk::BaseData* baseDataRawImage = NULL;
+  mitk::BaseData* baseDataRawImage = nullptr;
 
   mitk::Image::Pointer raw_image;
   std::string nodeName;
   if ((cb_image->GetSelectedNode().IsNotNull()))
   {
     baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
     nodeName = cb_image->GetSelectedNode()->GetName();
   }
-  if ((baseDataRawImage != NULL))
+  if ((baseDataRawImage != nullptr))
   {
     raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the images that shlould be used.");
     msgBox.exec();
     return;
   }
   if (raw_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
     return;
   }
 
   unsigned int numberOfLevels = m_Controls->m_WaveletNumberOfLevels->value();
   unsigned int numberOfBands = m_Controls->m_WaveletNumberOfBands->value();
   mitk::BorderCondition condition = mitk::BorderCondition::Constant;
   mitk::WaveletType waveletType = mitk::WaveletType::Held;
 
   std::string waveletStr = m_Controls->m_WaveletWavelet->currentText().toStdString();
   if (waveletStr == "Shannon")
   {
     waveletType = mitk::WaveletType::Shannon;
   }
   if (waveletStr == "Simoncelli")
   {
     waveletType = mitk::WaveletType::Simoncelli;
   }
   if (waveletStr == "Vow")
   {
     waveletType = mitk::WaveletType::Vow;
   }
   if (waveletStr == "Held")
   {
     waveletType = mitk::WaveletType::Held;
   }
 
   std::string conditionStr = m_Controls->m_WaveletBorderCondition->currentText().toStdString();
   if (conditionStr == "Constant")
   {
     condition = mitk::BorderCondition::Constant;
   }
   if (conditionStr == "Periodic")
   {
     condition = mitk::BorderCondition::Periodic;
   }
   if (conditionStr == "Zero Flux Neumann")
   {
     condition = mitk::BorderCondition::ZeroFluxNeumann;
   }
 
   auto results = mitk::TransformationOperation::WaveletForward(raw_image, numberOfLevels, numberOfBands, condition, waveletType);
   unsigned int level = 0;
   for (auto image : results)
   {
     mitk::DataNode::Pointer result = mitk::DataNode::New();
     result->SetProperty("name", mitk::StringProperty::New(nodeName + "::Wavelet::"+waveletStr+"-"+conditionStr+"::Level-" + us::Any(level).ToString()));
     result->SetData(image);
     GetDataStorage()->Add(result, cb_image->GetSelectedNode());
     ++level;
   }
 
 }
 
 
 void QmitkRadiomicsTransformation::executeButtonLoGPressed()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
-  mitk::BaseData* baseDataRawImage = NULL;
+  mitk::BaseData* baseDataRawImage = nullptr;
 
   mitk::Image::Pointer raw_image;
   std::string nodeName;
   if ((cb_image->GetSelectedNode().IsNotNull()))
   {
     baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
     nodeName = cb_image->GetSelectedNode()->GetName();
   }
-  if ((baseDataRawImage != NULL))
+  if ((baseDataRawImage != nullptr))
   {
     raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the images that shlould be used.");
     msgBox.exec();
     return;
   }
   if (raw_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
     return;
   }
 
   double sigma = m_Controls->m_LoGSigma->value();
   bool resultAsDouble = m_Controls->m_LogResultAsDouble->isChecked();
 
   auto results = mitk::TransformationOperation::LaplacianOfGaussian(raw_image, sigma, resultAsDouble);
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty("name", mitk::StringProperty::New(nodeName + "::LoG::Sigma-" + us::Any(sigma).ToString()));
   result->SetData(results);
   GetDataStorage()->Add(result, cb_image->GetSelectedNode());
 }
 
 void QmitkRadiomicsTransformation::executeButtonResamplingPressed()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
-  mitk::BaseData* baseDataRawImage = NULL;
+  mitk::BaseData* baseDataRawImage = nullptr;
 
   mitk::Image::Pointer raw_image;
   std::string nodeName;
   if ((cb_image->GetSelectedNode().IsNotNull()))
   {
     baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
     nodeName = cb_image->GetSelectedNode()->GetName();
   }
-  if ((baseDataRawImage != NULL))
+  if ((baseDataRawImage != nullptr))
   {
     raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the images that shlould be used.");
     msgBox.exec();
     return;
   }
   if (raw_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
     return;
   }
 
   mitk::ImageMappingInterpolator::Type interpolatorType;
   switch (m_Controls->comboInterpolationMode->currentIndex())
   {
   case 0:
     interpolatorType = mitk::ImageMappingInterpolator::Linear;
     break;
 
   case 1:
     interpolatorType = mitk::ImageMappingInterpolator::BSpline_3;
     break;
 
   case 2:
     interpolatorType = mitk::ImageMappingInterpolator::NearestNeighbor;
     break;
 
   case 3:
     interpolatorType = mitk::ImageMappingInterpolator::WSinc_Hamming;
     break;
 
   case 4:
     interpolatorType = mitk::ImageMappingInterpolator::WSinc_Welch;
     break;
 
   default:
     interpolatorType = mitk::ImageMappingInterpolator::Linear;
   }
 
   mitk::GridInterpolationPositionType gridPosition;
   switch (m_Controls->comboAxisAlignment->currentIndex())
   {
   case 0:
     gridPosition = mitk::GridInterpolationPositionType::OriginAligned;
     break;
 
   case 1:
     gridPosition = mitk::GridInterpolationPositionType::CenterAligned;
     break;
 
   case 2:
     gridPosition = mitk::GridInterpolationPositionType::SameSize;
     break;
 
   default:
     gridPosition = mitk::GridInterpolationPositionType::OriginAligned;
   }
 
   bool resultAsDouble = m_Controls->checkResamplingOutputAsDouble->isChecked();
   bool roundResult = m_Controls->checkResamplingRoundOutput->isChecked();
 
   mitk::Vector3D spacing;
   spacing.Fill(-1);
   if (m_Controls->checkResampleX->isChecked()) {
     spacing[0] = m_Controls->doubleSpinDimensionX->value();
   }
   if (m_Controls->checkResampleY->isChecked()) {
     spacing[1] = m_Controls->doubleSpinDimensionY->value();
   }
   if (m_Controls->checkResampleZ->isChecked()) {
     spacing[2] = m_Controls->doubleSpinDimensionZ->value();
   }
 
 
   mitk::Image::Pointer results;
   if (m_Controls->checkResampleAsMask->isChecked()) {
     results = mitk::TransformationOperation::ResampleMask(raw_image, spacing, interpolatorType, gridPosition);
     mitk::LabelSetImage::Pointer oldLabelImage = dynamic_cast<mitk::LabelSetImage *> (raw_image.GetPointer());
     if (oldLabelImage.IsNotNull())
     {
       mitk::LabelSetImage::Pointer labelResult = mitk::LabelSetImage::New();
       labelResult->InitializeByLabeledImage(results);
       labelResult->AddLabelSetToLayer(labelResult->GetActiveLayer(), oldLabelImage->GetLabelSet());
       results = dynamic_cast<mitk::Image*>(labelResult.GetPointer());
     }
   }
   else {
     results = mitk::TransformationOperation::ResampleImage(raw_image, spacing, interpolatorType, gridPosition, resultAsDouble, roundResult);
   }
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty("name", mitk::StringProperty::New(nodeName + "::Resampled" ));
   result->SetData(results);
   GetDataStorage()->Add(result, cb_image->GetSelectedNode());
 }
 
 void QmitkRadiomicsTransformation::SetFocus()
 {
 }
 
 //datamanager selection changed
 void QmitkRadiomicsTransformation::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
 {
   //any nodes there?
   if (!nodes.empty())
   {
 
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
index 7e07df0254..6a93f5280f 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
@@ -1,1149 +1,1149 @@
 /*===================================================================
 
 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 <QObject>
 
 #include "mitkProperties.h"
 #include "mitkSegTool2D.h"
 #include "mitkStatusBar.h"
 
 #include "QmitkNewSegmentationDialog.h"
 #include <QmitkSegmentationOrganNamesHandling.cpp>
 
 #include <QMessageBox>
 
 #include <berryIWorkbenchPage.h>
 
 #include "QmitkSegmentationView.h"
 
 #include <mitkSurfaceToImageFilter.h>
 
 #include "mitkVtkResliceInterpolationProperty.h"
 
 #include "mitkApplicationCursor.h"
 #include "mitkSegmentationObjectFactory.h"
 #include "mitkPluginActivator.h"
 #include "mitkCameraController.h"
 #include "mitkLabelSetImage.h"
 
 #include <QmitkRenderWindow.h>
 
 #include "usModuleResource.h"
 #include "usModuleResourceStream.h"
 
 //micro service to get the ToolManager instance
 #include "mitkToolManagerProvider.h"
 
 #include <mitkWorkbenchUtil.h>
 #include <regex>
 
 const std::string QmitkSegmentationView::VIEW_ID = "org.mitk.views.segmentation";
 
 QmitkSegmentationView::QmitkSegmentationView()
   : m_Parent(nullptr)
   , m_Controls(nullptr)
   , m_RenderWindowPart(nullptr)
   , m_MouseCursorSet(false)
   , m_DataSelectionChanged(false)
   , m_AutoSelectionEnabled(false)
 {
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
   mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
   mitk::NodePredicateDataType::Pointer isOdf = mitk::NodePredicateDataType::New("OdfImage");
   auto isSegment = mitk::NodePredicateDataType::New("Segment");
 
   mitk::NodePredicateOr::Pointer validImages = mitk::NodePredicateOr::New();
   validImages->AddPredicate(mitk::NodePredicateAnd::New(isImage, mitk::NodePredicateNot::New(isSegment)));
   validImages->AddPredicate(isDwi);
   validImages->AddPredicate(isDti);
   validImages->AddPredicate(isOdf);
 
   m_IsNotAHelperObject = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)));
 
   m_IsOfTypeImagePredicate = mitk::NodePredicateAnd::New(validImages, m_IsNotAHelperObject);
 
   mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   mitk::NodePredicateNot::Pointer isNotBinaryPredicate = mitk::NodePredicateNot::New(isBinaryPredicate);
 
   mitk::NodePredicateAnd::Pointer isABinaryImagePredicate = mitk::NodePredicateAnd::New(m_IsOfTypeImagePredicate, isBinaryPredicate);
   mitk::NodePredicateAnd::Pointer isNotABinaryImagePredicate = mitk::NodePredicateAnd::New(m_IsOfTypeImagePredicate, isNotBinaryPredicate);
 
   m_IsASegmentationImagePredicate = mitk::NodePredicateOr::New(isABinaryImagePredicate, mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
   m_IsAPatientImagePredicate = mitk::NodePredicateAnd::New(isNotABinaryImagePredicate, mitk::NodePredicateNot::New(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New()));
 }
 
 QmitkSegmentationView::~QmitkSegmentationView()
 {
   if (m_Controls)
   {
     SetToolSelectionBoxesEnabled(false);
     // deactivate all tools
     mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
 
     // removing all observers
     for (NodeTagMapType::iterator dataIter = m_WorkingDataObserverTags.begin(); dataIter != m_WorkingDataObserverTags.end(); ++dataIter)
     {
       (*dataIter).first->GetProperty("visible")->RemoveObserver((*dataIter).second);
     }
     m_WorkingDataObserverTags.clear();
 
     for (NodeTagMapType::iterator dataIter = m_BinaryPropertyObserverTags.begin(); dataIter != m_BinaryPropertyObserverTags.end(); ++dataIter)
     {
       (*dataIter).first->GetProperty("binary")->RemoveObserver((*dataIter).second);
     }
     m_BinaryPropertyObserverTags.clear();
 
     mitk::RenderingManager::GetInstance()->RemoveObserver(m_RenderingManagerObserverTag);
 
     ctkPluginContext* context = mitk::PluginActivator::getContext();
     ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
     mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
     service->RemoveAllPlanePositions();
     context->ungetService(ppmRef);
-    SetToolManagerSelection(0, 0);
+    SetToolManagerSelection(nullptr, nullptr);
   }
 
   delete m_Controls;
 }
 
 void QmitkSegmentationView::NewNodesGenerated()
 {
   MITK_WARN << "Use of deprecated function: NewNodesGenerated!! This function is empty and will be removed in the next time!";
 }
 
 void QmitkSegmentationView::NewNodeObjectsGenerated(mitk::ToolManager::DataVectorType* nodes)
 {
    if (!nodes) return;
 
    mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
    if (!toolManager) return;
    for (mitk::ToolManager::DataVectorType::iterator iter = nodes->begin(); iter != nodes->end(); ++iter)
    {
       this->FireNodeSelected( *iter );
       // only last iteration meaningful, multiple generated objects are not taken into account here
    }
 }
 
 void QmitkSegmentationView::Visible()
 {
 }
 
 void QmitkSegmentationView::Hidden()
 {
 }
 
 void QmitkSegmentationView::Activated()
 {
 }
 
 void QmitkSegmentationView::Deactivated()
 {
 }
 
 void QmitkSegmentationView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_RenderWindowPart != renderWindowPart)
   {
     m_RenderWindowPart = renderWindowPart;
   }
 
   if (m_Parent)
   {
     m_Parent->setEnabled(true);
   }
 
   // tell the interpolation about tool manager, data storage and render window part
   if (m_Controls)
   {
     mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
     m_Controls->m_SlicesInterpolator->SetDataStorage(this->GetDataStorage());
     QList<mitk::SliceNavigationController*> controllers;
     controllers.push_back(renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
     controllers.push_back(renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
     controllers.push_back(renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
     m_Controls->m_SlicesInterpolator->Initialize(toolManager, controllers);
   }
 }
 
 void QmitkSegmentationView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_RenderWindowPart = nullptr;
   if (m_Parent)
   {
     m_Parent->setEnabled(false);
   }
 }
 
 void QmitkSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
    if (m_Controls != nullptr)
    {
       bool slimView = prefs->GetBool("slim view", false);
       m_Controls->m_ManualToolSelectionBox2D->SetShowNames(!slimView);
       m_Controls->m_ManualToolSelectionBox3D->SetShowNames(!slimView);
       m_Controls->btnNewSegmentation->setToolButtonStyle(slimView
         ? Qt::ToolButtonIconOnly
         : Qt::ToolButtonTextOnly);
    }
 
    m_AutoSelectionEnabled = prefs->GetBool("auto selection", false);
    this->ForceDisplayPreferencesUponAllImages();
 }
 
 void QmitkSegmentationView::CreateNewSegmentation()
 {
    mitk::DataNode::Pointer node = mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetReferenceData(0);
    if (node.IsNotNull())
    {
      mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
      if (image.IsNotNull())
      {
        if (image->GetDimension() > 1)
        {
          // ask about the name and organ type of the new segmentation
          QmitkNewSegmentationDialog* dialog = new QmitkNewSegmentationDialog(m_Parent); // needs a QWidget as parent, "this" is not QWidget
          QStringList organColors = mitk::OrganNamesHandling::GetDefaultOrganColorString();;
 
          dialog->SetSuggestionList(organColors);
 
          int dialogReturnValue = dialog->exec();
          if (dialogReturnValue == QDialog::Rejected)
          {
            // user clicked cancel or pressed Esc or something similar
            return;
          }
 
          // ask the user about an organ type and name, add this information to the image's (!) propertylist
          // create a new image of the same dimensions and smallest possible pixel type
          mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
          mitk::Tool* firstTool = toolManager->GetToolById(0);
          if (firstTool)
          {
            try
            {
              std::string newNodeName = dialog->GetSegmentationName().toStdString();
              if (newNodeName.empty())
              {
                newNodeName = "no_name";
              }
 
              mitk::DataNode::Pointer emptySegmentation = firstTool->CreateEmptySegmentationNode(image, newNodeName, dialog->GetColor());
              // initialize showVolume to false to prevent recalculating the volume while working on the segmentation
              emptySegmentation->SetProperty("showVolume", mitk::BoolProperty::New(false));
              if (!emptySegmentation)
              {
                return; // could be aborted by user
              }
 
              mitk::OrganNamesHandling::UpdateOrganList(organColors, dialog->GetSegmentationName(), dialog->GetColor());
 
              // escape ';' here (replace by '\;'), see longer comment above
              QString stringForStorage = organColors.replaceInStrings(";", "\\;").join(";");
              MITK_DEBUG << "Will store: " << stringForStorage;
              this->GetPreferences()->Put("Organ-Color-List", stringForStorage);
              this->GetPreferences()->Flush();
 
              if (mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetWorkingData(0))
              {
                mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetWorkingData(0)->SetSelected(false);
              }
              emptySegmentation->SetSelected(true);
              this->GetDataStorage()->Add(emptySegmentation, node); // add as a child, because the segmentation "derives" from the original
 
              this->FireNodeSelected(emptySegmentation);
              this->OnSelectionChanged(emptySegmentation);
 
              m_Controls->segImageSelector->SetSelectedNode(emptySegmentation);
              mitk::RenderingManager::GetInstance()->InitializeViews(emptySegmentation->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
            }
            catch (const std::bad_alloc&)
            {
              QMessageBox::warning(nullptr, tr("Create new segmentation"), tr("Could not allocate memory for new segmentation"));
            }
          }
        }
        else
        {
          QMessageBox::information(nullptr, tr("Segmentation"), tr("Segmentation is currently not supported for 2D images"));
        }
      }
    }
    else
    {
      MITK_ERROR << "'Create new segmentation' button should never be clickable unless a patient image is selected...";
    }
 }
 
 void QmitkSegmentationView::OnVisiblePropertyChanged()
 {
    mitk::DataNode* selectedNode = m_Controls->segImageSelector->GetSelectedNode();
    if ( !selectedNode )
    {
      this->SetToolSelectionBoxesEnabled(false);
      return;
    }
 
    mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
    bool selectedNodeIsVisible = renderWindowPart && selectedNode->IsVisible(renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer());
 
    if (!selectedNodeIsVisible)
    {
       this->SetToolSelectionBoxesEnabled(false);
       this->UpdateWarningLabel(tr("The selected segmentation is currently not visible!"));
    }
    else
    {
       this->SetToolSelectionBoxesEnabled(true);
       this->UpdateWarningLabel("");
    }
 }
 
 void QmitkSegmentationView::OnBinaryPropertyChanged()
 {
    mitk::DataStorage::SetOfObjects::ConstPointer patImages = m_Controls->patImageSelector->GetNodes();
 
    for (mitk::DataStorage::SetOfObjects::ConstIterator it = patImages->Begin(); it != patImages->End(); ++it)
    {
       const mitk::DataNode* node = it->Value();
       if(m_IsASegmentationImagePredicate->CheckNode(node))
       {
          m_Controls->patImageSelector->RemoveNode(node);
          m_Controls->segImageSelector->AddNode(node);
          this->SetToolManagerSelection(nullptr,nullptr);
          return;
       }
    }
 
    mitk::DataStorage::SetOfObjects::ConstPointer segImages = m_Controls->segImageSelector->GetNodes();
 
    for (mitk::DataStorage::SetOfObjects::ConstIterator it = segImages->Begin(); it != segImages->End(); ++it)
    {
       const mitk::DataNode* node = it->Value();
       if(!m_IsASegmentationImagePredicate->CheckNode(node))
       {
          m_Controls->segImageSelector->RemoveNode(node);
          m_Controls->patImageSelector->AddNode(node);
          if (mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetWorkingData(0) == node)
          {
            mitk::ToolManagerProvider::GetInstance()->GetToolManager()->SetWorkingData(nullptr);
          }
          return;
       }
    }
 }
 
 void QmitkSegmentationView::NodeAdded(const mitk::DataNode *node)
 {
   if (!m_IsOfTypeImagePredicate->CheckNode(node))
   {
     return;
   }
 
   itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
   command->SetCallbackFunction(this, &QmitkSegmentationView::OnVisiblePropertyChanged);
   m_WorkingDataObserverTags.insert(std::pair<mitk::DataNode*, unsigned long>(const_cast<mitk::DataNode*>(node), node->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command)));
 
   itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
   command2->SetCallbackFunction(this, &QmitkSegmentationView::OnBinaryPropertyChanged);
   m_BinaryPropertyObserverTags.insert(std::pair<mitk::DataNode*, unsigned long>(const_cast<mitk::DataNode*>(node), node->GetProperty("binary")->AddObserver(itk::ModifiedEvent(), command2)));
 
   ApplyDisplayOptions(const_cast<mitk::DataNode*>(node));
 }
 
 void QmitkSegmentationView::NodeRemoved(const mitk::DataNode* node)
 {
   if (m_IsASegmentationImagePredicate->CheckNode(node))
   {
     //First of all remove all possible contour markers of the segmentation
     mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = this->GetDataStorage()->GetDerivations(node, mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true)));
 
     ctkPluginContext* context = mitk::PluginActivator::getContext();
     ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
     mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
 
     for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
     {
       std::string nodeName = node->GetName();
       unsigned int t = nodeName.find_last_of(" ");
       unsigned int id = atof(nodeName.substr(t + 1).c_str()) - 1;
 
       service->RemovePlanePosition(id);
 
       this->GetDataStorage()->Remove(it->Value());
     }
 
     context->ungetService(ppmRef);
     service = nullptr;
 
     if ((mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetWorkingData(0) == node) && m_Controls->patImageSelector->GetSelectedNode().IsNotNull())
     {
       this->SetToolManagerSelection(mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetReferenceData(0), nullptr);
       this->UpdateWarningLabel(tr("Select or create a segmentation"));
     }
 
     mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
     mitk::SurfaceInterpolationController::GetInstance()->RemoveInterpolationSession(image);
   }
   mitk::DataNode* tempNode = const_cast<mitk::DataNode*>(node);
   //Since the binary property could be changed during runtime by the user
   if (m_IsOfTypeImagePredicate->CheckNode(node))
   {
     node->GetProperty("visible")->RemoveObserver(m_WorkingDataObserverTags[tempNode]);
     m_WorkingDataObserverTags.erase(tempNode);
     node->GetProperty("binary")->RemoveObserver(m_BinaryPropertyObserverTags[tempNode]);
     m_BinaryPropertyObserverTags.erase(tempNode);
   }
 
   if (mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetReferenceData(0) == node)
   {
     //as we don't know which node was actually removed e.g. our reference node, disable 'New Segmentation' button.
     //consider the case that there is no more image in the datastorage
     this->SetToolManagerSelection(nullptr, nullptr);
     this->SetToolSelectionBoxesEnabled(false);
   }
 }
 
 void QmitkSegmentationView::OnPatientComboBoxSelectionChanged( const mitk::DataNode* node )
 {
    //mitk::DataNode* selectedNode = const_cast<mitk::DataNode*>(node);
    if( node != nullptr )
    {
       this->UpdateWarningLabel("");
       mitk::DataNode* segNode = m_Controls->segImageSelector->GetSelectedNode();
       if (segNode)
       {
         mitk::DataStorage::SetOfObjects::ConstPointer possibleParents = this->GetDataStorage()->GetSources(segNode, m_IsAPatientImagePredicate);
          bool isSourceNode(false);
 
          for (mitk::DataStorage::SetOfObjects::ConstIterator it = possibleParents->Begin(); it != possibleParents->End(); it++)
          {
             if (it.Value() == node)
                isSourceNode = true;
          }
 
          if ( !isSourceNode && (!this->CheckForSameGeometry(segNode, node) || possibleParents->Size() > 0 ))
          {
             this->SetToolManagerSelection(node, nullptr);
             this->SetToolSelectionBoxesEnabled( false );
             this->UpdateWarningLabel(tr("The selected patient image does not match with the selected segmentation!"));
          }
          else if ((!isSourceNode && this->CheckForSameGeometry(segNode, node)) || isSourceNode )
          {
             this->SetToolManagerSelection(node, segNode);
             //Doing this we can assure that the segmenation is always visible if the segmentation and the patient image are
             //loaded separately
             int layer(10);
             node->GetIntProperty("layer", layer);
             layer++;
             segNode->SetProperty("layer", mitk::IntProperty::New(layer));
             //this->UpdateWarningLabel("");
             RenderingManagerReinitialized();
          }
       }
       else
       {
          this->SetToolManagerSelection(node, nullptr);
          this->SetToolSelectionBoxesEnabled( false );
          this->UpdateWarningLabel(tr("Select or create a segmentation"));
       }
    }
    else
    {
       this->UpdateWarningLabel(tr("Please select an image!"));
       this->SetToolSelectionBoxesEnabled( false );
    }
 }
 
 void QmitkSegmentationView::OnSegmentationComboBoxSelectionChanged(const mitk::DataNode *node)
 {
    if (node == nullptr)
    {
       this->UpdateWarningLabel(tr("Select or create a segmentation"));
       this->SetToolSelectionBoxesEnabled( false );
       return;
    }
 
    mitk::DataNode* refNode = m_Controls->patImageSelector->GetSelectedNode();
 
    RenderingManagerReinitialized();
    if ( m_Controls->lblSegmentationWarnings->isVisible()) // "RenderingManagerReinitialized()" caused a warning. we do not need to go any further
       return;
 
    if (m_AutoSelectionEnabled)
    {
       this->OnSelectionChanged(const_cast<mitk::DataNode*>(node));
    }
    else
    {
      mitk::DataStorage::SetOfObjects::ConstPointer possibleParents = this->GetDataStorage()->GetSources(node, m_IsAPatientImagePredicate);
 
       if ( possibleParents->Size() == 1 )
       {
          mitk::DataNode* parentNode = possibleParents->ElementAt(0);
 
          if (parentNode != refNode)
          {
             this->UpdateWarningLabel(tr("The selected segmentation does not match with the selected patient image!"));
             this->SetToolSelectionBoxesEnabled( false );
             this->SetToolManagerSelection(nullptr, node);
          }
          else
          {
             this->UpdateWarningLabel("");
             this->SetToolManagerSelection(refNode, node);
          }
       }
       else if (refNode && this->CheckForSameGeometry(node, refNode))
       {
          this->UpdateWarningLabel("");
          this->SetToolManagerSelection(refNode, node);
       }
       else if (!refNode || !this->CheckForSameGeometry(node, refNode))
       {
          this->UpdateWarningLabel(tr("Please select the matching patient image!"));
       }
    }
 
    mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
    if (!renderWindowPart || !node->IsVisible(renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer()))
    {
      this->UpdateWarningLabel(tr("The selected segmentation is currently not visible!"));
      this->SetToolSelectionBoxesEnabled( false );
    }
 }
 
 void QmitkSegmentationView::OnShowMarkerNodes (bool state)
 {
    mitk::SegTool2D::Pointer manualSegmentationTool;
 
    unsigned int numberOfExistingTools = mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetTools().size();
 
    for(unsigned int i = 0; i < numberOfExistingTools; i++)
    {
       manualSegmentationTool = dynamic_cast<mitk::SegTool2D*>(mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetToolById(i));
 
       if (manualSegmentationTool)
       {
          if(state == true)
          {
             manualSegmentationTool->SetShowMarkerNodes( true );
          }
          else
          {
             manualSegmentationTool->SetShowMarkerNodes( false );
          }
       }
    }
 }
 
 void QmitkSegmentationView::OnSelectionChanged(mitk::DataNode* node)
 {
    berry::IWorkbenchPart::Pointer nullPart;
    QList<mitk::DataNode::Pointer> nodes;
    nodes.push_back(node);
    this->OnSelectionChanged(nullPart, nodes);
 }
 
 void QmitkSegmentationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   if (nodes.size() != 0)
   {
     std::string markerName = "Position";
     unsigned int numberOfNodes = nodes.size();
     std::string nodeName = nodes.at(0)->GetName();
     if ((numberOfNodes == 1) && (nodeName.find(markerName) == 0))
     {
       OnContourMarkerSelected(nodes.at(0));
       return;
     }
   }
 
   if (m_AutoSelectionEnabled)
   {
     if (nodes.size() == 0 && m_Controls->patImageSelector->GetSelectedNode().IsNull())
     {
       SetToolManagerSelection(nullptr, nullptr);
     }
     else if (nodes.size() == 1)
     {
       mitk::DataNode::Pointer selectedNode = nodes.at(0);
       if (selectedNode.IsNull())
       {
         return;
       }
 
       mitk::Image::Pointer selectedImage = dynamic_cast<mitk::Image*>(selectedNode->GetData());
       if (selectedImage.IsNull())
       {
         SetToolManagerSelection(nullptr, nullptr);
         return;
       }
 
       if (m_IsASegmentationImagePredicate->CheckNode(selectedNode))
       {
         // set all nodes to invisible
         mitk::DataStorage::SetOfObjects::ConstPointer allImages = GetDataStorage()->GetSubset(m_IsNotAHelperObject);
         for (mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin(); iter != allImages->end(); ++iter)
         {
           (*iter)->SetVisibility(false);
         }
 
         // if a segmentation is selected find a possible patient image (a parent node)
         mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(selectedNode, m_IsAPatientImagePredicate);
         mitk::DataNode::Pointer sourceNode;
         if (sources->Size() != 0)
         {
           // found one or more sources - use the first one
           sourceNode = sources->ElementAt(0);
           sourceNode->SetVisibility(true);
           selectedNode->SetVisibility(true);
           SetToolManagerSelection(sourceNode, selectedNode);
 
           // set all child nodes of the segmentation to visible
           mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(selectedNode, m_IsNotAHelperObject, false);
           for (mitk::DataStorage::SetOfObjects::const_iterator iter = derivations->begin(); iter != derivations->end(); ++iter)
           {
             (*iter)->SetVisibility(true);
           }
         }
         else
         {
           // did not find a source / patient image, check all images and compare geometry
           mitk::DataStorage::SetOfObjects::ConstPointer possiblePatientImages = GetDataStorage()->GetSubset(m_IsAPatientImagePredicate);
           for (mitk::DataStorage::SetOfObjects::ConstIterator iter = possiblePatientImages->Begin(); iter != possiblePatientImages->End(); ++iter)
           {
             sourceNode = iter->Value();
             if (CheckForSameGeometry(selectedNode, iter->Value()))
             {
               sourceNode->SetVisibility(true);
               selectedNode->SetVisibility(true);
               SetToolManagerSelection(sourceNode, selectedNode);
 
               // set all child nodes of the segmentation to visible
               mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(selectedNode, m_IsNotAHelperObject, false);
               for (mitk::DataStorage::SetOfObjects::const_iterator iter = derivations->begin(); iter != derivations->end(); ++iter)
               {
                 (*iter)->SetVisibility(true);
               }
 
               // doing this we can assure that the segmentation is always visible if the segmentation and the patient image are at the
               // same level in the data manager
               int layer(10);
               sourceNode->GetIntProperty("layer", layer);
               layer++;
               selectedNode->SetProperty("layer", mitk::IntProperty::New(layer));
               return;
             }
           }
           // did not find a source / patient image with the same geometry
           SetToolManagerSelection(nullptr, selectedNode);
         }
         mitk::RenderingManager::GetInstance()->InitializeViews(selectedNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
       }
       else
       {
         if (mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetReferenceData(0) != selectedNode)
         {
           SetToolManagerSelection(selectedNode, nullptr);
           // may be a bug in the selection services. A node which is deselected will be passed as selected node to the OnSelectionChanged function
           mitk::IRenderWindowPart* renderWindowPart = GetRenderWindowPart();
           if (renderWindowPart && !selectedNode->IsVisible(renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer()))
           {
             selectedNode->SetVisibility(true);
           }
           UpdateWarningLabel(tr("The selected patient image does not match with the selected segmentation!"));
           SetToolSelectionBoxesEnabled(false);
         }
       }
     }
 
     if (m_Controls->lblSegmentationWarnings->isVisible()) // "RenderingManagerReinitialized()" caused a warning. we do not need to go any further
     {
       return;
     }
     RenderingManagerReinitialized();
   }
 }
 
 void QmitkSegmentationView::OnContourMarkerSelected(const mitk::DataNode *node)
 {
-   QmitkRenderWindow* selectedRenderWindow = 0;
+   QmitkRenderWindow* selectedRenderWindow = nullptr;
    QmitkRenderWindow* axialRenderWindow = GetRenderWindowPart(mitk::WorkbenchUtil::OPEN)->GetQmitkRenderWindow("axial");
    QmitkRenderWindow* sagittalRenderWindow = GetRenderWindowPart(mitk::WorkbenchUtil::OPEN)->GetQmitkRenderWindow("sagittal");
    QmitkRenderWindow* coronalRenderWindow = GetRenderWindowPart(mitk::WorkbenchUtil::OPEN)->GetQmitkRenderWindow("coronal");
    QmitkRenderWindow* _3DRenderWindow = GetRenderWindowPart(mitk::WorkbenchUtil::OPEN)->GetQmitkRenderWindow("3d");
    bool PlanarFigureInitializedWindow = false;
 
    // find initialized renderwindow
    if (node->GetBoolProperty("PlanarFigureInitializedWindow",
       PlanarFigureInitializedWindow, axialRenderWindow->GetRenderer()))
    {
       selectedRenderWindow = axialRenderWindow;
    }
    if (!selectedRenderWindow && node->GetBoolProperty(
       "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
       sagittalRenderWindow->GetRenderer()))
    {
       selectedRenderWindow = sagittalRenderWindow;
    }
    if (!selectedRenderWindow && node->GetBoolProperty(
       "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
       coronalRenderWindow->GetRenderer()))
    {
       selectedRenderWindow = coronalRenderWindow;
    }
    if (!selectedRenderWindow && node->GetBoolProperty(
       "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
       _3DRenderWindow->GetRenderer()))
    {
       selectedRenderWindow = _3DRenderWindow;
    }
 
    // make node visible
    if (selectedRenderWindow)
    {
       std::string nodeName = node->GetName();
       unsigned int t = nodeName.find_last_of(" ");
       unsigned int id = atof(nodeName.substr(t+1).c_str())-1;
 
       {
          ctkPluginContext* context = mitk::PluginActivator::getContext();
          ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
          mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
          selectedRenderWindow->GetSliceNavigationController()->ExecuteOperation(service->GetPlanePosition(id));
          context->ungetService(ppmRef);
       }
 
       selectedRenderWindow->GetRenderer()->GetCameraController()->Fit();
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
    }
 }
 
 void QmitkSegmentationView::OnTabWidgetChanged(int id)
 {
    //always disable tools on tab changed
    mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
 
    //2D Tab ID = 0
    //3D Tab ID = 1
    if (id == 0)
    {
       //Hide 3D selection box, show 2D selection box
       m_Controls->m_ManualToolSelectionBox3D->hide();
       m_Controls->m_ManualToolSelectionBox2D->show();
       //Deactivate possible active tool
 
       //TODO Remove possible visible interpolations -> Maybe changes in SlicesInterpolator
    }
    else
    {
       //Hide 3D selection box, show 2D selection box
       m_Controls->m_ManualToolSelectionBox2D->hide();
       m_Controls->m_ManualToolSelectionBox3D->show();
       //Deactivate possible active tool
    }
 }
 
 void QmitkSegmentationView::InitToolManagerSelection(const mitk::DataNode* referenceData, const mitk::DataNode* workingData)
 {
   // initial tool manager selection, called from 'CreateQtPartControl'
   mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
   toolManager->SetReferenceData(const_cast<mitk::DataNode*>(referenceData));
   toolManager->SetWorkingData(const_cast<mitk::DataNode*>(workingData));
 
   // check original image
   m_Controls->btnNewSegmentation->setEnabled(referenceData != nullptr);
   if (referenceData)
   {
     UpdateWarningLabel("");
   }
 }
 
 void QmitkSegmentationView::SetToolManagerSelection(const mitk::DataNode* referenceData, const mitk::DataNode* workingData)
 {
   // called as a result of new BlueBerry selections
   //   tells the ToolManager for manual segmentation about new selections
   //   updates GUI information about what the user should select
   mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
   toolManager->SetReferenceData(const_cast<mitk::DataNode*>(referenceData));
   toolManager->SetWorkingData(const_cast<mitk::DataNode*>(workingData));
 
   // check original image
   m_Controls->btnNewSegmentation->setEnabled(referenceData != nullptr);
   if (referenceData)
   {
     UpdateWarningLabel("");
     disconnect(m_Controls->patImageSelector, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnPatientComboBoxSelectionChanged(const mitk::DataNode*)));
     m_Controls->patImageSelector->setCurrentIndex(m_Controls->patImageSelector->Find(referenceData));
     connect(m_Controls->patImageSelector, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnPatientComboBoxSelectionChanged(const mitk::DataNode*)));
 
     // check segmentation
     if (workingData)
     {
       //FireNodeSelected(const_cast<mitk::DataNode*>(workingData));
 
       disconnect(m_Controls->segImageSelector, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnSegmentationComboBoxSelectionChanged(const mitk::DataNode*)));
       m_Controls->segImageSelector->setCurrentIndex(m_Controls->segImageSelector->Find(workingData));
       connect(m_Controls->segImageSelector, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnSegmentationComboBoxSelectionChanged(const mitk::DataNode*)));
     }
   }
 }
 
 void QmitkSegmentationView::ForceDisplayPreferencesUponAllImages()
 {
    if (!m_Parent)
    {
      return;
    }
 
    // check all images and segmentations in DataStorage:
    // (items in brackets are implicitly done by previous steps)
    // 1.
    //   if  a reference image is selected,
    //     show the reference image
    //     and hide all other images (orignal and segmentation),
    //     (and hide all segmentations of the other original images)
    //     and show all the reference's segmentations
    //   if no reference image is selected, do do nothing
    //
    // 2.
    //   if  a segmentation is selected,
    //     show it
    //     (and hide all all its siblings (childs of the same parent, incl, nullptr parent))
    //   if no segmentation is selected, do nothing
 
    if (!m_Controls)
    {
      return; // might happen on initialization (preferences loaded)
    }
 
    mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
    mitk::DataNode::Pointer referenceData = toolManager->GetReferenceData(0);
    mitk::DataNode::Pointer workingData =   toolManager->GetWorkingData(0);
 
    // 1.
    if (referenceData.IsNotNull())
    {
       // iterate all images
      mitk::DataStorage::SetOfObjects::ConstPointer allImages = this->GetDataStorage()->GetSubset(m_IsASegmentationImagePredicate);
 
       for ( mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin(); iter != allImages->end(); ++iter)
 
       {
          mitk::DataNode* node = *iter;
          // apply display preferences
          ApplyDisplayOptions(node);
 
          // set visibility
          node->SetVisibility(node == referenceData);
       }
    }
 
    // 2.
    if (workingData.IsNotNull())
       workingData->SetVisibility(true);
 
    mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSegmentationView::ApplyDisplayOptions(mitk::DataNode* node)
 {
   if (!node)
   {
     return;
   }
 
   mitk::BoolProperty::Pointer drawOutline = mitk::BoolProperty::New(GetPreferences()->GetBool("draw outline", true));
   mitk::BoolProperty::Pointer volumeRendering = mitk::BoolProperty::New(GetPreferences()->GetBool("volume rendering", false));
   mitk::LabelSetImage* labelSetImage = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
   if (nullptr != labelSetImage)
   {
     // node is actually a multi label segmentation,
     // but its outline property can be set in the 'single label' segmentation preference page as well
     node->SetProperty("labelset.contour.active", drawOutline);
     //node->SetProperty("opacity", mitk::FloatProperty::New(drawOutline->GetValue() ? 1.0f : 0.3f));
     node->SetProperty("volumerendering", volumeRendering);
     // force render window update to show outline
     node->GetData()->Modified();
   }
   else
   {
     // node is a 'single label' segmentation
     bool isBinary = false;
     node->GetBoolProperty("binary", isBinary);
     if (isBinary)
     {
       node->SetProperty("outline binary", drawOutline);
       node->SetProperty("outline width", mitk::FloatProperty::New(2.0));
       //node->SetProperty("opacity", mitk::FloatProperty::New(drawOutline->GetValue() ? 1.0f : 0.3f));
       node->SetProperty("volumerendering", volumeRendering);
       // force render window update to show outline
       node->GetData()->Modified();
     }
   }
 }
 
 void QmitkSegmentationView::RenderingManagerReinitialized()
 {
    if (!this->GetRenderWindowPart())
    {
      return;
    }
 
    /*
    * Here we check whether the geometry of the selected segmentation image if aligned with the worldgeometry
    * At the moment it is not supported to use a geometry different from the selected image for reslicing.
    * For further information see Bug 16063
    */
    mitk::DataNode* workingNode = m_Controls->segImageSelector->GetSelectedNode();
    const mitk::BaseGeometry* worldGeo = this->GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetSliceNavigationController()->GetCurrentGeometry3D();
 
    if (workingNode && worldGeo)
    {
 
       const mitk::BaseGeometry* workingNodeGeo = workingNode->GetData()->GetGeometry();
       const mitk::BaseGeometry* worldGeo = this->GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetSliceNavigationController()->GetCurrentGeometry3D();
 
       if (mitk::Equal(*workingNodeGeo->GetBoundingBox(), *worldGeo->GetBoundingBox(), mitk::eps, true))
       {
          this->SetToolManagerSelection(m_Controls->patImageSelector->GetSelectedNode(), workingNode);
          this->SetToolSelectionBoxesEnabled(true);
          this->UpdateWarningLabel("");
       }
       else
       {
          this->SetToolManagerSelection(m_Controls->patImageSelector->GetSelectedNode(), nullptr);
          this->SetToolSelectionBoxesEnabled(false);
          this->UpdateWarningLabel(tr("Please perform a reinit on the segmentation image!"));
       }
    }
 }
 
 bool QmitkSegmentationView::CheckForSameGeometry(const mitk::DataNode *node1, const mitk::DataNode *node2) const
 {
    bool isSameGeometry(true);
 
    mitk::Image* image1 = dynamic_cast<mitk::Image*>(node1->GetData());
    mitk::Image* image2 = dynamic_cast<mitk::Image*>(node2->GetData());
    if (image1 && image2)
    {
       mitk::BaseGeometry* geo1 = image1->GetGeometry();
       mitk::BaseGeometry* geo2 = image2->GetGeometry();
 
       isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetOrigin(), geo2->GetOrigin());
       isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(0), geo2->GetExtent(0));
       isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(1), geo2->GetExtent(1));
       isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(2), geo2->GetExtent(2));
       isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetSpacing(), geo2->GetSpacing());
       isSameGeometry = isSameGeometry && mitk::MatrixEqualElementWise(geo1->GetIndexToWorldTransform()->GetMatrix(), geo2->GetIndexToWorldTransform()->GetMatrix());
 
       return isSameGeometry;
    }
    else
    {
       return false;
    }
 }
 
 void QmitkSegmentationView::UpdateWarningLabel(QString text)
 {
    if (text.size() == 0)
       m_Controls->lblSegmentationWarnings->hide();
    else
       m_Controls->lblSegmentationWarnings->show();
    m_Controls->lblSegmentationWarnings->setText("<font color=\"red\">" + text + "</font>");
 }
 
 void QmitkSegmentationView::CreateQtPartControl(QWidget* parent)
 {
    // setup the basic GUI of this view
    m_Parent = parent;
 
    m_Controls = new Ui::QmitkSegmentationControls;
    m_Controls->setupUi(parent);
 
    m_Controls->patImageSelector->SetDataStorage(GetDataStorage());
    m_Controls->patImageSelector->SetPredicate(m_IsAPatientImagePredicate);
 
    UpdateWarningLabel(tr("Please select an image"));
 
    if (m_Controls->patImageSelector->GetSelectedNode().IsNotNull())
    {
      UpdateWarningLabel(tr("Select or create a new segmentation"));
    }
 
    m_Controls->segImageSelector->SetDataStorage(GetDataStorage());
    m_Controls->segImageSelector->SetPredicate(m_IsASegmentationImagePredicate);
    if (m_Controls->segImageSelector->GetSelectedNode().IsNotNull())
    {
      UpdateWarningLabel("");
    }
 
    mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
    assert(toolManager);
 
    toolManager->SetDataStorage(*(GetDataStorage()));
    toolManager->InitializeTools();
 
    QString segTools2D = tr("Add Subtract Correction Paint Wipe 'Region Growing' Fill Erase 'Live Wire' '2D Fast Marching'");
    QString segTools3D = tr("Threshold 'UL Threshold' Otsu 'Fast Marching 3D' 'Region Growing 3D' Watershed Picking");
 
    std::regex extSegTool2DRegEx("SegTool2D$");
    std::regex extSegTool3DRegEx("SegTool3D$");
 
    auto tools = toolManager->GetTools();
 
    for (const auto &tool : tools)
    {
      if (std::regex_search(tool->GetNameOfClass(), extSegTool2DRegEx))
      {
        segTools2D.append(QString(" '%1'").arg(tool->GetName()));
      }
      else if (std::regex_search(tool->GetNameOfClass(), extSegTool3DRegEx))
      {
        segTools3D.append(QString(" '%1'").arg(tool->GetName()));
      }
    }
 
    // all part of open source MITK
    m_Controls->m_ManualToolSelectionBox2D->setEnabled(true);
    m_Controls->m_ManualToolSelectionBox2D->SetGenerateAccelerators(true);
    m_Controls->m_ManualToolSelectionBox2D->SetToolGUIArea( m_Controls->m_ManualToolGUIContainer2D );
 
    m_Controls->m_ManualToolSelectionBox2D->SetDisplayedToolGroups(segTools2D.toStdString());
    m_Controls->m_ManualToolSelectionBox2D->SetLayoutColumns(3);
    m_Controls->m_ManualToolSelectionBox2D->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible );
    connect( m_Controls->m_ManualToolSelectionBox2D, SIGNAL(ToolSelected(int)), this, SLOT(OnManualTool2DSelected(int)) );
 
    //setup 3D Tools
    m_Controls->m_ManualToolSelectionBox3D->setEnabled(true);
    m_Controls->m_ManualToolSelectionBox3D->SetGenerateAccelerators(true);
    m_Controls->m_ManualToolSelectionBox3D->SetToolGUIArea( m_Controls->m_ManualToolGUIContainer3D );
    //specify tools to be added to 3D Tool area
    m_Controls->m_ManualToolSelectionBox3D->SetDisplayedToolGroups(segTools3D.toStdString());
    m_Controls->m_ManualToolSelectionBox3D->SetLayoutColumns(3);
    m_Controls->m_ManualToolSelectionBox3D->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible );
 
    //Hide 3D selection box, show 2D selection box
    m_Controls->m_ManualToolSelectionBox3D->hide();
    m_Controls->m_ManualToolSelectionBox2D->show();
 
    // update the list of segmentations
    toolManager->NewNodesGenerated += mitk::MessageDelegate<QmitkSegmentationView>(this, &QmitkSegmentationView::NewNodesGenerated);
    // update the list of segmentations
    toolManager->NewNodeObjectsGenerated += mitk::MessageDelegate1<QmitkSegmentationView, mitk::ToolManager::DataVectorType*>(this, &QmitkSegmentationView::NewNodeObjectsGenerated);
 
    // create signal/slot connections
    connect(m_Controls->patImageSelector, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnPatientComboBoxSelectionChanged(const mitk::DataNode*)));
    connect(m_Controls->segImageSelector, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnSegmentationComboBoxSelectionChanged(const mitk::DataNode*)));
    connect(m_Controls->btnNewSegmentation, SIGNAL(clicked()), this, SLOT(CreateNewSegmentation()));
    connect(m_Controls->tabWidgetSegmentationTools, SIGNAL(currentChanged(int)), this, SLOT(OnTabWidgetChanged(int)));
    connect(m_Controls->m_SlicesInterpolator, SIGNAL(SignalShowMarkerNodes(bool)), this, SLOT(OnShowMarkerNodes(bool)));
 
    mitk::DataStorage::SetOfObjects::ConstPointer patientImages = GetDataStorage()->GetSubset(m_IsAPatientImagePredicate);
    if (!patientImages->empty())
    {
      OnSelectionChanged(*patientImages->begin());
    }
 
    // set callback function for already existing nodes (images & segmentations)
    mitk::DataStorage::SetOfObjects::ConstPointer allImages = GetDataStorage()->GetSubset(m_IsOfTypeImagePredicate);
    for (mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin(); iter != allImages->end(); ++iter)
    {
      mitk::DataNode* node = *iter;
      itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
      command->SetCallbackFunction(this, &QmitkSegmentationView::OnVisiblePropertyChanged);
      m_WorkingDataObserverTags.insert(std::pair<mitk::DataNode*, unsigned long>(node, node->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command)));
 
      itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
      command2->SetCallbackFunction(this, &QmitkSegmentationView::OnBinaryPropertyChanged);
      m_BinaryPropertyObserverTags.insert(std::pair<mitk::DataNode*, unsigned long>(node, node->GetProperty("binary")->AddObserver(itk::ModifiedEvent(), command2)));
    }
 
    itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
    command->SetCallbackFunction(this, &QmitkSegmentationView::RenderingManagerReinitialized);
    m_RenderingManagerObserverTag = mitk::RenderingManager::GetInstance()->AddObserver(mitk::RenderingManagerViewsInitializedEvent(), command);
 
    InitToolManagerSelection(m_Controls->patImageSelector->GetSelectedNode(), m_Controls->segImageSelector->GetSelectedNode());
 
    m_RenderWindowPart = GetRenderWindowPart();
    if (m_RenderWindowPart)
    {
      RenderWindowPartActivated(m_RenderWindowPart);
    }
 }
 
 void QmitkSegmentationView::SetFocus()
 {
   m_Controls->btnNewSegmentation->setFocus();
 }
 
 void QmitkSegmentationView::OnManualTool2DSelected(int id)
 {
    if (id >= 0)
    {
       std::string text = "Active Tool: \"";
       mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
       text += toolManager->GetToolById(id)->GetName();
       text += "\"";
       mitk::StatusBar::GetInstance()->DisplayText(text.c_str());
 
       us::ModuleResource resource = toolManager->GetToolById(id)->GetCursorIconResource();
       this->SetMouseCursor(resource, 0, 0);
    }
    else
    {
       this->ResetMouseCursor();
       mitk::StatusBar::GetInstance()->DisplayText("");
    }
 }
 
 void QmitkSegmentationView::ResetMouseCursor()
 {
    if ( m_MouseCursorSet )
    {
       mitk::ApplicationCursor::GetInstance()->PopCursor();
       m_MouseCursorSet = false;
    }
 }
 
 void QmitkSegmentationView::SetMouseCursor( const us::ModuleResource& resource, int hotspotX, int hotspotY )
 {
    // Remove previously set mouse cursor
    if (m_MouseCursorSet)
       this->ResetMouseCursor();
 
    if (resource)
    {
      us::ModuleResourceStream cursor(resource, std::ios::binary);
      mitk::ApplicationCursor::GetInstance()->PushCursor(cursor, hotspotX, hotspotY);
      m_MouseCursorSet = true;
    }
 }
 
 void QmitkSegmentationView::SetToolSelectionBoxesEnabled(bool status)
 {
   if (status)
   {
     m_Controls->m_ManualToolSelectionBox2D->RecreateButtons();
     m_Controls->m_ManualToolSelectionBox3D->RecreateButtons();
   }
 
   m_Controls->m_ManualToolSelectionBox2D->setEnabled(status);
   m_Controls->m_ManualToolSelectionBox3D->setEnabled(status);
   m_Controls->m_SlicesInterpolator->setEnabled(status);
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkThresholdAction.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkThresholdAction.cpp
index abcda7fea7..ecf13691cc 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkThresholdAction.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkThresholdAction.cpp
@@ -1,117 +1,117 @@
 /*===================================================================
 
 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 "QmitkThresholdAction.h"
 
 // MITK
 #include <mitkBinaryThresholdTool.h>
 #include <mitkRenderingManager.h>
 #include <QmitkBinaryThresholdToolGUI.h>
 
 // Qt
 #include <QDialog>
 #include <QVBoxLayout>
 #include <QApplication>
 #include <QDialogButtonBox>
 
 using namespace berry;
 using namespace mitk;
 using namespace std;
 
 QmitkThresholdAction::QmitkThresholdAction()
 {
 }
 
 QmitkThresholdAction::~QmitkThresholdAction()
 {
 }
 
 void QmitkThresholdAction::Run(const QList<DataNode::Pointer> &selectedNodes)
 {
   m_ThresholdingToolManager = ToolManager::New(m_DataStorage);
 
   m_ThresholdingToolManager->RegisterClient();
 
   Tool *binaryThresholdTool = m_ThresholdingToolManager->GetToolById(m_ThresholdingToolManager->GetToolIdByToolType<mitk::BinaryThresholdTool>());
   if (binaryThresholdTool != nullptr)
   {
     QmitkBinaryThresholdToolGUI *gui = dynamic_cast<QmitkBinaryThresholdToolGUI *>(binaryThresholdTool->GetGUI("Qmitk", "GUI").GetPointer());
     if (gui != nullptr)
     {
       QDialog thresholdingDialog(QApplication::activeWindow(), Qt::Window | Qt::WindowStaysOnTopHint);
 
       thresholdingDialog.setWindowFlags(thresholdingDialog.windowFlags() & ~Qt::WindowMinimizeButtonHint);
 
       QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Cancel);
       connect(buttonBox, SIGNAL(rejected()), &thresholdingDialog, SLOT(reject()));
       connect(gui, SIGNAL(thresholdAccepted()), &thresholdingDialog, SLOT(reject()));
 
       QVBoxLayout *layout = new QVBoxLayout;
       layout->setContentsMargins(3, 3, 3, 3);
 
       gui->SetTool(binaryThresholdTool);
       gui->setParent(&thresholdingDialog);
 
       layout->addWidget(gui);
       layout->addWidget(buttonBox);
 
       thresholdingDialog.setLayout(layout);
       thresholdingDialog.setMinimumWidth(350);
 
       m_SelectedNode = selectedNodes[0];
       m_ThresholdingToolManager->SetReferenceData(selectedNodes[0]);
       m_ThresholdingToolManager->ActivateTool(m_ThresholdingToolManager->GetToolIdByToolType<mitk::BinaryThresholdTool>());
 
       m_ThresholdingToolManager->ActiveToolChanged += mitk::MessageDelegate<QmitkThresholdAction>(this, &QmitkThresholdAction::OnThresholdingToolManagerToolModified);
       thresholdingDialog.exec();
       m_ThresholdingToolManager->ActiveToolChanged -= mitk::MessageDelegate<QmitkThresholdAction>(this, &QmitkThresholdAction::OnThresholdingToolManagerToolModified);
 
       m_ThresholdingToolManager->SetReferenceData(nullptr);
       m_ThresholdingToolManager->ActivateTool(-1);
-      m_SelectedNode = 0;
+      m_SelectedNode = nullptr;
     }
   }
 
   m_ThresholdingToolManager->UnregisterClient();
 }
 
 void QmitkThresholdAction::OnThresholdingToolManagerToolModified()
 {
   if (m_ThresholdingToolManager.IsNotNull())
   {
     if (m_ThresholdingToolManager->GetActiveToolID() < 0)
     {
       m_ThresholdingToolManager->SetReferenceData(m_SelectedNode);
       m_ThresholdingToolManager->ActivateTool(m_ThresholdingToolManager->GetToolIdByToolType<mitk::BinaryThresholdTool>());
     }
   }
 }
 
 void QmitkThresholdAction::SetDataStorage(DataStorage *dataStorage)
 {
   m_DataStorage = dataStorage;
 }
 
 void QmitkThresholdAction::SetSmoothed(bool)
 {
 }
 
 void QmitkThresholdAction::SetDecimated(bool)
 {
 }
 
 void QmitkThresholdAction::SetFunctionality(QtViewPart* /*view*/)
 {
 }
diff --git a/Plugins/org.mitk.gui.qt.toftutorial/src/internal/QmitkToFTutorialView.cpp b/Plugins/org.mitk.gui.qt.toftutorial/src/internal/QmitkToFTutorialView.cpp
index eaa7fb20eb..2abda3de6c 100644
--- a/Plugins/org.mitk.gui.qt.toftutorial/src/internal/QmitkToFTutorialView.cpp
+++ b/Plugins/org.mitk.gui.qt.toftutorial/src/internal/QmitkToFTutorialView.cpp
@@ -1,187 +1,187 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkToFTutorialView.h"
 
 // Qt
 #include <QMessageBox>
 
 // mitk includes
 #include <mitkCameraIntrinsics.h> // class holding the intrinsic parameters of the according camera
 #include <mitkSurface.h>
 
 // MITK-ToF related includes
 #include <mitkToFCameraMITKPlayerDevice.h>
 #include <mitkToFConfig.h> // configuration file holding e.g. plugin paths or path to test file directory
 #include <mitkToFDistanceImageToSurfaceFilter.h> // filter from module ToFProcessing that calculates a surface from the given range image
 #include <mitkToFImageGrabber.h> // allows access to images provided by the ToF camera
 
 const std::string QmitkToFTutorialView::VIEW_ID = "org.mitk.views.toftutorial";
 
 QmitkToFTutorialView::QmitkToFTutorialView()
 : QmitkAbstractView()
-, m_Controls( 0 )
+, m_Controls( nullptr )
 {
 }
 
 QmitkToFTutorialView::~QmitkToFTutorialView()
 {
 }
 
 void QmitkToFTutorialView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkToFTutorialViewControls;
     m_Controls->setupUi( parent );
 
     connect( m_Controls->step1Button, SIGNAL(clicked()), this, SLOT(OnStep1()) );
     connect( m_Controls->step2Button, SIGNAL(clicked()), this, SLOT(OnStep2()) );
   }
 }
 
 void QmitkToFTutorialView::SetFocus()
 {
   m_Controls->step1Button->setFocus();
 }
 
 void QmitkToFTutorialView::OnStep1()
 {
   // clean up data storage
   RemoveAllNodesFromDataStorage();
   // Create an instance of ToFImageGrabber that holds a ToFCameraMITKPlayerDevice for playing ToF data
   mitk::ToFImageGrabber::Pointer tofImageGrabber = mitk::ToFImageGrabber::New();
   tofImageGrabber->SetCameraDevice(mitk::ToFCameraMITKPlayerDevice::New());
   // set paths to test data
   std::string distanceFileName = MITK_TOF_DATA_DIR;
   distanceFileName.append("/PMDCamCube2_MF0_IT0_20Images_DistanceImage.pic");
   std::string amplitudeFileName = MITK_TOF_DATA_DIR;
   amplitudeFileName.append("/PMDCamCube2_MF0_IT0_20Images_AmplitudeImage.pic");
   std::string intensityFileName = MITK_TOF_DATA_DIR;
   intensityFileName.append("/PMDCamCube2_MF0_IT0_20Images_IntensityImage.pic");
   // set file name property in image grabber. This will be propagated to the corresponding device and controller class
   tofImageGrabber->SetProperty("DistanceImageFileName",mitk::StringProperty::New(distanceFileName));
   tofImageGrabber->SetProperty("AmplitudeImageFileName",mitk::StringProperty::New(amplitudeFileName));
   tofImageGrabber->SetProperty("IntensityImageFileName",mitk::StringProperty::New(intensityFileName));
   // connect to device
   if (tofImageGrabber->ConnectCamera())
   {
     //// start camera (internally starts thread that continuously grabs images from the camera)
     tofImageGrabber->StartCamera();
     // update image grabber which itself represents the source of a MITK filter pipeline
     tofImageGrabber->Update();
     // grab distance image
     mitk::Image::Pointer distanceImage = tofImageGrabber->GetOutput();
     // grab amplitude image
     mitk::Image::Pointer amplitudeImage = tofImageGrabber->GetOutput(1);
     // grab intensity image
     mitk::Image::Pointer intensityImage = tofImageGrabber->GetOutput(2);
     //add distance image to data storage
     mitk::DataNode::Pointer distanceNode = mitk::DataNode::New();
     distanceNode->SetName("Distance Image");
     distanceNode->SetData(distanceImage);
     this->GetDataStorage()->Add(distanceNode);
     //add amplitude image to data storage
     mitk::DataNode::Pointer amplitudeNode = mitk::DataNode::New();
     amplitudeNode->SetName("Amplitude Image");
     amplitudeNode->SetData(amplitudeImage);
     this->GetDataStorage()->Add(amplitudeNode);
     //add intensity image to data storage
     mitk::DataNode::Pointer intensityNode = mitk::DataNode::New();
     intensityNode->SetName("Intensity Image");
     intensityNode->SetData(intensityImage);
     this->GetDataStorage()->Add(intensityNode);
     // stop camera (terminate internally used thread)
     tofImageGrabber->StopCamera();
     //// disconnect from camera
     tofImageGrabber->DisconnectCamera();
     // adjust views to new data in DataStorage
     mitk::RenderingManager::GetInstance()->InitializeViews(distanceImage->GetGeometry());
   }
   else
   {
     MITK_ERROR<<"Connection to ToF camera could not be established";
   }
 }
 
 void QmitkToFTutorialView::OnStep2()
 {
   // Check if distance image is available
   mitk::DataNode::Pointer distanceNode = this->GetDataStorage()->GetNamedNode("Distance Image");
   if (distanceNode.IsNotNull())
   {
     // get distance image from node and check if node contains image
     mitk::Image::Pointer distanceImage = dynamic_cast<mitk::Image*>(distanceNode->GetData());
     if (distanceImage.IsNotNull())
     {
       // create object of CameraIntrinsics that holds intrinsic parameters of the ToF camera
       mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
       // set focal length in pixel
       cameraIntrinsics->SetFocalLength(295.8,296.1);
       // set principal point in pixel
       cameraIntrinsics->SetPrincipalPoint(113.2,97.1);
       // set up filter for surface calculation
       mitk::ToFDistanceImageToSurfaceFilter::Pointer surfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
       // apply intrinsic parameters to filter
       surfaceFilter->SetCameraIntrinsics(cameraIntrinsics);
       // set distance between pixels on chip in mm (in this example squared pixel)
       mitk::ToFProcessingCommon::ToFPoint2D interPixelDistance;
       interPixelDistance[0] = 0.045;
       interPixelDistance[1] = 0.045;
       surfaceFilter->SetInterPixelDistance(interPixelDistance);
       // set distance image as input
       surfaceFilter->SetInput(distanceImage);
       // update the filter
       surfaceFilter->Update();
       // get surface from filter
       mitk::Surface::Pointer surface = surfaceFilter->GetOutput();
       // add surface to data storage
       mitk::DataNode::Pointer surfaceNode = mitk::DataNode::New();
       surfaceNode->SetName("ToF surface");
       surfaceNode->SetData(surface);
       this->GetDataStorage()->Add(surfaceNode);
       // adjust views to new data in DataStorage
       mitk::RenderingManager::GetInstance()->InitializeViews(surface->GetGeometry());
       mitk::RenderingManager::GetInstance()->InitializeViews(surface->GetGeometry());
     }
     else
     {
       QMessageBox::warning(nullptr,"ToF Tutorial","Node 'Distance Image' contains no image");
     }
   }
   else
   {
     QMessageBox::warning(nullptr,"ToF Tutorial","Perform Step 1 first to acquire a distance image");
   }
 }
 
 void QmitkToFTutorialView::RemoveAllNodesFromDataStorage()
 {
   mitk::DataStorage::SetOfObjects::ConstPointer allNodes = this->GetDataStorage()->GetAll();
   this->GetDataStorage()->Remove(allNodes);
 }
 
 
 
 
 
diff --git a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
index 02c98dcb5e..89fc65a7cd 100644
--- a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
+++ b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
@@ -1,530 +1,530 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 // Blueberry
 #include <mitkIRenderingManager.h>
 #include <mitkIRenderWindowPart.h>
 #include <mitkILinkedRenderWindowPart.h>
 
 // Qmitk
 #include "QmitkToFUtilView.h"
 
 // Qt
 #include <QMessageBox>
 #include <QString>
 #include <qmessagebox.h>
 #include <qfiledialog.h>
 #include <qcombobox.h>
 
 // MITK
 #include <mitkBaseRenderer.h>
 #include <mitkToFDistanceImageToPointSetFilter.h>
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 #include <mitkToFDeviceFactoryManager.h>
 #include <mitkToFCameraDevice.h>
 #include <mitkCameraIntrinsicsProperty.h>
 #include <mitkSmartPointerProperty.h>
 #include <mitkRenderingModeProperty.h>
 #include <mitkVtkScalarModeProperty.h>
 
 // VTK
 #include <vtkCamera.h>
 #include <vtkPointData.h>
 #include <vtkPolyData.h>
 
 // ITK
 #include <itkCommand.h>
 #include <itksys/SystemTools.hxx>
 
 const std::string QmitkToFUtilView::VIEW_ID = "org.mitk.views.tofutil";
 
 //Constructor
 QmitkToFUtilView::QmitkToFUtilView()
   : QmitkAbstractView()
   , m_Controls(nullptr)
   , m_Framerateoutput(false)
   , m_MitkDistanceImage(nullptr), m_MitkAmplitudeImage(nullptr), m_MitkIntensityImage(nullptr), m_Surface(nullptr)
   , m_DistanceImageNode(nullptr), m_AmplitudeImageNode(nullptr), m_IntensityImageNode(nullptr), m_RGBImageNode(nullptr), m_SurfaceNode(nullptr)
   , m_ToFImageRecorder(nullptr), m_ToFImageGrabber(nullptr), m_ToFDistanceImageToSurfaceFilter(nullptr), m_ToFCompositeFilter(nullptr)
   , m_2DDisplayCount(0)
   , m_RealTimeClock(nullptr)
   , m_StepsForFramerate(100)
   , m_2DTimeBefore(0.0)
   , m_2DTimeAfter(0.0)
   , m_CameraIntrinsics(nullptr)
 {
   this->m_Frametimer = new QTimer(this);
 
   this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
   this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
   this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
 }
 
 //Destructor, specifically calling OnToFCameraStopped() and OnToFCammeraDiconnected()
 QmitkToFUtilView::~QmitkToFUtilView()
 {
   OnToFCameraStopped();
   OnToFCameraDisconnected();
 }
 
 //Createing the PartControl Signal-Slot principal
 void QmitkToFUtilView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkToFUtilViewControls;
     m_Controls->setupUi( parent );
 
     //Looking for Input and Defining reaction
     connect(m_Frametimer, SIGNAL(timeout()), this, SLOT(OnUpdateCamera()));
 
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(KinectAcquisitionModeChanged()), this, SLOT(OnKinectAcquisitionModeChanged()) ); // Todo in Widget2
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraConnected()), this, SLOT(OnToFCameraConnected()) );
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraDisconnected()), this, SLOT(OnToFCameraDisconnected()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStarted()), this, SLOT(OnToFCameraStarted()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStopped()), this, SLOT(OnToFCameraStopped()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStarted()), this, SLOT(OnToFCameraStopped()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStopped()), this, SLOT(OnToFCameraStarted()) );
 }
 }
 
 //SetFocus-Method -> actually seting Focus to the Recorder
 void QmitkToFUtilView::SetFocus()
 {
   m_Controls->m_ToFRecorderWidget->setFocus();
 }
 
 //Activated-Method->Generating RenderWindow
 void QmitkToFUtilView::Activated()
 {
   //get the current RenderWindowPart or open a new one if there is none
   if (this->GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN))
   {
     mitk::ILinkedRenderWindowPart* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
-    if (linkedRenderWindowPart == 0)
+    if (linkedRenderWindowPart == nullptr)
     {
       MITK_ERROR << "No linked render window part avaiable!!!";
     }
     else
     {
       linkedRenderWindowPart->EnableSlicingPlanes(false);
     }
     GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOn();
     GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOn();
     GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOn();
 
     mitk::RenderingManager::GetInstance()->InitializeViews();
 
     this->UseToFVisibilitySettings(true);
 
     if (this->m_ToFCompositeFilter)
     {
       m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
     }
     if (this->GetDataStorage())
     {
       m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
     }
 
     if (this->m_ToFImageGrabber.IsNull())
     {
       m_Controls->m_ToFRecorderWidget->setEnabled(false);
       m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
       m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
       m_Controls->m_ToFMeasurementWidget->setEnabled(false);
       m_Controls->m_ToFSurfaceGenerationWidget->setEnabled(false);
     }
   }
 }
 
 //ZomnnieView-Method -> Resetting GUI to default. Why not just QmitkToFUtilView()?!
 void QmitkToFUtilView::ActivatedZombieView(berry::IWorkbenchPartReference::Pointer /*zombieView*/)
 {
   ResetGUIToDefault();
 }
 
 void QmitkToFUtilView::Deactivated()
 {
 }
 
 void QmitkToFUtilView::Visible()
 {
 }
 
 //Reset of the ToFUtilView
 void QmitkToFUtilView::Hidden()
 {
   ResetGUIToDefault();
 }
 
 void QmitkToFUtilView::OnToFCameraConnected()
 {
   MITK_DEBUG <<"OnToFCameraConnected";
   this->m_2DDisplayCount = 0;
 
   this->m_ToFImageGrabber = m_Controls->m_ToFConnectionWidget->GetToFImageGrabber();
 
   // initialize surface generation
   this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
 
   // initialize ToFImageRecorder and ToFRecorderWidget
   this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
   this->m_ToFImageRecorder->SetCameraDevice(this->m_ToFImageGrabber->GetCameraDevice());
   m_Controls->m_ToFRecorderWidget->SetParameter(this->m_ToFImageGrabber, this->m_ToFImageRecorder);
   m_Controls->m_ToFRecorderWidget->setEnabled(true);
   m_Controls->m_ToFRecorderWidget->ResetGUIToInitial();
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
 
   // initialize ToFCompositeFilterWidget
   this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
   if (this->m_ToFCompositeFilter)
   {
     m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
   }
   if (this->GetDataStorage())
   {
     m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
   }
 
   if ( this->GetRenderWindowPart() )
     // initialize measurement widget
     m_Controls->m_ToFMeasurementWidget->InitializeWidget(this->GetRenderWindowPart()->GetQmitkRenderWindows(),this->GetDataStorage(), this->m_ToFDistanceImageToSurfaceFilter->GetCameraIntrinsics());
   else
     MITK_WARN << "No render window part available!!! MeasurementWidget will not work.";
 
   this->m_RealTimeClock = mitk::RealTimeClock::New();
   this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
 
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkToFUtilView::ResetGUIToDefault()
 {
   if(this->GetRenderWindowPart())
   {
     mitk::ILinkedRenderWindowPart* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
-    if(linkedRenderWindowPart == 0)
+    if(linkedRenderWindowPart == nullptr)
     {
       MITK_ERROR << "No linked render window part avaiable!!!";
     }
     else
     {
       linkedRenderWindowPart->EnableSlicingPlanes(true);
     }
     GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOff();
     GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
     GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOff();
     GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
     GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOff();
 
     this->UseToFVisibilitySettings(false);
 
     //global reinit
     mitk::RenderingManager::GetInstance()->InitializeViews();
     this->RequestRenderWindowUpdate();
   }
 }
 
 void QmitkToFUtilView::OnToFCameraDisconnected()
 {
   this->GetDataStorage()->Remove(m_DistanceImageNode);
   if(m_RGBImageNode)
     this->GetDataStorage()->Remove(m_RGBImageNode);
   if(m_AmplitudeImageNode)
     this->GetDataStorage()->Remove(m_AmplitudeImageNode);
   if(m_IntensityImageNode)
     this->GetDataStorage()->Remove(m_IntensityImageNode);
   if(m_SurfaceNode)
     this->GetDataStorage()->Remove(m_SurfaceNode);
 
   m_Controls->m_ToFRecorderWidget->OnStop();
   m_Controls->m_ToFRecorderWidget->setEnabled(false);
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
   m_Controls->m_ToFMeasurementWidget->setEnabled(false);
   m_Controls->m_ToFSurfaceGenerationWidget->setEnabled(false);
   //clean up measurement widget
   m_Controls->m_ToFMeasurementWidget->CleanUpWidget();
 }
 
 void QmitkToFUtilView::OnKinectAcquisitionModeChanged()
 {
   if (m_ToFCompositeFilter.IsNotNull()&&m_ToFImageGrabber.IsNotNull())
   {
     if (m_SelectedCamera.contains("Kinect"))
     {
       if (m_ToFImageGrabber->GetBoolProperty("RGB"))
       {
         this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
         this->m_ToFDistanceImageToSurfaceFilter->SetInput(3,this->m_ToFImageGrabber->GetOutput(3));
       }
       else if (m_ToFImageGrabber->GetBoolProperty("IR"))
       {
         this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
         this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
       }
     }
     this->UseToFVisibilitySettings(true);
   }
 }
 
 void QmitkToFUtilView::OnToFCameraStarted()
 {
   if (m_ToFImageGrabber.IsNotNull())
   {
     // initialize camera intrinsics
     if (this->m_ToFImageGrabber->GetProperty("CameraIntrinsics"))
     {
       m_CameraIntrinsics = dynamic_cast<mitk::CameraIntrinsicsProperty*>(this->m_ToFImageGrabber->GetProperty("CameraIntrinsics"))->GetValue();
       MITK_INFO << m_CameraIntrinsics->ToString();
     }
     else
     {
       m_CameraIntrinsics = nullptr;
       MITK_ERROR << "No camera intrinsics were found!";
     }
 
     // set camera intrinsics
     if ( m_CameraIntrinsics.IsNotNull() )
     {
       this->m_ToFDistanceImageToSurfaceFilter->SetCameraIntrinsics(m_CameraIntrinsics);
     }
 
     // initial update of image grabber
     this->m_ToFImageGrabber->Update();
 
     bool hasRGBImage = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasRGBImage",hasRGBImage);
 
     bool hasIntensityImage = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasIntensityImage",hasIntensityImage);
 
     bool hasAmplitudeImage = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasAmplitudeImage",hasAmplitudeImage);
 
     this->m_ToFCompositeFilter->SetInput(0,this->m_ToFImageGrabber->GetOutput(0));
     if(hasAmplitudeImage)
       this->m_ToFCompositeFilter->SetInput(1,this->m_ToFImageGrabber->GetOutput(1));
     if(hasIntensityImage)
       this->m_ToFCompositeFilter->SetInput(2,this->m_ToFImageGrabber->GetOutput(2));
 
     // initial update of composite filter
     this->m_ToFCompositeFilter->Update();
     this->m_MitkDistanceImage = m_ToFCompositeFilter->GetOutput();
     this->m_DistanceImageNode = ReplaceNodeData("Distance image",m_MitkDistanceImage);
 
     std::string rgbFileName;
     m_ToFImageGrabber->GetCameraDevice()->GetStringProperty("RGBImageFileName",rgbFileName);
 
     if(hasRGBImage || (rgbFileName!=""))
     {
       if(m_ToFImageGrabber->GetBoolProperty("IR"))
       {
         this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
       }
       else
       {
         this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
       }
     }
     else
     {
       this->m_RGBImageNode = nullptr;
     }
 
     if(hasAmplitudeImage)
     {
       this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
       this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
     }
 
     if(hasIntensityImage)
     {
       this->m_MitkIntensityImage = m_ToFCompositeFilter->GetOutput(2);
       this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
     }
 
     this->m_ToFDistanceImageToSurfaceFilter->SetInput(0,m_MitkDistanceImage);
     this->m_ToFDistanceImageToSurfaceFilter->SetInput(1,m_MitkAmplitudeImage);
     this->m_ToFDistanceImageToSurfaceFilter->SetInput(2,m_MitkIntensityImage);
 
     this->UseToFVisibilitySettings(true);
 
     this->m_SurfaceNode = ReplaceNodeData("Surface", nullptr);
     m_Controls->m_ToFCompositeFilterWidget->UpdateFilterParameter();
     // initialize visualization widget
     m_Controls->m_ToFVisualisationSettingsWidget->Initialize(this->m_DistanceImageNode,
                                                              this->m_AmplitudeImageNode,
                                                              this->m_IntensityImageNode,
                                                              this->m_SurfaceNode);
     m_Controls->m_ToFSurfaceGenerationWidget->Initialize(m_ToFDistanceImageToSurfaceFilter,
                                                          m_ToFImageGrabber,
                                                          m_CameraIntrinsics,
                                                          m_SurfaceNode,
                                                          GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderer()->GetVtkRenderer()->GetActiveCamera());
     // set distance image to measurement widget
     m_Controls->m_ToFMeasurementWidget->SetDistanceImage(m_MitkDistanceImage);
 
     this->m_Frametimer->start(50);
 
     m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(true);
     m_Controls->m_ToFCompositeFilterWidget->setEnabled(true);
     m_Controls->m_ToFMeasurementWidget->setEnabled(true);
     m_Controls->m_ToFSurfaceGenerationWidget->setEnabled(true);
   }
 }
 
 void QmitkToFUtilView::OnToFCameraStopped()
 {
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
   m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
 
   this->m_Frametimer->stop();
 }
 
 void QmitkToFUtilView::OnUpdateCamera()
 {
   if(!m_Controls->m_ToFSurfaceGenerationWidget->UpdateSurface())
   {
     // update pipeline
     this->m_MitkDistanceImage->Update();
   }
 
   this->RequestRenderWindowUpdate();
 
   if (m_Framerateoutput)
   {
     this->m_2DDisplayCount++;
     if ((this->m_2DDisplayCount % this->m_StepsForFramerate) == 0)
     {
       this->m_2DTimeAfter = this->m_RealTimeClock->GetCurrentStamp() - this->m_2DTimeBefore;
       MITK_INFO << " 2D-Display-framerate (fps): " << this->m_StepsForFramerate / (this->m_2DTimeAfter / 1000);
       this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
     }
   }
 
 }
 
 void QmitkToFUtilView::OnChangeCoronalWindowOutput(int index)
 {
   this->OnToFCameraStopped();
   if(index == 0)
   {
     if(this->m_IntensityImageNode.IsNotNull())
       this->m_IntensityImageNode->SetVisibility(false);
     if(this->m_RGBImageNode.IsNotNull())
       this->m_RGBImageNode->SetVisibility(true);
   }
   else if(index == 1)
   {
     if(this->m_IntensityImageNode.IsNotNull())
       this->m_IntensityImageNode->SetVisibility(true);
     if(this->m_RGBImageNode.IsNotNull())
       this->m_RGBImageNode->SetVisibility(false);
   }
   this->RequestRenderWindowUpdate();
   this->OnToFCameraStarted();
 }
 
 mitk::DataNode::Pointer QmitkToFUtilView::ReplaceNodeData( std::string nodeName, mitk::BaseData* data )
 {
   mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode(nodeName);
   if (node.IsNull())
   {
     node = mitk::DataNode::New();
     node->SetName(nodeName);
     node->SetBoolProperty("binary",false);
     node->SetData(data);
     this->GetDataStorage()->Add(node);
   }
   else
   {
     node->SetData(data);
   }
   return node;
 }
 
 void QmitkToFUtilView::UseToFVisibilitySettings(bool useToF)
 {
   //We need this property for every node.
   mitk::RenderingModeProperty::Pointer renderingModePropertyForTransferFunction = mitk::RenderingModeProperty::New(mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR);
 
   // set node properties
   if (m_DistanceImageNode.IsNotNull())
   {
     this->m_DistanceImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
     this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
     this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetRenderWindow() ) );
     this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
     this->m_DistanceImageNode->SetProperty("Image Rendering.Mode", renderingModePropertyForTransferFunction);
   }
   if (m_AmplitudeImageNode.IsNotNull())
   {
     this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
     this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetRenderWindow() ) );
     this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
     this->m_AmplitudeImageNode->SetProperty("Image Rendering.Mode", renderingModePropertyForTransferFunction);
   }
   if (m_IntensityImageNode.IsNotNull())
   {
       this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
       this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
       this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
       this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
       this->m_IntensityImageNode->SetProperty("Image Rendering.Mode", renderingModePropertyForTransferFunction);
   }
   if ((m_RGBImageNode.IsNotNull()))
   {
       this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
       this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
       this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
       this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
   }
   // initialize images
   if (m_MitkDistanceImage.IsNotNull())
   {
       mitk::RenderingManager::GetInstance()->InitializeViews(
           this->m_MitkDistanceImage->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS, true);
   }
   if(this->m_SurfaceNode.IsNotNull())
   {
     QHash<QString, QmitkRenderWindow*> renderWindowHashMap = this->GetRenderWindowPart()->GetQmitkRenderWindows();
     QHashIterator<QString, QmitkRenderWindow*> i(renderWindowHashMap);
     while (i.hasNext()){
       i.next();
       this->m_SurfaceNode->SetVisibility( false, mitk::BaseRenderer::GetInstance(i.value()->GetRenderWindow()) );
     }
     this->m_SurfaceNode->SetVisibility( true, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
   }
   //disable/enable gradient background
   this->GetRenderWindowPart()->EnableDecorations(!useToF, QStringList(QString("background")));
 
   if((this->m_RGBImageNode.IsNotNull()))
   {
     bool RGBImageHasDifferentResolution = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("RGBImageHasDifferentResolution",RGBImageHasDifferentResolution);
     if(RGBImageHasDifferentResolution)
     {
       //update the display geometry by using the RBG image node. Only for renderwindow coronal
       mitk::RenderingManager::GetInstance()->InitializeView( GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetRenderWindow(), this->m_RGBImageNode->GetData()->GetGeometry() );
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.tubegraph/src/internal/QmitkTubeGraphView.cpp b/Plugins/org.mitk.gui.qt.tubegraph/src/internal/QmitkTubeGraphView.cpp
index 8e3ac99120..98ef75915f 100644
--- a/Plugins/org.mitk.gui.qt.tubegraph/src/internal/QmitkTubeGraphView.cpp
+++ b/Plugins/org.mitk.gui.qt.tubegraph/src/internal/QmitkTubeGraphView.cpp
@@ -1,624 +1,624 @@
 /*===================================================================
 
 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 "QmitkTubeGraphView.h"
 
 #include "mitkDataStorage.h"
 #include "mitkRenderingManager.h"
 #include "mitkNodePredicateDataType.h"
 #include "usModuleRegistry.h"
 #include "QmitkTubeGraphLabelGroupWidget.h"
 #include "QmitkTubeGraphDeleteLabelGroupDialog.h"
 #include "QmitkTubeGraphNewLabelGroupDialog.h"
 #include "QmitkTubeGraphNewAnnotationDialog.h"
 
 const std::string QmitkTubeGraphView::VIEW_ID = "org.mitk.views.tubegraph";
 
 QmitkTubeGraphView::QmitkTubeGraphView()
   :QmitkAbstractView(),
   m_ActiveTubeGraph(),
   m_ActiveProperty(),
   m_ActivationMode(mitk::TubeGraphDataInteractor::None)
 {
 }
 
 QmitkTubeGraphView::~QmitkTubeGraphView()
 {
   //m_ActivationMode.mitk::TubeGraphDataInteractor::ActivationMode::~ActivationMode();
 
   //remove observer
   //if (m_ActiveInteractor.IsNotNull())
   //m_ActiveInteractor->RemoveObserver(m_InformationChangedObserverTag);
 
 }
 
 void QmitkTubeGraphView::SetFocus()
 {
   m_Controls.activeNodeGroupBox->setFocus();
 }
 
 void QmitkTubeGraphView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets
   m_Parent = parent;
   m_Controls.setupUi(parent);
   this->CreateConnections();
 }
 
 void QmitkTubeGraphView::NodeRemoved(const mitk::DataNode* /*node*/)
 {
 
 }
 
 void QmitkTubeGraphView::CreateConnections()
 {
   mitk::NodePredicateDataType::Pointer tubeGraphPred = mitk::NodePredicateDataType::New("TubeGraph");
   m_Controls.activeGraphComboBox->SetDataStorage(this->GetDataStorage());
   m_Controls.activeGraphComboBox->SetPredicate(tubeGraphPred);
 
   //activation mode
   connect( m_Controls.activeGraphComboBox, SIGNAL(currentIndexChanged (int)), this, SLOT(OnActiveGraphChanged(int)) );
   connect( m_Controls.noneModeRadioButton, SIGNAL(clicked()), this, SLOT(OnActivationModeChanged()));
   connect( m_Controls.singleModeRadioButton, SIGNAL(clicked()), this, SLOT(OnActivationModeChanged()));
   connect( m_Controls.multipleModeRadioButton, SIGNAL(clicked()), this, SLOT(OnActivationModeChanged()));
   connect( m_Controls.peripheryModeRadioButton, SIGNAL(clicked()), this, SLOT(OnActivationModeChanged()));
   connect( m_Controls.rootModeRadioButton, SIGNAL(clicked()), this, SLOT(OnActivationModeChanged()));
   connect( m_Controls.pointModeRadioButton, SIGNAL(clicked()), this, SLOT(OnActivationModeChanged()));
   connect( m_Controls.setRootButton, SIGNAL(toggled(bool)), this, SLOT(OnSetRootToggled(bool)));
 
   //deselect tubes
   connect( m_Controls.deselectAllButton, SIGNAL(clicked()), this, SLOT(OnDeselectAllTubes()));
 
   // tab switch
   connect( m_Controls.tubeGraphTabWidget, SIGNAL(currentChanged(int)), this, SLOT(OnTabSwitched(int)));
 
   //attributation tab
   connect( m_Controls.addLabelGroupButton, SIGNAL(clicked()), this, SLOT(OnAddingLabelGroup()));
   connect( m_Controls.removeLabelGroupButton, SIGNAL(clicked()), this, SLOT(OnRemoveLabelGroup()));
 
   //annotation tab
   connect( m_Controls.addAnnotationButton, SIGNAL(clicked()), this, SLOT(OnAddingAnnotation()));
   connect( m_Controls.deleteAnnotationButton, SIGNAL(clicked()), this, SLOT(OnRemoveAnnotation()));
 
   //edit tab
   connect( m_Controls.editSelectionNewButton, SIGNAL(clicked()), this, SLOT(OnAddTubeBetweenSelection()));
   connect( m_Controls.editSelectionSeperateButton, SIGNAL(clicked()), this, SLOT(OnSeperateSelection()));
   connect( m_Controls.editSelectionDeleteButton, SIGNAL(clicked()), this, SLOT(OnDeleteSelection()));
 
 
   this->SetTabsEnable(false);
 }
 
 void QmitkTubeGraphView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   for (mitk::DataNode::Pointer node: nodes)
   {
     if( node.IsNotNull() && dynamic_cast< mitk::TubeGraph* >(node->GetData()) )
     {
       m_Controls.activeGraphComboBox->SetSelectedNode(node);
       m_ActiveTubeGraph = dynamic_cast< mitk::TubeGraph* >(node->GetData());
 
       m_ActiveProperty = dynamic_cast<mitk::TubeGraphProperty*>(m_ActiveTubeGraph->GetProperty( "Tube Graph.Visualization Information" ).GetPointer());
 
       this->UpdateActiveTubeGraphInInteractors();
       this->UpdateLabelGroups();
       this->UpdateAnnotation();
     }
   }
 }
 
 void QmitkTubeGraphView::OnActiveGraphChanged(int)
 {
   mitk::DataNode::Pointer selectedNode = m_Controls.activeGraphComboBox->GetSelectedNode();
 
   if(selectedNode.IsNotNull())
   {
     m_ActiveTubeGraph = dynamic_cast <mitk::TubeGraph* >( selectedNode->GetData() );
 
     m_ActiveProperty = dynamic_cast<mitk::TubeGraphProperty*>(m_ActiveTubeGraph->GetProperty("Tube Graph.Visualization Information" ).GetPointer());
     this->SetTabsEnable(true);
     this->UpdateGraphInformation();
   }
   else
   {
     m_ActiveTubeGraph = nullptr;
     m_ActiveProperty = nullptr;
     this->SetTabsEnable(false);
 
   }
   this->UpdateActiveTubeGraphInInteractors();
   this->UpdateLabelGroups();
   this->UpdateAnnotation();
 }
 
 void QmitkTubeGraphView::UpdateActiveTubeGraphInInteractors()
 {
   //
   // traverse all tube graphs and check, and add an interactor if needed...
   //
   mitk::NodePredicateDataType::Pointer tubeGraphPred = mitk::NodePredicateDataType::New("TubeGraph");
   mitk::DataStorage::SetOfObjects::ConstPointer tubeGraphs = this->GetDataStorage()->GetSubset(tubeGraphPred);
   for(mitk::DataStorage::SetOfObjects::ConstIterator it = tubeGraphs->Begin();
     it != tubeGraphs->End();
     ++it)
   {
     mitk::DataNode::Pointer node = it.Value().GetPointer();
     if ( node->GetDataInteractor().IsNull() )
     {
       mitk::TubeGraphDataInteractor::Pointer tubeGraphInteractor = mitk::TubeGraphDataInteractor::New();
       tubeGraphInteractor->LoadStateMachine("TubeGraphInteraction.xml", us::ModuleRegistry::GetModule("MitkTubeGraph"));
       tubeGraphInteractor->SetEventConfig("TubeGraphConfig.xml", us::ModuleRegistry::GetModule("MitkTubeGraph"));
       tubeGraphInteractor->SetActivationMode(m_ActivationMode);
       tubeGraphInteractor->SetDataNode(node);
     }
   }
 
   if (m_ActiveTubeGraph.IsNotNull())
   {
     //remove old observer
    // if (m_ActiveInteractor.IsNotNull())
       //  m_ActiveInteractor->RemoveObserver(m_InformationChangedObserverTag);
 
         mitk::DataNode::Pointer node = m_Controls.activeGraphComboBox->GetSelectedNode();
     //set active interactor to interactor from selected node
     m_ActiveInteractor = dynamic_cast<mitk::TubeGraphDataInteractor*>(node->GetDataInteractor().GetPointer());
 
     m_ActiveInteractor->SetActivationMode(m_ActivationMode);
 
     //add observer to activeInteractor
     typedef itk::SimpleMemberCommand< QmitkTubeGraphView > SimpleCommandType;
     SimpleCommandType::Pointer changeInformationCommand = SimpleCommandType::New();
     changeInformationCommand->SetCallbackFunction(this, &QmitkTubeGraphView::SelectionInformationChanged);
     //m_InformationChangedObserverTag = m_ActiveInteractor->AddObserver(mitk::SelectionChangedTubeGraphEvent(), changeInformationCommand);
 
     ////Add selected node to all tube graph interactors as current node
     //mitk::TubeGraphDataInteractor::SetCurrentSelectedDataNode( node );
 
     if (m_ActiveProperty.IsNull())
     {
       mitk::TubeGraphProperty::Pointer newProperty = mitk::TubeGraphProperty::New();
       m_ActiveTubeGraph->SetProperty("Tube Graph.Visualization Information",newProperty);
       m_ActiveProperty = newProperty;
     }
   }
 }
 
 void QmitkTubeGraphView::UpdateLabelGroups()
 {
   for(int i = m_Controls.toolBox->count()- 1; i >= 0  ; i--)
     m_Controls.toolBox->removeItem(i);
 
   if (m_ActiveProperty.IsNotNull())
   {
     if(m_ActiveProperty->GetNumberOfLabelGroups()!= 0)
     {
       std::vector<LabelGroupType*> labelGroups = m_ActiveProperty->GetLabelGroups();
 
       for (unsigned int k = 0; k < labelGroups.size(); k++)
         this->CreateLabelGroupWidget(labelGroups.at(k));
     }
   }
 }
 
 void QmitkTubeGraphView::OnActivationModeChanged()
 {
   if (m_Controls.noneModeRadioButton->isChecked())
     m_ActivationMode = mitk::TubeGraphDataInteractor::None;
   else if (m_Controls.singleModeRadioButton->isChecked())
     m_ActivationMode = mitk::TubeGraphDataInteractor::Single;
   else if (m_Controls.multipleModeRadioButton->isChecked())
     m_ActivationMode = mitk::TubeGraphDataInteractor::Multiple;
   else if (m_Controls.rootModeRadioButton->isChecked())
     m_ActivationMode = mitk::TubeGraphDataInteractor::ToRoot;
   else if (m_Controls.peripheryModeRadioButton->isChecked())
     m_ActivationMode = mitk::TubeGraphDataInteractor::ToPeriphery;
   else if (m_Controls.pointModeRadioButton->isChecked())
     m_ActivationMode = mitk::TubeGraphDataInteractor::Points;
   else //normally not possible, but.... set to single mode
     m_ActivationMode = mitk::TubeGraphDataInteractor::Single;
 
   mitk::DataNode::Pointer node = m_Controls.activeGraphComboBox->GetSelectedNode();
   if(node.IsNotNull() && m_ActiveProperty.IsNotNull())
   {
     dynamic_cast< mitk::TubeGraphDataInteractor*>(node->GetDataInteractor().GetPointer())->SetActivationMode(m_ActivationMode);
 
     //m_ActiveTubeGraph->Modified();
     // render new selection
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 mitk::TubeGraphDataInteractor::ActivationMode QmitkTubeGraphView::GetActivationMode ()
 {
   return m_ActivationMode;
 }
 
 void QmitkTubeGraphView::OnSetRootToggled(bool enable)
 {
   this->SetTabsEnable(!enable);
   if (m_ActiveTubeGraph.IsNotNull())
   {
     mitk::DataNode::Pointer node = m_Controls.activeGraphComboBox->GetSelectedNode();
     if(node.IsNotNull())
     {
       if (enable)
         dynamic_cast<mitk::TubeGraphDataInteractor*>(node->GetDataInteractor().GetPointer())->SetActionMode(mitk::TubeGraphDataInteractor::RootMode);
       else
         dynamic_cast<mitk::TubeGraphDataInteractor*>(node->GetDataInteractor().GetPointer())->SetActionMode(mitk::TubeGraphDataInteractor::AttributationMode);
     }
   }
 }
 
 void QmitkTubeGraphView::OnDeselectAllTubes()
 {
   mitk::DataNode::Pointer node = m_Controls.activeGraphComboBox->GetSelectedNode();
   if(node.IsNotNull())
     dynamic_cast<mitk::TubeGraphDataInteractor*>(node->GetDataInteractor().GetPointer())->ResetPickedTubes();
 
   if (m_ActiveProperty.IsNull())
   {
     MITK_ERROR << "Oho!No Property..mhhhh";
     return;
   }
   m_ActiveProperty->DeactivateAllTubes();
   m_ActiveTubeGraph->Modified();
   // render new selection
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkTubeGraphView::OnTabSwitched(int tabIndex)
 {
   mitk::DataNode::Pointer node = m_Controls.activeGraphComboBox->GetSelectedNode();
   if(node.IsNotNull())
   {
-    if (dynamic_cast<mitk::TubeGraphDataInteractor*>(node->GetDataInteractor().GetPointer()) == 0)
+    if (dynamic_cast<mitk::TubeGraphDataInteractor*>(node->GetDataInteractor().GetPointer()) == nullptr)
     {
       this->UpdateActiveTubeGraphInInteractors();
       /* if (dynamic_cast<mitk::TubeGraphDataInteractor::Pointer>(node->GetDataInteractor().GetPointer()).IsNull());*/
       return;
     }
 
     switch(tabIndex)
     {
     case 0:
       dynamic_cast<mitk::TubeGraphDataInteractor*>(node->GetDataInteractor().GetPointer())->SetActionMode(mitk::TubeGraphDataInteractor::AttributationMode);
       m_Controls.noneModeRadioButton->setEnabled(true);
       m_Controls.singleModeRadioButton->setEnabled(true);
       m_Controls.multipleModeRadioButton->setEnabled(true);
       m_Controls.peripheryModeRadioButton->setEnabled(true);
       m_Controls.rootModeRadioButton->setEnabled(true);
       m_Controls.pointModeRadioButton->setEnabled(true);
       break;
     case 1:
       dynamic_cast<mitk::TubeGraphDataInteractor*>(node->GetDataInteractor().GetPointer())->SetActionMode(mitk::TubeGraphDataInteractor::AnnotationMode);
       m_ActiveProperty->DeactivateAllTubes();
       m_Controls.noneModeRadioButton->setEnabled(true);
       m_Controls.singleModeRadioButton->setEnabled(true);
       m_Controls.multipleModeRadioButton->setEnabled(false);
       m_Controls.peripheryModeRadioButton->setEnabled(false);
       m_Controls.rootModeRadioButton->setEnabled(false);
       m_Controls.pointModeRadioButton->setEnabled(false);
       break;
     case 2:
       dynamic_cast<mitk::TubeGraphDataInteractor*>(node->GetDataInteractor().GetPointer())->SetActionMode(mitk::TubeGraphDataInteractor::EditMode);
       m_Controls.noneModeRadioButton->setEnabled(true);
       m_Controls.singleModeRadioButton->setEnabled(true);
       m_Controls.multipleModeRadioButton->setEnabled(true);
       m_Controls.peripheryModeRadioButton->setEnabled(true);
       m_Controls.rootModeRadioButton->setEnabled(true);
       m_Controls.pointModeRadioButton->setEnabled(true);
       break;
     case 3:
       dynamic_cast<mitk::TubeGraphDataInteractor*>(node->GetDataInteractor().GetPointer())->SetActionMode(mitk::TubeGraphDataInteractor::InformationMode);
       m_Controls.noneModeRadioButton->setEnabled(false);
       m_Controls.singleModeRadioButton->setEnabled(false);
       m_Controls.multipleModeRadioButton->setEnabled(false);
       m_Controls.peripheryModeRadioButton->setEnabled(false);
       m_Controls.rootModeRadioButton->setEnabled(false);
       m_Controls.pointModeRadioButton->setEnabled(false);
       this->UpdateGraphInformation();
       break;
     default:
       break;
     }
   }
 }
 
 void QmitkTubeGraphView::OnAddingLabelGroup()
 {
   QmitkTubeGraphNewLabelGroupDialog* dialog = new QmitkTubeGraphNewLabelGroupDialog( m_Parent );
 
   int dialogReturnValue = dialog->exec();
 
   LabelGroupType* newLabelGroup = dialog->GetLabelGroup();
   delete dialog;
 
   if ( dialogReturnValue != QDialog::Rejected ) // user doesn't clicked cancel or pressed Esc or something similar
   {
     m_ActiveProperty->AddLabelGroup(newLabelGroup, m_ActiveProperty->GetNumberOfLabelGroups());
     this->UpdateLabelGroups();
   }
 }
 
 void QmitkTubeGraphView::CreateLabelGroupWidget(LabelGroupType* labelGroup)
 {
   QmitkTubeGraphLabelGroupWidget* labelGroupWidget = new QmitkTubeGraphLabelGroupWidget(m_Controls.toolBox, (labelGroup->labelGroupName).c_str());
 
   for (std::vector<LabelType*>::iterator it = labelGroup->labels.begin(); it != labelGroup->labels.end(); it++)
   {
     labelGroupWidget->AddLabel(QString::fromStdString((*it)->labelName), (*it)->labelColor);
   }
 
   m_Controls.toolBox->addItem(labelGroupWidget, QString::fromStdString(labelGroup->labelGroupName));
 
   connect(labelGroupWidget, SIGNAL(SignalLabelVisibilityInGroupToggled(bool, QString, QString)), this, SLOT(OnLabelVisibilityChanged(bool, QString, QString)));
   connect(labelGroupWidget, SIGNAL(SignalLabelButtonInGroupClicked(QString, QString)), this, SLOT(OnLabelChanged(QString, QString)));
   connect(labelGroupWidget, SIGNAL(SignalLabelColorInGroupChanged(mitk::Color, QString, QString)), this, SLOT(OnLabelColorChanged(mitk::Color, QString, QString)));
 }
 
 void QmitkTubeGraphView::OnRemoveLabelGroup()
 {
   QStringList allLabelGroups;
   std::vector<LabelGroupType*> labelGroups = m_ActiveProperty->GetLabelGroups();
   for (unsigned int i = 0; i < labelGroups.size(); i++)
     allLabelGroups.push_back(QString::fromStdString(labelGroups.at(i)->labelGroupName));
 
   QmitkTubeGraphDeleteLabelGroupDialog* dialog = new QmitkTubeGraphDeleteLabelGroupDialog( m_Parent );
   dialog->SetLabelGroups(allLabelGroups);
 
   int dialogReturnValue = dialog->exec();
 
   QList<QString> toDeleteItemsList = dialog->GetSelectedLabelGroups();
 
   delete dialog;
 
   if ( dialogReturnValue != QDialog::Rejected ) // user clicked cancel or pressed Esc or something similar
   {
     for (QList<QString>::iterator it = toDeleteItemsList.begin(); it != toDeleteItemsList.end(); it++ )
     {
       std::string labelGroupName = (*it).toStdString();
       LabelGroupType* labelGroup = m_ActiveProperty->GetLabelGroupByName(labelGroupName);
       m_ActiveProperty->RemoveLabelGroup(labelGroup);
     }
     this->UpdateLabelGroups();
   }
 }
 
 void QmitkTubeGraphView::OnAddingAnnotation()
 {
   std::vector <mitk::TubeGraph::TubeDescriptorType> activeTubes = m_ActiveProperty->GetActiveTubes();
   if (activeTubes.size()!= 0)
   {
     QmitkTubeGraphNewAnnotationDialog* dialog = new QmitkTubeGraphNewAnnotationDialog( m_Parent );
 
     int dialogReturnValue = dialog->exec();
 
     QString newAnnotationName = dialog->GetAnnotationName();
     QString newDescription = dialog->GetAnnotationDescription();
     QString tubeString = QString("[%1,%2]").arg(activeTubes.begin()->first).arg(activeTubes.begin()->second);
 
     delete dialog;
 
     if ( dialogReturnValue != QDialog::Rejected ) // user doesn't clicked cancel or pressed Esc or something similar
     {
 
       mitk::TubeGraphProperty::Annotation* annotation = new mitk::TubeGraphProperty::Annotation();
       annotation->name =  newAnnotationName.toStdString();
       annotation->description = newDescription.toStdString();
       annotation->tube = (*activeTubes.begin());
 
       m_ActiveProperty->AddAnnotation(annotation);
       this->UpdateAnnotation();
     }
   }
   else
   {
     MITK_INFO<< "No Tube select for annotation";
   }
 }
 
 void QmitkTubeGraphView::UpdateAnnotation()
 {
   m_Controls.annotationsTableWidget->clear();
   m_Controls.annotationsTableWidget->setRowCount(0);
   if (m_ActiveProperty.IsNotNull())
   {
     std::vector<mitk::TubeGraphProperty::Annotation*> annotations = m_ActiveProperty->GetAnnotations();
 
     if (annotations.size() != 0)
     {
       for (unsigned int k = 0; k < annotations.size(); k++)
       {
         m_Controls.annotationsTableWidget->setRowCount(k+1); // add one row
 
         QTableWidgetItem* annotationNameItem = new QTableWidgetItem(QString::fromStdString(annotations[k]->name));
         QTableWidgetItem* annotationDescriptionItem = new QTableWidgetItem(QString::fromStdString(annotations[k]->description));
         QString tubeString = QString("[%1,%2]").arg(annotations[k]->tube.first).arg(annotations[k]->tube.second);
         QTableWidgetItem* annotationTubeItem = new QTableWidgetItem(tubeString);
 
         m_Controls.annotationsTableWidget->setItem(k, 0, annotationNameItem);
         m_Controls.annotationsTableWidget->setItem(k, 1, annotationDescriptionItem);
         m_Controls.annotationsTableWidget->setItem(k, 2, annotationTubeItem);
       }
     }
   }
 }
 
 
 void QmitkTubeGraphView::OnRemoveAnnotation()
 {
   //m_Controls.annotationsTableWidget->removeRow(m_Controls.annotationsTableWidget->currentRow());
   int row = m_Controls.annotationsTableWidget->currentRow();
 
   if (row >= 0)
   {
     std::string name =  m_Controls.annotationsTableWidget->item(row, 0)->text().toStdString();
 
     mitk::TubeGraphProperty::Annotation* annotation = m_ActiveProperty->GetAnnotationByName(name);
     m_ActiveProperty->RemoveAnnotation(annotation);
     this->UpdateAnnotation();
   }
 
 }
 
 
 void QmitkTubeGraphView::OnAddTubeBetweenSelection()
 {
 }
 
 void QmitkTubeGraphView::OnSeperateSelection()
 {
   std::vector <mitk::TubeGraph::TubeDescriptorType> activeTubes = m_ActiveProperty->GetActiveTubes();
   if (activeTubes.size()!= 0)
   {
     mitk::TubeGraph::Pointer subGraph = m_ActiveTubeGraph->CreateSubGraph(activeTubes);
 
     mitk::DataNode::Pointer originGraphNode = m_Controls.activeGraphComboBox->GetSelectedNode();
 
     mitk::DataNode::Pointer newGraphNode = mitk::DataNode::New();
     newGraphNode->SetData(subGraph);
     newGraphNode->SetName(originGraphNode->GetName() + "-SubGraph");
 
     mitk::TubeGraphDataInteractor::Pointer tubeGraphInteractor = mitk::TubeGraphDataInteractor::New();
     tubeGraphInteractor->LoadStateMachine("TubeGraphInteraction.xml", us::ModuleRegistry::GetModule("TubeGraph"));
     tubeGraphInteractor->SetEventConfig("TubeGraphConfig.xml", us::ModuleRegistry::GetModule("TubeGraph"));
     tubeGraphInteractor->SetDataNode(newGraphNode);
 
     mitk::TubeGraphProperty::Pointer newProperty = mitk::TubeGraphProperty::New();
     subGraph->SetProperty("Tube Graph.Visualization Information",newProperty);
 
     this->GetDataStorage()->Add(newGraphNode, originGraphNode);
   }
 }
 
 void QmitkTubeGraphView::OnDeleteSelection()
 { //TODO Action for Interactor + undo/redo
 
   std::vector <mitk::TubeGraph::TubeDescriptorType> activeTubes = m_ActiveProperty->GetActiveTubes();
   m_ActiveTubeGraph->RemoveSubGraph(m_ActiveProperty->GetActiveTubes());
 }
 
 void QmitkTubeGraphView::OnLabelVisibilityChanged(bool isVisible, QString labelName, QString labelGroupName)
 {
   if (m_ActiveProperty.IsNull())
   {
     MITK_ERROR << "Oho!No Property..mhhhh";
     return;
   }
   LabelGroupType* labelGroup = m_ActiveProperty->GetLabelGroupByName(labelGroupName.toStdString());
   LabelType* label = m_ActiveProperty->GetLabelByName(labelGroup, labelName.toStdString());
 
-  if(labelGroup == 0 || label == 0 )
+  if(labelGroup == nullptr || label == nullptr )
   {
     MITK_ERROR << "This label group or label doesn't exist!";
     return;
   }
 
   m_ActiveProperty->SetLabelVisibility(label, isVisible);
   m_ActiveTubeGraph->Modified();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkTubeGraphView::OnLabelChanged(QString labelName, QString labelGroupName)
 {
   if (m_ActiveProperty.IsNull())
   {
     MITK_ERROR << "Oho!No Property..mhhhh";
     return;
   }
   LabelGroupType* labelGroup = m_ActiveProperty->GetLabelGroupByName(labelGroupName.toStdString());
   LabelType* label = m_ActiveProperty->GetLabelByName(labelGroup, labelName.toStdString());
-  if(labelGroup == 0 || label == 0 )
+  if(labelGroup == nullptr || label == nullptr )
   {
     MITK_ERROR << "This label group or label doesn't exist!";
     return;
   }
 
   m_ActiveProperty->SetLabelForActivatedTubes(labelGroup, label);
   m_ActiveTubeGraph->Modified();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkTubeGraphView::OnLabelColorChanged (mitk::Color color, QString labelName, QString labelGroupName)
 {
   if (m_ActiveProperty.IsNull())
   {
     MITK_ERROR << "Oho!No Property..mhhhh";
     return;
   }
 
   LabelGroupType* labelGroup = m_ActiveProperty->GetLabelGroupByName(labelGroupName.toStdString());
   LabelType* label = m_ActiveProperty->GetLabelByName(labelGroup, labelName.toStdString());
 
-  if(labelGroup == 0 || label == 0 )
+  if(labelGroup == nullptr || label == nullptr )
   {
     MITK_ERROR << "This label group or label doesn't exist!";
     return;
   }
 
   m_ActiveProperty->SetLabelColor(label, color);
   m_ActiveTubeGraph->Modified();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkTubeGraphView::SetTabsEnable(bool enable)
 {
   m_Controls.tubeGraphTabWidget->setTabEnabled(0, enable); //attributationTab
   m_Controls.tubeGraphTabWidget->setTabEnabled(1, enable);//annotationTab
   m_Controls.tubeGraphTabWidget->setTabEnabled(2, enable);//editTab
   m_Controls.tubeGraphTabWidget->setTabEnabled(3, enable);//informationTab
 }
 
 void QmitkTubeGraphView::UpdateGraphInformation()
 {
   mitk::TubeGraph::TubeDescriptorType root = m_ActiveTubeGraph->GetRootTube();
   mitk::BaseGeometry::Pointer geometry = m_ActiveTubeGraph->GetGeometry();
   mitk::Point3D origin = geometry->GetOrigin();
   mitk::Vector3D spacing = geometry->GetSpacing();
   QString information;
   information.append(QString("Number of Vertices: %1\n").arg(m_ActiveTubeGraph->GetNumberOfVertices()));
   information.append(QString("Number of Edges: %1\n").arg(m_ActiveTubeGraph->GetNumberOfEdges()));
   information.append(QString("Root Id: [%1,%2]\n\n").arg(root.first).arg(root.second));
   information.append(QString("Origin: [%1,%2,%3]\n").arg(origin[0]).arg(origin[1]).arg(origin[2]));
   information.append(QString("Spacing: [%1,%2,%3]").arg(spacing[0]).arg(spacing[1]).arg(spacing[2]));
 
   m_Controls.informationLabel->setText(information);
 }
 
 void QmitkTubeGraphView::SelectionInformationChanged()
 {
   std::vector <mitk::TubeGraph::TubeDescriptorType> activeTubes = m_ActiveProperty->GetActiveTubes();
   if(activeTubes.size()==0)
     m_Controls.shortInformationLabel->setText("");
   else
   {
     mitk::TubeGraph::TubeDescriptorType root = m_ActiveTubeGraph->GetRootTube();
     /*double averageDiameter;
     for (int i = 0; i < activeTubes.size(); i++)
     {
     mitk::TubeGraph::EdgeDescriptorType edgeDescriptor = m_ActiveTubeGraph->GetEdgeDescriptorByVerices(activeTubes.at(i).first, activeTubes.at(i).second);
     mitk::TubeGraphEdge edge =  m_ActiveTubeGraph->GetEdge(edgeDescriptor);
     averageDiameter += edge.GetEdgeAverageDiameter(m_ActiveTubeGraph->GetVertex(activeTubes.at(i).first), m_ActiveTubeGraph->GetVertex(activeTubes.at(i).second));
     }
     averageDiameter = averageDiameter/activeTubes.size();*/
 
     QString information;
     information.append(QString("Number of Selected Tubes: %1\n").arg(activeTubes.size()));
     //information.append(QString("Average diameter\n").arg(averageDiameter));
     information.append(QString("Root Id: [%1,%2]").arg(root.first).arg(root.second));
     m_Controls.shortInformationLabel->setText(information);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.ugvisualization/src/internal/QmitkUGVisualizationView.cpp b/Plugins/org.mitk.gui.qt.ugvisualization/src/internal/QmitkUGVisualizationView.cpp
index 60a5ae646c..408605fae8 100644
--- a/Plugins/org.mitk.gui.qt.ugvisualization/src/internal/QmitkUGVisualizationView.cpp
+++ b/Plugins/org.mitk.gui.qt.ugvisualization/src/internal/QmitkUGVisualizationView.cpp
@@ -1,289 +1,289 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkUGVisualizationView.h"
 
 #include <mitkUnstructuredGrid.h>
 #include <mitkGridRepresentationProperty.h>
 #include <mitkGridVolumeMapperProperty.h>
 #include <mitkVtkScalarModeProperty.h>
 #include <mitkPropertyObserver.h>
 
 #include <QmitkUGCombinedRepresentationPropertyWidget.h>
 #include <QmitkBoolPropertyWidget.h>
 
 #include <QWidgetAction>
 
 #include <QMenu>
 
 
 class UGVisVolumeObserver : public mitk::PropertyView
 {
 public:
 
   UGVisVolumeObserver(mitk::BoolProperty* property, QmitkUGVisualizationView* view)
     : PropertyView(property), m_View(view), m_BoolProperty(property)
   {
   }
 
 protected:
 
   void PropertyChanged() override
   {
     m_View->m_VolumeMode = m_BoolProperty->GetValue();
     m_View->UpdateEnablement();
   }
 
   void PropertyRemoved() override
   {
     m_View->m_VolumeMode = false;
-    m_Property = 0;
-    m_BoolProperty = 0;
+    m_Property = nullptr;
+    m_BoolProperty = nullptr;
   }
 
   QmitkUGVisualizationView* m_View;
   mitk::BoolProperty* m_BoolProperty;
 
 };
 
 
 const std::string QmitkUGVisualizationView::VIEW_ID = "org.mitk.views.ugvisualization";
 
 
 QmitkUGVisualizationView::QmitkUGVisualizationView()
-: QmitkAbstractView(), m_Outline2DAction(0), m_Outline2DWidget(0),
-  m_LODAction(0), m_ScalarVisibilityAction(0), m_ScalarVisibilityWidget(0),
+: QmitkAbstractView(), m_Outline2DAction(nullptr), m_Outline2DWidget(nullptr),
+  m_LODAction(nullptr), m_ScalarVisibilityAction(nullptr), m_ScalarVisibilityWidget(nullptr),
   m_FirstVolumeRepId(-1), m_ShowTFGeneratorWidget(true), m_ShowScalarOpacityWidget(false),
-  m_ShowColorWidget(true), m_ShowGradientOpacityWidget(false), m_ShowTFGeneratorAction(0),
-  m_ShowScalarOpacityAction(0), m_ShowColorAction(0), m_ShowGradientOpacityAction(0),
-  m_VolumeModeObserver(0)
+  m_ShowColorWidget(true), m_ShowGradientOpacityWidget(false), m_ShowTFGeneratorAction(nullptr),
+  m_ShowScalarOpacityAction(nullptr), m_ShowColorAction(nullptr), m_ShowGradientOpacityAction(nullptr),
+  m_VolumeModeObserver(nullptr)
 {
 }
 
 QmitkUGVisualizationView::~QmitkUGVisualizationView()
 {
   delete m_VolumeModeObserver;
 }
 
 
 void QmitkUGVisualizationView::CreateQtPartControl( QWidget *parent )
 {
   m_Controls.setupUi( parent );
 
   m_Outline2DWidget = new QmitkBoolPropertyWidget("Outline 2D polygons", parent);
   m_Outline2DAction = new QWidgetAction(this);
   m_Outline2DAction->setDefaultWidget(m_Outline2DWidget);
 
   m_LODAction = new QAction("Enable LOD (Level Of Detail)", this);
   m_LODAction->setCheckable(true);
 
   m_ScalarVisibilityWidget = new QmitkBoolPropertyWidget("Visualize scalars", parent);
   m_ScalarVisibilityAction = new QWidgetAction(this);
   m_ScalarVisibilityAction->setDefaultWidget(m_ScalarVisibilityWidget);
 
   m_ShowColorAction = new QAction("Show color transfer function", this);
   m_ShowColorAction->setCheckable(true);
   m_ShowColorAction->setChecked(m_ShowColorWidget);
   m_ShowGradientOpacityAction = new QAction("Show gradient opacity function", this);
   m_ShowGradientOpacityAction->setCheckable(true);
   m_ShowGradientOpacityAction->setChecked(m_ShowGradientOpacityWidget);
   m_ShowScalarOpacityAction = new QAction("Show scalar opacity function", this);
   m_ShowScalarOpacityAction->setCheckable(true);
   m_ShowScalarOpacityAction->setChecked(m_ShowScalarOpacityWidget);
   m_ShowTFGeneratorAction = new QAction("Show transfer function generator", this);
   m_ShowTFGeneratorAction->setCheckable(true);
   m_ShowTFGeneratorAction->setChecked(m_ShowTFGeneratorWidget);
 
   QMenu* menu = new QMenu(parent);
   menu->addAction(m_ScalarVisibilityAction);
   menu->addAction(m_Outline2DAction);
   //menu->addAction(m_LODAction);
   menu->addSeparator();
   menu->addAction(m_ShowTFGeneratorAction);
   menu->addAction(m_ShowScalarOpacityAction);
   menu->addAction(m_ShowColorAction);
   menu->addAction(m_ShowGradientOpacityAction);
 
   m_Controls.m_OptionsButton->setMenu(menu);
 
   m_Controls.m_TransferFunctionWidget->SetScalarLabel("Scalar value");
 
 //  const mitk::EnumerationProperty::EnumStringsContainerType& scalarStrings = scalarProp->GetEnumStrings();
 
 //  for (mitk::EnumerationProperty::EnumStringsContainerType::const_iterator it = scalarStrings.begin();
 //    it != scalarStrings.end(); ++it)
 //  {
 //    MITK_INFO << "ADding: " << it->first;
 //    m_Controls.m_ScalarModeComboBox->addItem(QString::fromStdString(it->first), it->second);
 //  }
 
   this->UpdateGUI();
 
   CreateConnections();
 }
 
 void QmitkUGVisualizationView::CreateConnections()
 {
   connect(m_Controls.m_ScalarModeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateRenderWindow()));
   connect(m_Controls.m_RepresentationComboBox, SIGNAL(activated(int)), this, SLOT(UpdateRenderWindow()));
   connect(m_Outline2DWidget, SIGNAL(toggled(bool)), this, SLOT(UpdateRenderWindow()));
   connect(m_ScalarVisibilityWidget, SIGNAL(toggled(bool)), this, SLOT(UpdateRenderWindow()));
   connect(m_Controls.m_TransferFunctionGeneratorWidget, SIGNAL(SignalUpdateCanvas()), m_Controls.m_TransferFunctionWidget, SLOT(OnUpdateCanvas()));
 
   connect(m_ShowColorAction, SIGNAL(triggered(bool)), this, SLOT(ShowColorWidget(bool)));
   connect(m_ShowGradientOpacityAction, SIGNAL(triggered(bool)), this, SLOT(ShowGradientOpacityWidget(bool)));
   connect(m_ShowScalarOpacityAction, SIGNAL(triggered(bool)), this, SLOT(ShowScalarOpacityWidget(bool)));
   connect(m_ShowTFGeneratorAction, SIGNAL(triggered(bool)), this, SLOT(ShowTFGeneratorWidget(bool)));
 }
 
 void QmitkUGVisualizationView::SetFocus()
 {
   m_Controls.m_OptionsButton->setFocus();
 }
 
 void QmitkUGVisualizationView::UpdateRenderWindow()
 {
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkUGVisualizationView::ShowTFGeneratorWidget(bool show)
 {
   m_ShowTFGeneratorWidget = show;
   UpdateEnablement();
 }
 
 void QmitkUGVisualizationView::ShowScalarOpacityWidget(bool show)
 {
   m_ShowScalarOpacityWidget = show;
   UpdateEnablement();
 }
 
 void QmitkUGVisualizationView::ShowColorWidget(bool show)
 {
   m_ShowColorWidget = show;
   UpdateEnablement();
 }
 
 void QmitkUGVisualizationView::ShowGradientOpacityWidget(bool show)
 {
   m_ShowGradientOpacityWidget = show;
   UpdateEnablement();
 }
 
 void QmitkUGVisualizationView::UpdateEnablement()
 {
   m_Controls.m_TransferFunctionGeneratorWidget->setVisible(m_ShowTFGeneratorWidget);
   m_Controls.m_TransferFunctionWidget->ShowScalarOpacityFunction(m_ShowScalarOpacityWidget);
   m_Controls.m_TransferFunctionWidget->ShowColorFunction(m_ShowColorWidget);
   m_Controls.m_TransferFunctionWidget->ShowGradientOpacityFunction(m_ShowGradientOpacityWidget);
 
   m_Controls.m_TransferFunctionGeneratorWidget->SetThresholdTabEnabled(m_ScalarVisibilityWidget->isChecked());
   m_Controls.m_TransferFunctionGeneratorWidget->SetBellTabEnabled(m_ScalarVisibilityWidget->isChecked());
   m_Controls.m_TransferFunctionWidget->SetScalarOpacityFunctionEnabled(m_ScalarVisibilityWidget->isChecked());
   m_Controls.m_TransferFunctionWidget->SetGradientOpacityFunctionEnabled(m_VolumeMode);
 }
 
 void QmitkUGVisualizationView::UpdateGUI()
 {
   bool enable = false;
 
-  mitk::DataNode* node = 0;
+  mitk::DataNode* node = nullptr;
   auto nodes = this->GetDataManagerSelection();
   if (!nodes.empty())
   {
     node = nodes.front();
 
     if (node)
     {
       // here we have a valid mitk::DataNode
 
       // a node itself is not very useful, we need its data item
       mitk::BaseData* data = node->GetData();
       if (data)
       {
         // test if this data item is an unstructured grid
         enable = dynamic_cast<mitk::UnstructuredGrid*>( data );
       }
     }
   }
 
   m_Controls.m_SelectedLabel->setVisible(enable);
   m_Controls.m_ErrorLabel->setVisible(!enable);
   m_Controls.m_ContainerWidget->setEnabled(enable);
   m_Controls.m_OptionsButton->setEnabled(enable);
 
   if (enable)
   {
     m_VolumeMode = false;
     node->GetBoolProperty("volumerendering", m_VolumeMode);
 
     m_Controls.m_SelectedLabel->setText(QString("Selected UG: ") + node->GetName().c_str());
 
     m_Controls.m_TransferFunctionGeneratorWidget->SetDataNode(node);
     m_Controls.m_TransferFunctionWidget->SetDataNode(node);
 
-    mitk::BoolProperty* outlineProp = 0;
+    mitk::BoolProperty* outlineProp = nullptr;
     node->GetProperty(outlineProp, "outline polygons");
     m_Outline2DWidget->SetProperty(outlineProp);
 
-    mitk::BoolProperty* scalarVisProp = 0;
+    mitk::BoolProperty* scalarVisProp = nullptr;
     node->GetProperty(scalarVisProp, "scalar visibility");
     m_ScalarVisibilityWidget->SetProperty(scalarVisProp);
 
-    mitk::VtkScalarModeProperty* scalarProp = 0;
+    mitk::VtkScalarModeProperty* scalarProp = nullptr;
     if (node->GetProperty(scalarProp, "scalar mode"))
     {
       m_Controls.m_ScalarModeComboBox->SetProperty(scalarProp);
     }
 
-    mitk::GridRepresentationProperty* gridRepProp = 0;
-    mitk::GridVolumeMapperProperty* gridVolumeProp = 0;
-    mitk::BoolProperty* volumeProp = 0;
+    mitk::GridRepresentationProperty* gridRepProp = nullptr;
+    mitk::GridVolumeMapperProperty* gridVolumeProp = nullptr;
+    mitk::BoolProperty* volumeProp = nullptr;
     node->GetProperty(gridRepProp, "grid representation");
     node->GetProperty(gridVolumeProp, "volumerendering.mapper");
     node->GetProperty(volumeProp, "volumerendering");
     m_Controls.m_RepresentationComboBox->SetProperty(gridRepProp, gridVolumeProp, volumeProp);
 
     if (m_VolumeModeObserver)
     {
       delete m_VolumeModeObserver;
-      m_VolumeModeObserver = 0;
+      m_VolumeModeObserver = nullptr;
     }
 
     if (volumeProp)
     {
       m_VolumeModeObserver = new UGVisVolumeObserver(volumeProp, this);
     }
   }
 
   UpdateEnablement();
 
 }
 
 
 void QmitkUGVisualizationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& /*nodes*/)
 {
   UpdateGUI();
 }
 
 
 
 
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/QmitkUltrasoundSupport.cpp b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/QmitkUltrasoundSupport.cpp
index 4595f43540..fc71ca0af0 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/QmitkUltrasoundSupport.cpp
+++ b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/QmitkUltrasoundSupport.cpp
@@ -1,587 +1,587 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 //Mitk
 #include <mitkDataNode.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkIRenderingManager.h>
 #include <mitkImageGenerator.h>
 
 // Qmitk
 #include "QmitkUltrasoundSupport.h"
 
 // Qt
 #include <QMessageBox>
 #include <QSettings>
 #include <QTimer>
 
 // Ultrasound
 #include "mitkUSDevice.h"
 #include "QmitkUSAbstractCustomWidget.h"
 
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include "usServiceReference.h"
 #include "internal/org_mitk_gui_qt_ultrasound_Activator.h"
 
 const std::string QmitkUltrasoundSupport::VIEW_ID = "org.mitk.views.ultrasoundsupport";
 
 QmitkUltrasoundSupport::QmitkUltrasoundSupport()
-  : m_Controls(nullptr), m_ControlCustomWidget(0), m_ControlBModeWidget(0),
-  m_ControlProbesWidget(0), m_ImageAlreadySetToNode(false),
+  : m_Controls(nullptr), m_ControlCustomWidget(nullptr), m_ControlBModeWidget(nullptr),
+  m_ControlProbesWidget(nullptr), m_ImageAlreadySetToNode(false),
   m_CurrentImageWidth(0), m_CurrentImageHeight(0)
 {
   ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
 
   if (pluginContext)
   {
     // to be notified about service event of an USDevice
     pluginContext->connectServiceListener(this, "OnDeviceServiceEvent",
       QString::fromStdString("(" + us::ServiceConstants::OBJECTCLASS() + "=" + us_service_interface_iid<mitk::USDevice>() + ")"));
   }
 }
 
 QmitkUltrasoundSupport::~QmitkUltrasoundSupport()
 {
   try
   {
     StoreUISettings();
     StopTimers();
 
     // Get all active devicesand deactivate them to prevent freeze
     std::vector<mitk::USDevice*> devices = this->m_Controls->m_ActiveVideoDevices->GetAllServices<mitk::USDevice>();
     for (size_t i = 0; i < devices.size(); i++)
     {
       mitk::USDevice::Pointer device = devices[i];
       if (device.IsNotNull() && device->GetIsActive())
       {
         device->Deactivate();
         device->Disconnect();
       }
     }
   }
   catch (std::exception &e)
   {
     MITK_ERROR << "Exception during call of destructor! Message: " << e.what();
   }
 }
 
 void QmitkUltrasoundSupport::SetFocus()
 {
 }
 
 void QmitkUltrasoundSupport::CreateQtPartControl(QWidget *parent)
 {
   //initialize timers
   m_UpdateTimer = new QTimer(this);
   m_RenderingTimer2d = new QTimer(this);
   m_RenderingTimer3d = new QTimer(this);
 
   // build up qt view, unless already done
   if (!m_Controls)
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::UltrasoundSupportControls;
 
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls->setupUi(parent);
 
     //load persistence data before connecting slots (so no slots are called in this phase...)
     LoadUISettings();
 
     //connect signals and slots...
     connect(m_Controls->m_DeviceManagerWidget, SIGNAL(NewDeviceButtonClicked()), this, SLOT(OnClickedAddNewDevice())); // Change Widget Visibilities
     connect(m_Controls->m_DeviceManagerWidget, SIGNAL(NewDeviceButtonClicked()), this->m_Controls->m_NewVideoDeviceWidget, SLOT(CreateNewDevice())); // Init NewDeviceWidget
     connect(m_Controls->m_ActiveVideoDevices, SIGNAL(ServiceSelectionChanged(us::ServiceReferenceU)), this, SLOT(OnChangedActiveDevice()));
     connect(m_Controls->m_RunImageTimer, SIGNAL(clicked()), this, SLOT(OnChangedActiveDevice()));
     connect(m_Controls->m_ShowImageStream, SIGNAL(clicked()), this, SLOT(OnChangedActiveDevice()));
     connect(m_Controls->m_NewVideoDeviceWidget, SIGNAL(Finished()), this, SLOT(OnNewDeviceWidgetDone())); // After NewDeviceWidget finished editing
     connect(m_Controls->m_FrameRatePipeline, SIGNAL(valueChanged(int)), this, SLOT(OnChangedFramerateLimit()));
     connect(m_Controls->m_FrameRate2d, SIGNAL(valueChanged(int)), this, SLOT(OnChangedFramerateLimit()));
     connect(m_Controls->m_FrameRate3d, SIGNAL(valueChanged(int)), this, SLOT(OnChangedFramerateLimit()));
     connect(m_Controls->m_FreezeButton, SIGNAL(clicked()), this, SLOT(OnClickedFreezeButton()));
     connect(m_UpdateTimer, SIGNAL(timeout()), this, SLOT(UpdateImage()));
     connect(m_RenderingTimer2d, SIGNAL(timeout()), this, SLOT(RenderImage2d()));
     connect(m_RenderingTimer3d, SIGNAL(timeout()), this, SLOT(RenderImage3d()));
     connect(m_Controls->m_Update2DView, SIGNAL(clicked()), this, SLOT(StartTimers()));
     connect(m_Controls->m_Update3DView, SIGNAL(clicked()), this, SLOT(StartTimers()));
     connect(m_Controls->m_DeviceManagerWidget, SIGNAL(EditDeviceButtonClicked(mitk::USDevice::Pointer)), this, SLOT(OnClickedEditDevice())); //Change Widget Visibilities
     connect(m_Controls->m_DeviceManagerWidget, SIGNAL(EditDeviceButtonClicked(mitk::USDevice::Pointer)), this->m_Controls->m_NewVideoDeviceWidget, SLOT(EditDevice(mitk::USDevice::Pointer)));
 
     connect(m_Controls->m_SetXPoint1, SIGNAL(clicked()), this, SLOT(SetXPoint1()));
     connect(m_Controls->m_SetXPoint2, SIGNAL(clicked()), this, SLOT(SetXPoint2()));
     connect(m_Controls->m_SetYPoint1, SIGNAL(clicked()), this, SLOT(SetYPoint1()));
     connect(m_Controls->m_SetYPoint2, SIGNAL(clicked()), this, SLOT(SetYPoint2()));
     connect(m_Controls->m_SaveSpacing, SIGNAL(clicked()), this, SLOT(WriteSpacingToDevice()));
 
 
     // Initializations
     m_Controls->m_NewVideoDeviceWidget->setVisible(false);
     std::string filter = "(&(" + us::ServiceConstants::OBJECTCLASS() + "="
       + "org.mitk.services.UltrasoundDevice)("
       + mitk::USDevice::GetPropertyKeys().US_PROPKEY_ISACTIVE + "=true))";
     m_Controls->m_ActiveVideoDevices->Initialize<mitk::USDevice>(
       mitk::USDevice::GetPropertyKeys().US_PROPKEY_LABEL, filter);
     m_Controls->m_ActiveVideoDevices->SetAutomaticallySelectFirstEntry(true);
     m_FrameCounterPipeline = 0;
     m_FrameCounter2d = 0;
     m_FrameCounter3d = 0;
 
     m_Controls->tabWidget->setTabEnabled(1, false);
   }
 }
 
 void QmitkUltrasoundSupport::OnClickedAddNewDevice()
 {
   m_Controls->m_NewVideoDeviceWidget->setVisible(true);
   m_Controls->m_DeviceManagerWidget->setVisible(false);
   m_Controls->m_Headline->setText("Add New Video Device:");
   m_Controls->m_WidgetActiveDevices->setVisible(false);
 }
 
 void QmitkUltrasoundSupport::OnClickedEditDevice()
 {
   m_Controls->m_NewVideoDeviceWidget->setVisible(true);
   m_Controls->m_DeviceManagerWidget->setVisible(false);
   m_Controls->m_WidgetActiveDevices->setVisible(false);
   m_Controls->m_Headline->setText("Edit Video Device:");
 }
 
 void QmitkUltrasoundSupport::UpdateImage()
 {
   //Update device
   m_Device->Modified();
   m_Device->Update();
 
 
   //Only update the view if the image is shown
   if (m_Controls->m_ShowImageStream->isChecked())
   {
     //Update data nodes
     for (size_t i = 0; i < m_AmountOfOutputs; i++)
     {
       mitk::Image::Pointer curOutput = m_Device->GetOutput(i);
       if (curOutput->IsEmpty())
       {
         m_Node.at(i)->SetName("No Data received yet ...");
         //create a noise image for correct initialization of level window, etc.
         mitk::Image::Pointer randomImage = mitk::ImageGenerator::GenerateRandomImage<float>(32, 32, 1, 1, 1, 1, 1, 255, 0);
         m_Node.at(i)->SetData(randomImage);
         curOutput->SetGeometry(randomImage->GetGeometry());
       }
       else
       {
         std::stringstream nodeName;
         nodeName << "US Viewing Stream - Image " << i;
         m_Node.at(i)->SetName(nodeName.str());
         m_Node.at(i)->SetData(curOutput);
         m_Node.at(i)->Modified();
       }
       // if the geometry changed: reinitialize the ultrasound image
       if ((i==0) && (m_OldGeometry.IsNotNull()) &&
-        (curOutput->GetGeometry() != NULL) &&
+        (curOutput->GetGeometry() != nullptr) &&
         (!mitk::Equal(*(m_OldGeometry.GetPointer()), *(curOutput->GetGeometry()), 0.0001, false))
         )
       {
         mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
-        if ((renderWindow != NULL) && (curOutput->GetTimeGeometry()->IsValid()) && (m_Controls->m_ShowImageStream->isChecked()))
+        if ((renderWindow != nullptr) && (curOutput->GetTimeGeometry()->IsValid()) && (m_Controls->m_ShowImageStream->isChecked()))
         {
           renderWindow->GetRenderingManager()->InitializeViews(
             curOutput->GetGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
           renderWindow->GetRenderingManager()->RequestUpdateAll();
         }
         m_CurrentImageWidth = curOutput->GetDimension(0);
         m_CurrentImageHeight = curOutput->GetDimension(1);
         m_OldGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(curOutput->GetGeometry());
       }
     }
   }
 
 
 
   //Update frame counter
   m_FrameCounterPipeline++;
   if (m_FrameCounterPipeline >0)
   {
     //compute framerate of pipeline update
     int nMilliseconds = m_Clock.restart();
     int fps = 1000.0 / nMilliseconds;
     m_FPSPipeline = fps;
     m_FrameCounterPipeline = 0;
 
     //display lowest framerate in UI
     int lowestFPS = m_FPSPipeline;
     if (m_Controls->m_Update2DView->isChecked() && (m_FPS2d < lowestFPS)) { lowestFPS = m_FPS2d; }
     if (m_Controls->m_Update3DView->isChecked() && (m_FPS3d < lowestFPS)) { lowestFPS = m_FPS3d; }
     m_Controls->m_FramerateLabel->setText("Current Framerate: " + QString::number(lowestFPS) + " FPS");
   }
 }
 
 void QmitkUltrasoundSupport::RenderImage2d()
 {
   if (!m_Controls->m_Update2DView->isChecked())
     return;
 
   this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
   m_FrameCounter2d++;
   if (m_FrameCounter2d >0)
   {
     //compute framerate of 2d render window update
     int nMilliseconds = m_Clock2d.restart();
     int fps = 1000.0f / (nMilliseconds);
     m_FPS2d = fps;
     m_FrameCounter2d = 0;
   }
 }
 
 void QmitkUltrasoundSupport::RenderImage3d()
 {
   if (!m_Controls->m_Update3DView->isChecked())
     return;
 
   this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS);
   m_FrameCounter3d++;
   if (m_FrameCounter3d >0)
   {
     //compute framerate of 2d render window update
     int nMilliseconds = m_Clock3d.restart();
     int fps = 1000.0f / (nMilliseconds);
     m_FPS3d = fps;
     m_FrameCounter3d = 0;
   }
 }
 
 void QmitkUltrasoundSupport::OnChangedFramerateLimit()
 {
   StopTimers();
   int intervalPipeline = (1000 / m_Controls->m_FrameRatePipeline->value());
   int interval2D = (1000 / m_Controls->m_FrameRate2d->value());
   int interval3D = (1000 / m_Controls->m_FrameRate3d->value());
   SetTimerIntervals(intervalPipeline, interval2D, interval3D);
   StartTimers();
 }
 
 void QmitkUltrasoundSupport::OnClickedFreezeButton()
 {
   if (m_Device.IsNull())
   {
     MITK_WARN("UltrasoundSupport") << "Freeze button clicked though no device is selected.";
     return;
   }
   if (m_Device->GetIsFreezed())
   {
     m_Device->SetIsFreezed(false);
     m_Controls->m_FreezeButton->setText("Freeze");
   }
   else
   {
     m_Device->SetIsFreezed(true);
     m_Controls->m_FreezeButton->setText("Start Viewing Again");
   }
 }
 
 void QmitkUltrasoundSupport::OnChangedActiveDevice()
 {
   //clean up and stop timer
   StopTimers();
   this->RemoveControlWidgets();
   for (size_t j = 0; j < m_Node.size(); j++)
   {
     this->GetDataStorage()->Remove(m_Node.at(j));
     m_Node.at(j)->ReleaseData();
   }
   m_Node.clear();
   //get current device, abort if it is invalid
   m_Device = m_Controls->m_ActiveVideoDevices->GetSelectedService<mitk::USDevice>();
   if (m_Device.IsNull())
   {
     m_Controls->tabWidget->setTabEnabled(1, false);
     return;
   }
   m_AmountOfOutputs = m_Device->GetNumberOfIndexedOutputs();
   // clear data storage, create new nodes and add
   for (size_t i = 0; i < m_AmountOfOutputs; i++)
   {
     mitk::DataNode::Pointer currentNode = mitk::DataNode::New();
     std::stringstream nodeName;
     nodeName << "US Viewing Stream - Image " << i;
     currentNode->SetName(nodeName.str());
     //create a dummy image (gray values 0..255) for correct initialization of level window, etc.
     mitk::Image::Pointer dummyImage = mitk::ImageGenerator::GenerateRandomImage<float>(100, 100, 1, 1, 1, 1, 1, 255, 0);
     currentNode->SetData(dummyImage);
     m_OldGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(dummyImage->GetGeometry());
     m_Node.push_back(currentNode);
     //show node if the option is enabled
     if (m_Controls->m_ShowImageStream->isChecked())
     {
         this->GetDataStorage()->Add(m_Node.at(i));
     }
   }
 
   //create the widgets for this device and enable the widget tab
   this->CreateControlWidgets();
   m_Controls->tabWidget->setTabEnabled(1, true);
 
   //start timer
   if (m_Controls->m_RunImageTimer->isChecked())
   {
     int intervalPipeline = (1000 / m_Controls->m_FrameRatePipeline->value());
     int interval2D = (1000 / m_Controls->m_FrameRate2d->value());
     int interval3D = (1000 / m_Controls->m_FrameRate3d->value());
     SetTimerIntervals(intervalPipeline, interval2D, interval3D);
     StartTimers();
     m_Controls->m_TimerWidget->setEnabled(true);
   }
   else
   {
     m_Controls->m_TimerWidget->setEnabled(false);
   }
 }
 
 void QmitkUltrasoundSupport::OnNewDeviceWidgetDone()
 {
   m_Controls->m_NewVideoDeviceWidget->setVisible(false);
   m_Controls->m_DeviceManagerWidget->setVisible(true);
   m_Controls->m_Headline->setText("Ultrasound Devices:");
   m_Controls->m_WidgetActiveDevices->setVisible(true);
 }
 
 void QmitkUltrasoundSupport::CreateControlWidgets()
 {
   m_ControlProbesWidget = new QmitkUSControlsProbesWidget(m_Device->GetControlInterfaceProbes(), m_Controls->m_ToolBoxControlWidgets);
   m_Controls->probesWidgetContainer->addWidget(m_ControlProbesWidget);
 
   // create b mode widget for current device
   m_ControlBModeWidget = new QmitkUSControlsBModeWidget(m_Device->GetControlInterfaceBMode(), m_Controls->m_ToolBoxControlWidgets);
   m_Controls->m_ToolBoxControlWidgets->addItem(m_ControlBModeWidget, "B Mode Controls");
   if (!m_Device->GetControlInterfaceBMode())
   {
     m_Controls->m_ToolBoxControlWidgets->setItemEnabled(m_Controls->m_ToolBoxControlWidgets->count() - 1, false);
   }
 
   // create doppler widget for current device
   m_ControlDopplerWidget = new QmitkUSControlsDopplerWidget(m_Device->GetControlInterfaceDoppler(), m_Controls->m_ToolBoxControlWidgets);
   m_Controls->m_ToolBoxControlWidgets->addItem(m_ControlDopplerWidget, "Doppler Controls");
   if (!m_Device->GetControlInterfaceDoppler())
   {
     m_Controls->m_ToolBoxControlWidgets->setItemEnabled(m_Controls->m_ToolBoxControlWidgets->count() - 1, false);
   }
 
   ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
   if (pluginContext)
   {
     std::string filter = "(org.mitk.services.UltrasoundCustomWidget.deviceClass=" + m_Device->GetDeviceClass() + ")";
     //Hint: The following three lines are a workaround. Till now the only US video device was an USVideoDevice.
     // And everything worked fine. However, the ultrasound image source can be an USIGTLDevice (IGTL Client), as well.
     // This second option wasn't considered yet. So, the custom control widget will work correctly only, if
     // the filter declares the device class as org.mitk.modules.us.USVideoDevice. Another option, how to deal with
     // the two possible ultrasound image devices would be to change the returned string of the method
     // std::string QmitkUSControlsCustomVideoDeviceWidget::GetDeviceClass(), which always returns the string
     // org.mitk.modules.us.USVideoDevice of the USVideoDevice class. If there is a possility to change the
     // returned string dynamically between "IGTL Client" and "org.mitk.modules.us.USVideoDevice" the following
     // three lines will not be needed.
     if (m_Device->GetDeviceClass().compare("IGTL Client") == 0)
     {
       filter = "(org.mitk.services.UltrasoundCustomWidget.deviceClass=" + mitk::USVideoDevice::GetDeviceClassStatic() + ")";
     }
 
     QString interfaceName = QString::fromStdString(us_service_interface_iid<QmitkUSAbstractCustomWidget>());
     m_CustomWidgetServiceReference = pluginContext->getServiceReferences(interfaceName, QString::fromStdString(filter));
 
     if (m_CustomWidgetServiceReference.size() > 0)
     {
       m_ControlCustomWidget = pluginContext->getService<QmitkUSAbstractCustomWidget>
         (m_CustomWidgetServiceReference.at(0))->CloneForQt(m_Controls->tab2);
       m_ControlCustomWidget->SetDevice(m_Device);
       m_Controls->m_ToolBoxControlWidgets->addItem(m_ControlCustomWidget, "Custom Controls");
     }
     else
     {
       m_Controls->m_ToolBoxControlWidgets->addItem(new QWidget(m_Controls->m_ToolBoxControlWidgets), "Custom Controls");
       m_Controls->m_ToolBoxControlWidgets->setItemEnabled(m_Controls->m_ToolBoxControlWidgets->count() - 1, false);
     }
   }
 
   // select first enabled control widget
   for (int n = 0; n < m_Controls->m_ToolBoxControlWidgets->count(); ++n)
   {
     if (m_Controls->m_ToolBoxControlWidgets->isItemEnabled(n))
     {
       m_Controls->m_ToolBoxControlWidgets->setCurrentIndex(n);
       break;
     }
   }
 }
 
 void QmitkUltrasoundSupport::RemoveControlWidgets()
 {
   if (!m_ControlProbesWidget) { return; } //widgets do not exist... nothing to do
 
   // remove all control widgets from the tool box widget
   while (m_Controls->m_ToolBoxControlWidgets->count() > 0)
   {
     m_Controls->m_ToolBoxControlWidgets->removeItem(0);
   }
 
   // remove probes widget (which is not part of the tool box widget)
   m_Controls->probesWidgetContainer->removeWidget(m_ControlProbesWidget);
   delete m_ControlProbesWidget;
-  m_ControlProbesWidget = 0;
+  m_ControlProbesWidget = nullptr;
 
   delete m_ControlBModeWidget;
-  m_ControlBModeWidget = 0;
+  m_ControlBModeWidget = nullptr;
 
   delete m_ControlDopplerWidget;
-  m_ControlDopplerWidget = 0;
+  m_ControlDopplerWidget = nullptr;
 
   // delete custom widget if it is present
   if (m_ControlCustomWidget)
   {
     ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
-    delete m_ControlCustomWidget; m_ControlCustomWidget = 0;
+    delete m_ControlCustomWidget; m_ControlCustomWidget = nullptr;
     if (m_CustomWidgetServiceReference.size() > 0)
     {
       pluginContext->ungetService(m_CustomWidgetServiceReference.at(0));
     }
   }
 }
 
 void QmitkUltrasoundSupport::OnDeviceServiceEvent(const ctkServiceEvent event)
 {
   if (m_Device.IsNull() || event.getType() != ctkServiceEvent::MODIFIED)
   {
     return;
   }
 
   ctkServiceReference service = event.getServiceReference();
 
   if (m_Device->GetManufacturer() != service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_MANUFACTURER)).toString().toStdString()
     && m_Device->GetName() != service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_NAME)).toString().toStdString())
   {
     return;
   }
 
   if (!m_Device->GetIsActive() && m_UpdateTimer->isActive())
   {
     StopTimers();
   }
 
   if (m_CurrentDynamicRange != service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DYNAMIC_RANGE)).toDouble())
   {
     m_CurrentDynamicRange = service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DYNAMIC_RANGE)).toDouble();
 
     // update level window for the current dynamic range
     mitk::LevelWindow levelWindow;
     m_Node.at(0)->GetLevelWindow(levelWindow);
     levelWindow.SetAuto(m_curOutput.at(0), true, true);
     m_Node.at(0)->SetLevelWindow(levelWindow);
   }
 }
 
 void QmitkUltrasoundSupport::StoreUISettings()
 {
   QSettings settings;
   settings.beginGroup(QString::fromStdString(VIEW_ID));
   settings.setValue("DisplayImage", QVariant(m_Controls->m_ShowImageStream->isChecked()));
   settings.setValue("RunImageTimer", QVariant(m_Controls->m_RunImageTimer->isChecked()));
   settings.setValue("Update2DView", QVariant(m_Controls->m_Update2DView->isChecked()));
   settings.setValue("Update3DView", QVariant(m_Controls->m_Update3DView->isChecked()));
   settings.setValue("UpdateRatePipeline", QVariant(m_Controls->m_FrameRatePipeline->value()));
   settings.setValue("UpdateRate2d", QVariant(m_Controls->m_FrameRate2d->value()));
   settings.setValue("UpdateRate3d", QVariant(m_Controls->m_FrameRate3d->value()));
   settings.endGroup();
 }
 
 void QmitkUltrasoundSupport::LoadUISettings()
 {
   QSettings settings;
   settings.beginGroup(QString::fromStdString(VIEW_ID));
   m_Controls->m_ShowImageStream->setChecked(settings.value("DisplayImage", true).toBool());
   m_Controls->m_RunImageTimer->setChecked(settings.value("RunImageTimer", true).toBool());
   m_Controls->m_Update2DView->setChecked(settings.value("Update2DView", true).toBool());
   m_Controls->m_Update3DView->setChecked(settings.value("Update3DView", true).toBool());
   m_Controls->m_FrameRatePipeline->setValue(settings.value("UpdateRatePipeline", 50).toInt());
   m_Controls->m_FrameRate2d->setValue(settings.value("UpdateRate2d", 20).toInt());
   m_Controls->m_FrameRate3d->setValue(settings.value("UpdateRate3d", 5).toInt());
   settings.endGroup();
 }
 
 void QmitkUltrasoundSupport::StartTimers()
 {
   m_Clock.start();
   m_UpdateTimer->start();
   if (m_Controls->m_Update2DView->isChecked()) { m_RenderingTimer2d->start(); }
   if (m_Controls->m_Update3DView->isChecked()) { m_RenderingTimer3d->start(); }
 }
 
 void QmitkUltrasoundSupport::StopTimers()
 {
   m_UpdateTimer->stop();
   m_RenderingTimer2d->stop();
   m_RenderingTimer3d->stop();
 }
 
 void QmitkUltrasoundSupport::SetTimerIntervals(int intervalPipeline, int interval2D, int interval3D)
 {
   m_UpdateTimer->setInterval(intervalPipeline);
   m_RenderingTimer2d->setInterval(interval2D);
   m_RenderingTimer3d->setInterval(interval3D);
 }
 
 
 /* Spacing methods */
 void QmitkUltrasoundSupport::SetXPoint1()
 {
   m_Xpoint1 = this->GetRenderWindowPart()->GetSelectedPosition();
   m_XSpacing = ComputeSpacing(m_Xpoint1, m_Xpoint2, m_Controls->m_XDistance->value());
   m_Controls->m_XSpacing->setText(QString("X Spacing: ") + QString::number(m_XSpacing) + " mm");
 }
 void QmitkUltrasoundSupport::SetXPoint2()
 {
   m_Xpoint2 = this->GetRenderWindowPart()->GetSelectedPosition();
   m_XSpacing = ComputeSpacing(m_Xpoint1, m_Xpoint2, m_Controls->m_XDistance->value());
   m_Controls->m_XSpacing->setText(QString("X Spacing: ") + QString::number(m_XSpacing) + " mm");
 }
 void QmitkUltrasoundSupport::SetYPoint1()
 {
   m_Ypoint1 = this->GetRenderWindowPart()->GetSelectedPosition();
   m_YSpacing = ComputeSpacing(m_Ypoint1, m_Ypoint2, m_Controls->m_YDistance->value());
   m_Controls->m_YSpacing->setText(QString("Y Spacing: ") + QString::number(m_YSpacing) + " mm");
 }
 void QmitkUltrasoundSupport::SetYPoint2()
 {
   m_Ypoint2 = this->GetRenderWindowPart()->GetSelectedPosition();
   m_YSpacing = ComputeSpacing(m_Ypoint1, m_Ypoint2, m_Controls->m_YDistance->value());
   m_Controls->m_YSpacing->setText(QString("Y Spacing: ") + QString::number(m_YSpacing) + " mm");
 }
 void QmitkUltrasoundSupport::WriteSpacingToDevice()
 {
   this->m_Device->SetSpacing(m_XSpacing, m_YSpacing);
   MITK_INFO << "Spacing saved to device object, please save device data to permanently store the spacing.";
 }
 double QmitkUltrasoundSupport::ComputeSpacing(mitk::Point3D p1, mitk::Point3D p2, double distance)
 {
   double spacing = 0;
   double pointDistance = p1.EuclideanDistanceTo(p2);
   spacing = distance / pointDistance;
   return spacing;
 }
 
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/org_mitk_gui_qt_ultrasound_Activator.cpp b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/org_mitk_gui_qt_ultrasound_Activator.cpp
index bd24bbef26..16bfb50ad9 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/org_mitk_gui_qt_ultrasound_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/org_mitk_gui_qt_ultrasound_Activator.cpp
@@ -1,44 +1,44 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.#include "QmitkUltrasoundSupport.h"
 
 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 "org_mitk_gui_qt_ultrasound_Activator.h"
 #include "QmitkUltrasoundSupport.h"
 
 namespace mitk {
 
-ctkPluginContext* org_mitk_gui_qt_ultrasound_Activator::m_Context = 0;
+ctkPluginContext* org_mitk_gui_qt_ultrasound_Activator::m_Context = nullptr;
 
 void org_mitk_gui_qt_ultrasound_Activator::start(ctkPluginContext* context)
 {
   m_Context = context;
 
   BERRY_REGISTER_EXTENSION_CLASS(QmitkUltrasoundSupport, context)
 }
 
 void org_mitk_gui_qt_ultrasound_Activator::stop(ctkPluginContext* context)
 {
-  m_Context = 0;
+  m_Context = nullptr;
 
   Q_UNUSED(context)
 }
 
 ctkPluginContext *org_mitk_gui_qt_ultrasound_Activator::GetContext()
 {
   return m_Context;
 }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp b/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp
index d2cfc1749a..fb9d696c9e 100755
--- a/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp
+++ b/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp
@@ -1,349 +1,349 @@
 /*===================================================================
 
 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 "QmitkVolumeVisualizationView.h"
 
 #include <QComboBox>
 
 #include <vtkVersionMacros.h>
 #include <vtkSmartVolumeMapper.h>
 
 #include <berryISelectionProvider.h>
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 //#include <berryISelectionService.h>
 #include <mitkDataNodeObject.h>
 
 #include <mitkProperties.h>
 #include <mitkNodePredicateDataType.h>
 
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 #include <mitkTransferFunctionInitializer.h>
 #include "mitkHistogramGenerator.h"
 #include "QmitkPiecewiseFunctionCanvas.h"
 #include "QmitkColorTransferFunctionCanvas.h"
 
 #include "mitkBaseRenderer.h"
 
 #include "mitkVtkVolumeRenderingProperty.h"
 
 #include <mitkIRenderingManager.h>
 
 #include <QToolTip>
 
 const std::string QmitkVolumeVisualizationView::VIEW_ID =
 "org.mitk.views.volumevisualization";
 
 enum {DEFAULT_RENDERMODE = 0, RAYCAST_RENDERMODE = 1, GPU_RENDERMODE = 2};
 
 QmitkVolumeVisualizationView::QmitkVolumeVisualizationView()
 : QmitkAbstractView(),
   m_Controls(nullptr)
 {
 }
 
 QmitkVolumeVisualizationView::~QmitkVolumeVisualizationView()
 {
 }
 
 void QmitkVolumeVisualizationView::CreateQtPartControl(QWidget* parent)
 {
 
   if (!m_Controls)
   {
     m_Controls = new Ui::QmitkVolumeVisualizationViewControls;
     m_Controls->setupUi(parent);
 
     // Fill the tf presets in the generator widget
     std::vector<std::string> names;
     mitk::TransferFunctionInitializer::GetPresetNames(names);
     for (std::vector<std::string>::const_iterator it = names.begin();
          it != names.end(); ++it)
     {
       m_Controls->m_TransferFunctionGeneratorWidget->AddPreset(QString::fromStdString(*it));
     }
     
     // see enum in vtkSmartVolumeMapper
     m_Controls->m_RenderMode->addItem("Default");
     m_Controls->m_RenderMode->addItem("RayCast");
     m_Controls->m_RenderMode->addItem("GPU");
 
     // see vtkVolumeMapper::BlendModes
     m_Controls->m_BlendMode->addItem("Comp");
     m_Controls->m_BlendMode->addItem("Max");
     m_Controls->m_BlendMode->addItem("Min");
     m_Controls->m_BlendMode->addItem("Avg");
     m_Controls->m_BlendMode->addItem("Add");
 
     connect( m_Controls->m_EnableRenderingCB, SIGNAL( toggled(bool) ),this, SLOT( OnEnableRendering(bool) ));
     connect(m_Controls->m_RenderMode, SIGNAL(activated(int)), this, SLOT(OnRenderMode(int)));
     connect(m_Controls->m_BlendMode, SIGNAL(activated(int)), this, SLOT(OnBlendMode(int)));
 
     connect( m_Controls->m_TransferFunctionGeneratorWidget, SIGNAL( SignalUpdateCanvas( ) ),   m_Controls->m_TransferFunctionWidget, SLOT( OnUpdateCanvas( ) ) );
     connect( m_Controls->m_TransferFunctionGeneratorWidget, SIGNAL(SignalTransferFunctionModeChanged(int)), SLOT(OnMitkInternalPreset(int)));
 
     m_Controls->m_EnableRenderingCB->setEnabled(false);
     m_Controls->m_BlendMode->setEnabled(false);
     m_Controls->m_RenderMode->setEnabled(false);
     m_Controls->m_TransferFunctionWidget->setEnabled(false);
     m_Controls->m_TransferFunctionGeneratorWidget->setEnabled(false);
 
     m_Controls->m_SelectedImageLabel->hide();
     m_Controls->m_ErrorImageLabel->hide();
   }
 }
 
 void QmitkVolumeVisualizationView::OnMitkInternalPreset( int mode )
 {
   if (m_SelectedNode.IsExpired()) return;
 
   auto node = m_SelectedNode.Lock();
   mitk::TransferFunctionProperty::Pointer transferFuncProp;
   if (node->GetProperty(transferFuncProp, "TransferFunction"))
   {
     //first item is only information
     if( --mode == -1 )
       return;
 
     // -- Creat new TransferFunction
     mitk::TransferFunctionInitializer::Pointer tfInit = mitk::TransferFunctionInitializer::New(transferFuncProp->GetValue());
     tfInit->SetTransferFunctionMode(mode);
     RequestRenderWindowUpdate();
     m_Controls->m_TransferFunctionWidget->OnUpdateCanvas();
   }
 }
 
 
 void QmitkVolumeVisualizationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   bool weHadAnImageButItsNotThreeDeeOrFourDee = false;
 
   mitk::DataNode::Pointer node;
 
   for (mitk::DataNode::Pointer currentNode: nodes)
   {
     if( currentNode.IsNotNull() && dynamic_cast<mitk::Image*>(currentNode->GetData()) )
     {
       if( dynamic_cast<mitk::Image*>(currentNode->GetData())->GetDimension()>=3 )
       {
         if (node.IsNull())
         {
           node = currentNode;
         }
       }
       else
       {
         weHadAnImageButItsNotThreeDeeOrFourDee = true;
       }
     }
   }
 
   if( node.IsNotNull() )
   {
     m_Controls->m_NoSelectedImageLabel->hide();
     m_Controls->m_ErrorImageLabel->hide();
     m_Controls->m_SelectedImageLabel->show();
 
     std::string  infoText;
 
     if (node->GetName().empty())
       infoText = std::string("Selected Image: [currently selected image has no name]");
     else
       infoText = std::string("Selected Image: ") + node->GetName();
 
     m_Controls->m_SelectedImageLabel->setText( QString( infoText.c_str() ) );
 
     m_SelectedNode = node;
   }
   else
   {
     if(weHadAnImageButItsNotThreeDeeOrFourDee)
     {
       m_Controls->m_NoSelectedImageLabel->hide();
       m_Controls->m_ErrorImageLabel->show();
       std::string  infoText;
       infoText = std::string("only 3D or 4D images are supported");
       m_Controls->m_ErrorImageLabel->setText( QString( infoText.c_str() ) );
     }
     else
     {
       m_Controls->m_SelectedImageLabel->hide();
       m_Controls->m_ErrorImageLabel->hide();
       m_Controls->m_NoSelectedImageLabel->show();
     }
 
     m_SelectedNode = nullptr;
   }
 
   UpdateInterface();
 }
 
 
 void QmitkVolumeVisualizationView::UpdateInterface()
 {
   if(m_SelectedNode.IsExpired())
   {
     // turnoff all
     m_Controls->m_EnableRenderingCB->setChecked(false);
     m_Controls->m_EnableRenderingCB->setEnabled(false);
 
     m_Controls->m_BlendMode->setCurrentIndex(0);
     m_Controls->m_BlendMode->setEnabled(false);
 
     m_Controls->m_RenderMode->setCurrentIndex(0);
     m_Controls->m_RenderMode->setEnabled(false);
 
-    m_Controls->m_TransferFunctionWidget->SetDataNode(0);
+    m_Controls->m_TransferFunctionWidget->SetDataNode(nullptr);
     m_Controls->m_TransferFunctionWidget->setEnabled(false);
 
-    m_Controls->m_TransferFunctionGeneratorWidget->SetDataNode(0);
+    m_Controls->m_TransferFunctionGeneratorWidget->SetDataNode(nullptr);
     m_Controls->m_TransferFunctionGeneratorWidget->setEnabled(false);
     return;
   }
 
   bool enabled = false;
   auto selectedNode = m_SelectedNode.Lock();
 
   selectedNode->GetBoolProperty("volumerendering",enabled);
   m_Controls->m_EnableRenderingCB->setEnabled(true);
   m_Controls->m_EnableRenderingCB->setChecked(enabled);
 
   if(!enabled)
   {
     // turnoff all except volumerendering checkbox
     m_Controls->m_BlendMode->setCurrentIndex(0);
     m_Controls->m_BlendMode->setEnabled(false);
 
     m_Controls->m_RenderMode->setCurrentIndex(0);
     m_Controls->m_RenderMode->setEnabled(false);
 
-    m_Controls->m_TransferFunctionWidget->SetDataNode(0);
+    m_Controls->m_TransferFunctionWidget->SetDataNode(nullptr);
     m_Controls->m_TransferFunctionWidget->setEnabled(false);
 
-    m_Controls->m_TransferFunctionGeneratorWidget->SetDataNode(0);
+    m_Controls->m_TransferFunctionGeneratorWidget->SetDataNode(nullptr);
     m_Controls->m_TransferFunctionGeneratorWidget->setEnabled(false);
     return;
   }
 
   // otherwise we can activate em all
   m_Controls->m_BlendMode->setEnabled(true);
   m_Controls->m_RenderMode->setEnabled(true);
 
   // Determine Combo Box mode
   {
     bool usegpu=false;
     bool useray=false;
     bool usemip=false;
     selectedNode->GetBoolProperty("volumerendering.usegpu",usegpu);
     selectedNode->GetBoolProperty("volumerendering.useray",useray);
     selectedNode->GetBoolProperty("volumerendering.usemip",usemip);
           
     int blendMode;
     if (selectedNode->GetIntProperty("volumerendering.blendmode", blendMode))
       m_Controls->m_BlendMode->setCurrentIndex(blendMode);
 
     if (usemip)
       m_Controls->m_BlendMode->setCurrentIndex(vtkVolumeMapper::MAXIMUM_INTENSITY_BLEND);
 
     int mode = DEFAULT_RENDERMODE;
 
     if (useray)
       mode = RAYCAST_RENDERMODE;
     else if(usegpu)
       mode = GPU_RENDERMODE;
         
     m_Controls->m_RenderMode->setCurrentIndex(mode);
         
   }
 
   m_Controls->m_TransferFunctionWidget->SetDataNode(selectedNode);
   m_Controls->m_TransferFunctionWidget->setEnabled(true);
   m_Controls->m_TransferFunctionGeneratorWidget->SetDataNode(selectedNode);
   m_Controls->m_TransferFunctionGeneratorWidget->setEnabled(true);
 }
 
 
 void QmitkVolumeVisualizationView::OnEnableRendering(bool state)
 {
   if(m_SelectedNode.IsExpired())
     return;
 
   m_SelectedNode.Lock()->SetProperty("volumerendering",mitk::BoolProperty::New(state));
   UpdateInterface();
   RequestRenderWindowUpdate();
 }
 
 void QmitkVolumeVisualizationView::OnBlendMode(int mode)
 {
   if (m_SelectedNode.IsExpired())
     return;
 
   auto selectedNode = m_SelectedNode.Lock();
 
   bool usemip = false;
   if (mode == vtkVolumeMapper::MAXIMUM_INTENSITY_BLEND)
     usemip = true;
 
   selectedNode->SetProperty("volumerendering.usemip", mitk::BoolProperty::New(usemip));
   selectedNode->SetProperty("volumerendering.blendmode", mitk::IntProperty::New(mode));
 
   RequestRenderWindowUpdate();
 }
 
 void QmitkVolumeVisualizationView::OnRenderMode(int mode)
 {
   if(m_SelectedNode.IsExpired())
     return;
 
   auto selectedNode = m_SelectedNode.Lock();
   
   bool usegpu = false;
   if (mode == GPU_RENDERMODE)
     usegpu = true;
 
   bool useray = false;
   if (mode == RAYCAST_RENDERMODE)
     useray = true;
   
   if (mode == DEFAULT_RENDERMODE)
   {
     useray = true;
     usegpu = true;
   }
 
   selectedNode->SetProperty("volumerendering.usegpu",mitk::BoolProperty::New(usegpu));
   selectedNode->SetProperty("volumerendering.useray",mitk::BoolProperty::New(useray));
 
   RequestRenderWindowUpdate();
 }
 
 void QmitkVolumeVisualizationView::SetFocus()
 {
 
 }
 
 void QmitkVolumeVisualizationView::NodeRemoved(const mitk::DataNode* node)
 {
   if(m_SelectedNode == node)
   {
     m_SelectedNode = nullptr;
     m_Controls->m_SelectedImageLabel->hide();
     m_Controls->m_ErrorImageLabel->hide();
     m_Controls->m_NoSelectedImageLabel->show();
     UpdateInterface();
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.cpp b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.cpp
index edf0fc93f8..22476d0e5f 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatConnectionPreferencePage.cpp
@@ -1,304 +1,304 @@
 /*===================================================================
 
 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 "QmitkXnatConnectionPreferencePage.h"
 #include "QmitkXnatTreeBrowserView.h"
 
 #include "org_mitk_gui_qt_xnatinterface_Activator.h"
 
 #include "berryIPreferencesService.h"
 #include "berryPlatform.h"
 
 #include <QFileDialog>
 #include <QLabel>
 #include <QPushButton>
 #include <QLineEdit>
 #include <QGridLayout>
 #include <QMessageBox>
 #include <QApplication>
 #include <QMap>
 
 #include "ctkXnatSession.h"
 #include "ctkXnatLoginProfile.h"
 #include "ctkXnatException.h"
 
 #include <mitkIOUtil.h>
 
 using namespace berry;
 
 QmitkXnatConnectionPreferencePage::QmitkXnatConnectionPreferencePage()
-  : m_Control(0)
+  : m_Control(nullptr)
 {
 }
 
 void QmitkXnatConnectionPreferencePage::Init(berry::IWorkbench::Pointer)
 {
 }
 
 void QmitkXnatConnectionPreferencePage::CreateQtControl(QWidget* parent)
 {
   IPreferencesService* prefService = Platform::GetPreferencesService();
   berry::IPreferences::Pointer _XnatConnectionPreferencesNode = prefService->GetSystemPreferences()->Node(QmitkXnatTreeBrowserView::VIEW_ID);
   m_XnatConnectionPreferencesNode = _XnatConnectionPreferencesNode;
 
   m_Controls.setupUi(parent);
   m_Control = new QWidget(parent);
   m_Control->setLayout(m_Controls.gridLayout);
 
   ctkXnatSession* session;
 
   try
   {
     session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
           mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
   }
   catch (std::invalid_argument&)
   {
     session = nullptr;
   }
 
   if (session != nullptr && session->isOpen())
   {
     m_Controls.xnatTestConnectionLabel->setStyleSheet("color: green");
     m_Controls.xnatTestConnectionLabel->setText("Already connected.");
     m_Controls.xnatTestConnectionButton->setEnabled(false);
   }
   const QIntValidator *portV = new QIntValidator(0, 65535, parent);
   m_Controls.inXnatPort->setValidator(portV);
 
   const QRegExp hostRx("^(https?)://[^ /](\\S)+$");
   const QRegExpValidator *hostV = new QRegExpValidator(hostRx, parent);
   m_Controls.inXnatHostAddress->setValidator(hostV);
 
   connect(m_Controls.xnatTestConnectionButton, SIGNAL(clicked()), this, SLOT(TestConnection()));
 
   connect(m_Controls.inXnatHostAddress, SIGNAL(editingFinished()), this, SLOT(UrlChanged()));
   connect(m_Controls.inXnatDownloadPath, SIGNAL(editingFinished()), this, SLOT(DownloadPathChanged()));
 
   connect(m_Controls.cbUseNetworkProxy, SIGNAL(toggled(bool)), this, SLOT(onUseNetworkProxy(bool)));
 
   connect(m_Controls.btnDownloadPath, SIGNAL(clicked()), this, SLOT(OnDownloadPathButtonClicked()));
 
   m_Controls.groupBoxProxySettings->setVisible(m_Controls.cbUseNetworkProxy->isChecked());
 
   this->Update();
 }
 
 QWidget* QmitkXnatConnectionPreferencePage::GetQtControl() const
 {
   return m_Control;
 }
 
 bool QmitkXnatConnectionPreferencePage::PerformOk()
 {
   IPreferences::Pointer _XnatConnectionPreferencesNode = m_XnatConnectionPreferencesNode.Lock();
   if (_XnatConnectionPreferencesNode.IsNotNull())
   {
     _XnatConnectionPreferencesNode->Put(m_Controls.xnatHostAddressLabel->text(), m_Controls.inXnatHostAddress->text());
     _XnatConnectionPreferencesNode->Put(m_Controls.xnatPortLabel->text(), m_Controls.inXnatPort->text());
     _XnatConnectionPreferencesNode->Put(m_Controls.xnatUsernameLabel->text(), m_Controls.inXnatUsername->text());
     _XnatConnectionPreferencesNode->Put(m_Controls.xnatPasswortLabel->text(), m_Controls.inXnatPassword->text());
     _XnatConnectionPreferencesNode->Put(m_Controls.xnatDownloadPathLabel->text(), m_Controls.inXnatDownloadPath->text());
 
     // Network proxy settings
     _XnatConnectionPreferencesNode->PutBool(m_Controls.cbUseNetworkProxy->text(), m_Controls.cbUseNetworkProxy->isChecked());
     _XnatConnectionPreferencesNode->Put(m_Controls.proxyAddressLabel->text(), m_Controls.inProxyAddress->text());
     _XnatConnectionPreferencesNode->Put(m_Controls.proxyPortLabel->text(), m_Controls.inProxyPort->text());
     _XnatConnectionPreferencesNode->Put(m_Controls.proxyUsernameLabel->text(), m_Controls.inProxyUsername->text());
     _XnatConnectionPreferencesNode->Put(m_Controls.proxyPasswordLabel->text(), m_Controls.inProxyPassword->text());
 
     // Silent Mode
     _XnatConnectionPreferencesNode->PutBool(m_Controls.cbUseSilentMode->text(), m_Controls.cbUseSilentMode->isChecked());
 
     //Write
     _XnatConnectionPreferencesNode->Flush();
 
     return true;
   }
   return false;
 }
 
 void QmitkXnatConnectionPreferencePage::PerformCancel()
 {
 }
 
 bool QmitkXnatConnectionPreferencePage::UserInformationEmpty()
 {
   // To check empty QLineEdits in the following
   QString errString;
 
   if (m_Controls.inXnatHostAddress->text().isEmpty())
   {
     errString += "Server Address is empty.\n";
   }
 
   if (m_Controls.inXnatUsername->text().isEmpty())
   {
     errString += "Username is empty.\n";
   }
 
   if (m_Controls.inXnatPassword->text().isEmpty())
   {
     errString += "Password is empty.\n";
   }
 
   // if something is empty
   if (!errString.isEmpty())
   {
     m_Controls.xnatTestConnectionLabel->setStyleSheet("color: red");
     m_Controls.xnatTestConnectionLabel->setText("Connecting failed.\n" + errString);
     return true;
   }
   else
   {
     return false;
   }
 }
 
 void QmitkXnatConnectionPreferencePage::Update()
 {
   IPreferences::Pointer _XnatConnectionPreferencesNode = m_XnatConnectionPreferencesNode.Lock();
   if (_XnatConnectionPreferencesNode.IsNotNull())
   {
     m_Controls.inXnatHostAddress->setText(_XnatConnectionPreferencesNode->Get(
                                             m_Controls.xnatHostAddressLabel->text(), m_Controls.inXnatHostAddress->text()));
     m_Controls.inXnatPort->setText(_XnatConnectionPreferencesNode->Get(
                                      m_Controls.xnatPortLabel->text(), m_Controls.inXnatPort->text()));
     m_Controls.inXnatUsername->setText(_XnatConnectionPreferencesNode->Get(
                                          m_Controls.xnatUsernameLabel->text(), m_Controls.inXnatUsername->text()));
     m_Controls.inXnatPassword->setText(_XnatConnectionPreferencesNode->Get(
                                          m_Controls.xnatPasswortLabel->text(), m_Controls.inXnatPassword->text()));
     m_Controls.inXnatDownloadPath->setText(_XnatConnectionPreferencesNode->Get(
                                              m_Controls.xnatDownloadPathLabel->text(), m_Controls.inXnatDownloadPath->text()));
 
     // Network proxy settings
     m_Controls.cbUseNetworkProxy->setChecked(_XnatConnectionPreferencesNode->GetBool(
                                                m_Controls.cbUseNetworkProxy->text(), false));
     m_Controls.inProxyAddress->setText(_XnatConnectionPreferencesNode->Get(
                                          m_Controls.proxyAddressLabel->text(), m_Controls.inProxyAddress->text()));
     m_Controls.inProxyPort->setText(_XnatConnectionPreferencesNode->Get(
                                       m_Controls.proxyPortLabel->text(), m_Controls.inProxyPort->text()));
     m_Controls.inProxyUsername->setText(_XnatConnectionPreferencesNode->Get(
                                           m_Controls.proxyUsernameLabel->text(), m_Controls.inProxyUsername->text()));
     m_Controls.inProxyPassword->setText(_XnatConnectionPreferencesNode->Get(
                                           m_Controls.proxyPasswordLabel->text(), m_Controls.inProxyPassword->text()));
 
     // Silent Mode
     m_Controls.cbUseSilentMode->setChecked(_XnatConnectionPreferencesNode->GetBool(
                                              m_Controls.cbUseSilentMode->text(), false));
   }
 }
 
 void QmitkXnatConnectionPreferencePage::UrlChanged()
 {
   m_Controls.inXnatHostAddress->setStyleSheet("");
   QString str = m_Controls.inXnatHostAddress->text();
 
   while (str.endsWith("/"))
   {
     str = str.left(str.length() - 1);
   }
 
   m_Controls.inXnatHostAddress->setText(str);
 
   QUrl url(m_Controls.inXnatHostAddress->text());
   if (!url.isValid())
   {
     m_Controls.inXnatHostAddress->setStyleSheet("background-color: red");
   }
 }
 
 void QmitkXnatConnectionPreferencePage::DownloadPathChanged()
 {
   m_Controls.inXnatDownloadPath->setStyleSheet("");
   QString downloadPath = m_Controls.inXnatDownloadPath->text();
   if (!downloadPath.isEmpty())
   {
     if (downloadPath.lastIndexOf("/") != downloadPath.size() - 1)
     {
       downloadPath.append("/");
       m_Controls.inXnatDownloadPath->setText(downloadPath);
     }
     QFileInfo path(m_Controls.inXnatDownloadPath->text());
     if (!path.isDir())
     {
       m_Controls.inXnatDownloadPath->setStyleSheet("background-color: red");
     }
   }
 }
 
 void QmitkXnatConnectionPreferencePage::onUseNetworkProxy(bool status)
 {
   m_Controls.groupBoxProxySettings->setVisible(status);
 }
 
 void QmitkXnatConnectionPreferencePage::OnDownloadPathButtonClicked()
 {
   QString dir = QFileDialog::getExistingDirectory();
   if (!dir.endsWith("/") || !dir.endsWith("\\"))
     dir.append("/");
   m_Controls.inXnatDownloadPath->setText(dir);
 }
 
 void QmitkXnatConnectionPreferencePage::TestConnection()
 {
   if(UserInformationEmpty())
   {
     return;
   }
 
   try
   {
     mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
       mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
   }
   catch (const std::invalid_argument &)
   {
     if (!UserInformationEmpty())
     {
       PerformOk();
 
       mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CreateXnatSession();
       mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
         mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
     }
   }
 
   try
   {
     mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->OpenXnatSession();
 
     m_Controls.xnatTestConnectionLabel->setStyleSheet("color: green");
     m_Controls.xnatTestConnectionLabel->setText("Connecting successful.");
 
     mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
   }
   catch (const ctkXnatAuthenticationException& auth)
   {
     m_Controls.xnatTestConnectionLabel->setStyleSheet("color: red");
     m_Controls.xnatTestConnectionLabel->setText("Connecting failed:\nAuthentication error.");
     MITK_INFO << auth.message().toStdString();
     mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
   }
   catch (const ctkException& e)
   {
     m_Controls.xnatTestConnectionLabel->setStyleSheet("color: red");
     m_Controls.xnatTestConnectionLabel->setText("Connecting failed:\nInvalid Server Adress\nPossibly due to missing OpenSSL for HTTPS connections");
     MITK_INFO << e.message().toStdString();
     mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
   }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatSessionManager.cpp b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatSessionManager.cpp
index 63d127430d..b8f5bd4787 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatSessionManager.cpp
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatSessionManager.cpp
@@ -1,106 +1,106 @@
 /*===================================================================
 
 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 "QmitkXnatSessionManager.h"
 #include "QmitkXnatTreeBrowserView.h"
 
 #include "org_mitk_gui_qt_xnatinterface_Activator.h"
 
 #include "berryPlatform.h"
 #include "berryIPreferences.h"
 #include "mitkLogMacros.h"
 
 #include <QApplication>
 #include <QMessageBox>
 #include <QNetworkProxy>
 
 #include "ctkXnatSession.h"
 #include "ctkXnatException.h"
 
 QmitkXnatSessionManager::QmitkXnatSessionManager()
-  : m_Session(0)
+  : m_Session(nullptr)
 {
 }
 
 QmitkXnatSessionManager::~QmitkXnatSessionManager()
 {
-  if(m_SessionRegistration != 0)
+  if(m_SessionRegistration != nullptr)
   {
     m_SessionRegistration.Unregister();
   }
-  if(m_Session != 0)
+  if(m_Session != nullptr)
   {
     delete m_Session;
   }
 }
 
 void QmitkXnatSessionManager::OpenXnatSession()
 {
   ctkXnatSession* session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(m_SessionRegistration.GetReference());
   if(session == nullptr) return;
 
   if(!session->isOpen())
   {
     session->open();
   }
 }
 
 void QmitkXnatSessionManager::CreateXnatSession()
 {
   berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService();
   berry::IPreferences::Pointer nodeConnectionPref = prefService->GetSystemPreferences()->Node(QmitkXnatTreeBrowserView::VIEW_ID);
 
   QUrl url(nodeConnectionPref->Get("Server Address", ""));
   url.setPort(nodeConnectionPref->Get("Port", "").toInt());
 
   ctkXnatLoginProfile profile;
   profile.setName("Default");
   profile.setServerUrl(url);
   profile.setUserName(nodeConnectionPref->Get("Username", ""));
   profile.setPassword(nodeConnectionPref->Get("Password", ""));
   profile.setDefault(true);
 
   m_Session = new ctkXnatSession(profile);
 
   if (nodeConnectionPref->Get("Proxy Server Address", "").length() != 0)
   {
     QNetworkProxy proxy;
     proxy.setType(QNetworkProxy::HttpProxy);
     proxy.setHostName(nodeConnectionPref->Get("Proxy Server Address", ""));
     proxy.setPort(nodeConnectionPref->Get("Proxy Port", "").toUShort());
 
     if (nodeConnectionPref->Get("Proxy Username", "").length() != 0 &&
         nodeConnectionPref->Get("Proxy Password", "").length() != 0)
     {
       proxy.setUser(nodeConnectionPref->Get("Proxy Username", ""));
       proxy.setPassword(nodeConnectionPref->Get("Proxy Password", ""));
     }
     // Setting the proxy
     m_Session->setHttpNetworkProxy(proxy);
   }
 
   m_SessionRegistration = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->RegisterService(m_Session);
 }
 
 void QmitkXnatSessionManager::CloseXnatSession()
 {
   ctkXnatSession* session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(m_SessionRegistration.GetReference());
   session->close();
   m_SessionRegistration.Unregister();
   m_SessionRegistration = 0;
   delete m_Session;
-  m_Session = 0;
+  m_Session = nullptr;
 }
diff --git a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.cpp b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.cpp
index 55bde83bfb..b587374df2 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.cpp
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/QmitkXnatTreeBrowserView.cpp
@@ -1,1342 +1,1342 @@
 /*===================================================================
 
 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 "QmitkXnatTreeBrowserView.h"
 
 // Qmitk
 #include "org_mitk_gui_qt_xnatinterface_Activator.h"
 
 // Blueberry
 #include <berryPlatform.h>
 
 // CTK XNAT Core
 #include <ctkXnatAssessor.h>
 #include <ctkXnatAssessorFolder.h>
 #include <ctkXnatDataModel.h>
 #include <ctkXnatException.h>
 #include <ctkXnatExperiment.h>
 #include "ctkXnatFile.h"
 #include <ctkXnatProject.h>
 #include <ctkXnatReconstruction.h>
 #include <ctkXnatReconstructionFolder.h>
 #include <ctkXnatResource.h>
 #include <ctkXnatResourceFolder.h>
 #include <ctkXnatScan.h>
 #include <ctkXnatScanFolder.h>
 #include <ctkXnatSubject.h>
 
 
 // MITK XNAT
 #include <mitkDataStorage.h>
 #include <QmitkIOUtil.h>
 #include <QmitkXnatProjectWidget.h>
 #include <QmitkXnatSubjectWidget.h>
 #include <QmitkXnatExperimentWidget.h>
 #include <QmitkXnatCreateObjectDialog.h>
 #include <QmitkXnatUploadFromDataStorageDialog.h>
 
 // Qt
 #include <QAction>
 #include <QClipboard>
 #include <QDateTime>
 #include <QDialog>
 #include <QDir>
 #include <QDirIterator>
 #include <QFileDialog>
 #include <QInputDialog>
 #include <QMenu>
 #include <QMessageBox>
 #include <QTimer>
 #include <QFileInfoList>
 
 #include <QmitkPreferencesDialog.h>
 
 // Poco
 #include <Poco/Zip/Decompress.h>
 
 const QString QmitkXnatTreeBrowserView::VIEW_ID = "org.mitk.views.xnat.treebrowser";
 
 static bool isDirWriteable(QDir myDir)
 {
   const QFileInfoList tmpInfo = myDir.entryInfoList();
   foreach (QFileInfo f, tmpInfo)
   {
     if(f.fileName() == ".")
       return f.isWritable();
   }
   return true;
 }
 
 static bool doesDirExist(QDir myDir)
 {
   if (!myDir.exists())
   {
     if(!myDir.mkpath("."))
     {
       MITK_INFO << "Path Creation Failed.";
       return false;
     }
   }
   return true;
 }
 
 QmitkXnatTreeBrowserView::QmitkXnatTreeBrowserView() :
   m_DataStorageServiceTracker(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetContext()),
   m_TreeModel(new QmitkXnatTreeModel()),
-  m_Tracker(0),
+  m_Tracker(nullptr),
   m_DownloadPath(berry::Platform::GetPreferencesService()->GetSystemPreferences()->Node(VIEW_ID)->Get("Download Path", "")),
   m_SilentMode(false)
 {
   m_DataStorageServiceTracker.open();
 
   // Set DownloadPath
   if (m_DownloadPath.isEmpty())
   {
     QString xnatFolder = "XNAT_DOWNLOADS";
     QDir dir(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetContext()->getDataFile("").absoluteFilePath());
     dir.mkdir(xnatFolder);
     dir.setPath(dir.path() + "/" + xnatFolder);
     m_DownloadPath = dir.path() + "/";
   }
 }
 
 QmitkXnatTreeBrowserView::~QmitkXnatTreeBrowserView()
 {
   m_DataStorageServiceTracker.close();
   delete m_TreeModel;
   delete m_Tracker;
 }
 
 void QmitkXnatTreeBrowserView::SetFocus()
 {
 }
 
 void QmitkXnatTreeBrowserView::FilePathNotAvailableWarning(QString file)
 {
   MITK_INFO << "Download of " << file.toStdString() << " failed! Download Path not available!";
   QMessageBox::critical(m_Controls.treeView, "Download failed!", "Download of " + file + " failed!\nDownload Path "
                         + m_DownloadPath + " not available. \n\nChange Download Path in Settings!");
   QmitkPreferencesDialog _PreferencesDialog(QApplication::activeWindow());
   _PreferencesDialog.SetSelectedPage("org.mitk.gui.qt.application.XnatConnectionPreferencePage");
   _PreferencesDialog.exec();
   m_Controls.groupBox->hide();
 }
 
 void QmitkXnatTreeBrowserView::ToggleConnection()
 {
-  ctkXnatSession* session = 0;
+  ctkXnatSession* session = nullptr;
 
   try
   {
     session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
           mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
   }
   catch (std::invalid_argument&)
   {
     mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CreateXnatSession();
 
     session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
           mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
   }
 
-  if (session != 0 && session->isOpen())
+  if (session != nullptr && session->isOpen())
   {
     mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
     m_Controls.btnXnatConnect->setToolTip("Connect");
     m_Controls.btnXnatConnect->setIcon(QIcon(":/xnat-plugin/xnat-connect.png"));
     CleanUp();
   }
-  else if (session != 0 && !session->isOpen())
+  else if (session != nullptr && !session->isOpen())
   {
     try
     {
       mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->OpenXnatSession();
       m_Controls.btnXnatConnect->setToolTip("Disconnect");
       m_Controls.btnXnatConnect->setIcon(QIcon(":/xnat-plugin/xnat-disconnect.png"));
       m_Controls.searchField->setEnabled(true);
       m_Controls.searchModeBox->setEnabled(true);
     }
     catch (const ctkXnatAuthenticationException& auth)
     {
       MITK_INFO << auth.message().toStdString();
       mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
       QmitkPreferencesDialog _PreferencesDialog(QApplication::activeWindow());
       _PreferencesDialog.SetSelectedPage("org.mitk.gui.qt.application.XnatConnectionPreferencePage");
       _PreferencesDialog.exec();
     }
     catch (const ctkException& e)
     {
       MITK_INFO << e.message().toStdString();
       mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()->CloseXnatSession();
       QmitkPreferencesDialog _PreferencesDialog(QApplication::activeWindow());
       _PreferencesDialog.SetSelectedPage("org.mitk.gui.qt.application.XnatConnectionPreferencePage");
       _PreferencesDialog.exec();
     }
     catch (...)
     {
       QmitkPreferencesDialog _PreferencesDialog(QApplication::activeWindow());
       _PreferencesDialog.SetSelectedPage("org.mitk.gui.qt.application.XnatConnectionPreferencePage");
       _PreferencesDialog.exec();
     }
   }
 }
 
 void QmitkXnatTreeBrowserView::CreateQtPartControl(QWidget *parent)
 {
   // Create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   m_Controls.treeView->setModel(m_TreeModel);
   m_Controls.treeView->header()->hide();
   m_Controls.treeView->setSelectionMode(QAbstractItemView::ExtendedSelection);
   m_Controls.treeView->setAcceptDrops(true);
   m_Controls.treeView->setDropIndicatorShown(true);
 
   m_Controls.treeView->setSelectionMode(QAbstractItemView::SingleSelection);
   m_Controls.treeView->setContextMenuPolicy(Qt::CustomContextMenu);
 
   m_Controls.groupBox->hide();
   m_Controls.wgtExperimentInfo->hide();
   m_Controls.wgtSubjectInfo->hide();
   m_Controls.wgtProjectInfo->hide();
 
   m_Tracker = new mitk::XnatSessionTracker(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext());
 
   m_ContextMenu = new QMenu(m_Controls.treeView);
 
   connect(m_Controls.treeView, SIGNAL(clicked(const QModelIndex&)), SLOT(ItemSelected(const QModelIndex&)));
   connect(m_Controls.treeView, SIGNAL(customContextMenuRequested(const QPoint&)),
           this, SLOT(OnContextMenuRequested(const QPoint&)));
   connect(m_Tracker, SIGNAL(AboutToBeClosed(ctkXnatSession*)), this, SLOT(CleanTreeModel(ctkXnatSession*)));
   connect(m_Tracker, SIGNAL(Opened(ctkXnatSession*)), this, SLOT(UpdateSession(ctkXnatSession*)));
 
   m_Tracker->Open();
 
   connect(m_Controls.treeView, SIGNAL(doubleClicked(const QModelIndex&)), this, SLOT(OnActivatedNode(const QModelIndex&)));
   connect(m_Controls.treeView, SIGNAL(clicked(const QModelIndex&)), this, SLOT(OnXnatNodeSelected(const QModelIndex&)));
   connect(m_TreeModel, SIGNAL(ResourceDropped(const QList<mitk::DataNode*>&, ctkXnatObject*, const QModelIndex&)), this, SLOT(OnUploadResource(const QList<mitk::DataNode*>&, ctkXnatObject*, const QModelIndex&)));
 
   connect(m_Controls.btnXnatConnect, SIGNAL(clicked()), SLOT(ToggleConnection()));
   connect(m_Controls.btnXnatUpload, SIGNAL(clicked()), this, SLOT(OnUploadFromDataStorage()));
   connect(m_Controls.btnXnatDownload, SIGNAL(clicked()), this, SLOT(OnDownloadSelectedXnatFile()));
   connect(m_Controls.btnCreateXnatFolder, SIGNAL(clicked()), this, SLOT(OnCreateResourceFolder()));
   connect(m_Controls.searchField, SIGNAL(textChanged(const QString&)), this, SLOT(Search(const QString&)));
 }
 
 void QmitkXnatTreeBrowserView::OnCreateResourceFolder()
 {
   QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
 
   if(!index.isValid()) return;
 
   ctkXnatObject* parent = index.data(Qt::UserRole).value<ctkXnatObject*>();
 
   this->InternalAddResourceFolder(parent);
 
   OnContextMenuRefreshItem();
 }
 
 
 void QmitkXnatTreeBrowserView::Search(const QString &toSearch)
 {
   if(m_AlreadyInSearch)
     return;
 
   m_AlreadyInSearch = true;
 
   m_Controls.treeView->collapseAll();
   m_Controls.treeView->expandToDepth(m_Controls.searchModeBox->currentIndex());
 
   m_Controls.treeView->clearSelection();
 
   foreach (const QModelIndex &hidden, m_hiddenItems)
   {
     m_Controls.treeView->setRowHidden(hidden.row(),hidden.parent(),false);
   }
   m_hiddenItems.clear();
 
   if(toSearch.isEmpty())
   {
     m_Controls.treeView->collapseAll();
     m_Controls.treeView->expandToDepth(0);
     m_AlreadyInSearch = false;
     return;
   }
 
   QModelIndexList items = m_Controls.treeView->model()->match(
         m_Controls.treeView->model()->index(0,0),
         Qt::DisplayRole,
         QVariant::fromValue(toSearch),
         -1,
         Qt::MatchContains|Qt::MatchRecursive);
 
   if(!items.isEmpty())
   {
     foreach (const QModelIndex &match, items)
     {
       int depth = 0;
       QModelIndex tparent = match;
       while ( tparent.parent().isValid() )
       {
         tparent = tparent.parent();
         depth++;
       }
 
       switch (depth)
       {
       case 1: //Project Level
         if(m_Controls.searchModeBox->currentIndex() == ProjectLevel)
         {
           m_hiddenItems.append(match);
           m_Controls.treeView->setRowHidden(match.row(),match.parent(),true);
         }
         break;
       case 2: //Patient level
         if(m_Controls.searchModeBox->currentIndex() == SubjectLevel)
         {
           m_hiddenItems.append(match);
           m_Controls.treeView->setRowHidden(match.row(),match.parent(),true);
         }
         break;
       default:
         break;
       }
     }
 
   }
   m_AlreadyInSearch = false;
 }
 
 void QmitkXnatTreeBrowserView::OnDownloadSelectedXnatFile()
 {
   QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
 
   if(!index.isValid()) return;
 
   ctkXnatObject* selectedXnatObject = index.data(Qt::UserRole).value<ctkXnatObject*>();
   bool enableDownload = dynamic_cast<ctkXnatFile*>(selectedXnatObject) != nullptr;
   enableDownload |= dynamic_cast<ctkXnatScan*>(selectedXnatObject) != nullptr;
 
   if (enableDownload)
   {
     this->InternalFileDownload(index, true);
   }
 }
 
 void QmitkXnatTreeBrowserView::OnUploadFromDataStorage()
 {
   QmitkXnatUploadFromDataStorageDialog dialog;
   dialog.SetDataStorage(this->GetDataStorage());
   int result = dialog.exec();
   if (result == QDialog::Accepted)
   {
     QList<mitk::DataNode*> nodes;
     nodes << dialog.GetSelectedNode().GetPointer();
     QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
 
     if (!index.isValid()) return;
     ctkXnatObject* parent = m_TreeModel->xnatObject(index);
     this->OnUploadResource(nodes, parent, index);
   }
 }
 
 void QmitkXnatTreeBrowserView::OnXnatNodeSelected(const QModelIndex& index)
 {
   if (!index.isValid()) return;
 
   ctkXnatObject* selectedXnatObject = index.data(Qt::UserRole).value<ctkXnatObject*>();
 
   // enable download button
   bool enableDownload = dynamic_cast<ctkXnatFile*>(selectedXnatObject) != nullptr;
   enableDownload |= dynamic_cast<ctkXnatScan*>(selectedXnatObject) != nullptr;
   m_Controls.btnXnatDownload->setEnabled(enableDownload);
 
   // enable folder creation
   bool enableCreateFolder = dynamic_cast<ctkXnatProject*>(selectedXnatObject) != nullptr;
   enableCreateFolder |= dynamic_cast<ctkXnatSubject*>(selectedXnatObject) != nullptr;
   enableCreateFolder |= dynamic_cast<ctkXnatExperiment*>(selectedXnatObject) != nullptr;
   enableCreateFolder |= dynamic_cast<ctkXnatResourceFolder*>(selectedXnatObject) != nullptr;
   m_Controls.btnCreateXnatFolder->setEnabled(enableCreateFolder);
 
   // enable upload
   bool enableUpload = dynamic_cast<ctkXnatResource*>(selectedXnatObject) != nullptr;
   m_Controls.btnXnatUpload->setEnabled(enableUpload);
 }
 
 void QmitkXnatTreeBrowserView::OnActivatedNode(const QModelIndex& index)
 {
   if (!index.isValid()) return;
 
   ctkXnatObject* selectedXnatObject = index.data(Qt::UserRole).value<ctkXnatObject*>();
   bool enableDownload = dynamic_cast<ctkXnatFile*>(selectedXnatObject) != nullptr;
   enableDownload |= dynamic_cast<ctkXnatScan*>(selectedXnatObject) != nullptr;
 
   if (enableDownload)
   {
     if(!m_SilentMode)
     {
       QMessageBox msgBox;
       QString fname = selectedXnatObject->name() != "" ? selectedXnatObject->name() :
                                                          index.data(Qt::DisplayRole).toString();
       QString msg ("Do you want to download "+ fname +"?");
       msgBox.setWindowTitle("MITK XNAT download");
       msgBox.setText(msg);
       msgBox.setIcon(QMessageBox::Question);
       msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
       int result = msgBox.exec();
       if (result == QMessageBox::Ok)
       {
         InternalFileDownload(index, true);
       }
     }
     else
     {
       InternalFileDownload(index, true);
     }
   }
 }
 
 void QmitkXnatTreeBrowserView::UpdateSession(ctkXnatSession* session)
 {
-  if (session != 0 && session->isOpen())
+  if (session != nullptr && session->isOpen())
   {
     // Fill model and show in the GUI
     m_TreeModel->addDataModel(session->dataModel());
     m_Controls.treeView->reset();
 
     connect(session, SIGNAL(progress(QUuid,double)), this, SLOT(OnProgress(QUuid,double)));
     connect(session, SIGNAL(timedOut()), this, SLOT(SessionTimedOutMsg()));
     connect(session, SIGNAL(aboutToTimeOut()), this, SLOT(SessionTimesOutSoonMsg()));
   }
 }
 
 void QmitkXnatTreeBrowserView::CleanTreeModel(ctkXnatSession* session)
 {
-  if (session != 0)
+  if (session != nullptr)
   {
     m_TreeModel->removeDataModel(session->dataModel());
     m_Controls.treeView->reset();
   }
 }
 
 void QmitkXnatTreeBrowserView::OnProgress(QUuid /*queryID*/, double progress)
 {
   if (progress > 0)
   {
     unsigned int currentProgress = progress*100;
     if (m_Controls.groupBox->isHidden())
     {
       m_Controls.groupBox->show();
       m_Controls.progressBar->setValue(0);
     }
     m_Controls.progressBar->setValue(currentProgress);
   }
 }
 
 void QmitkXnatTreeBrowserView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
   QString downloadPath = prefs->Get("Download Path", "");
   QDir downloadDir (downloadPath);
   if (downloadPath.length() != 0 && downloadDir.exists())
     m_DownloadPath = downloadPath;
 
   m_SilentMode = prefs->GetBool("Silent Mode", false);
 }
 
 void QmitkXnatTreeBrowserView::InternalFileDownload(const QModelIndex& index, bool loadData)
 {
   if (!index.isValid())
     return;
 
   QDir rootDownloadDir(m_DownloadPath);
   if(isDirWriteable(rootDownloadDir) == false)
   {
     MITK_INFO << "Download directory access permission unsufficient! " << m_DownloadPath;
     QMessageBox::critical(nullptr,"Download directory access permission unsufficient!",
                           "You have no permission to write to selected download directory " + m_DownloadPath +"!\n\nChange Download Path in Settings!");
     QmitkPreferencesDialog _PreferencesDialog(QApplication::activeWindow());
     _PreferencesDialog.SetSelectedPage("org.mitk.gui.qt.application.XnatConnectionPreferencePage");
     _PreferencesDialog.exec();
     return;
   }
 
   ctkXnatObject* xnatObject = m_TreeModel->xnatObject(index);
   if (xnatObject != nullptr)
   {
     m_Controls.progressBar->setMinimum(0);
     m_Controls.progressBar->setMaximum(100);
     // The path to the downloaded file
     QString filePath;
     QDir downloadPath (m_DownloadPath);
     QString serverURL = berry::Platform::GetPreferencesService()->GetSystemPreferences()->Node(VIEW_ID)->Get("Server Address", "");
     bool isDICOM (false);
     bool filePathExists (true);
 
     // If a scan was selected, downloading the contained DICOM folder as ZIP
     ctkXnatScan* scan = dynamic_cast<ctkXnatScan*>(xnatObject);
 
     if (scan != nullptr)
     {
       isDICOM = true;
 
       if (!scan->isFetched())
         scan->fetch();
 
       QList<ctkXnatObject*> children = scan->children();
 
       foreach (ctkXnatObject* obj, children)
       {
         if (obj->name() == "DICOM")
         {
           QString uriId = obj->resourceUri();
           uriId.replace("/data/archive/projects/", "");
           QString folderName = m_DownloadPath + uriId + "/";
           downloadPath = folderName;
           filePathExists = doesDirExist(downloadPath);
 
           if(filePathExists)
           {
             try
             {
               this->InternalDICOMDownload(obj, downloadPath);
             }
             catch(const ctkRuntimeException& exc)
             {
               QmitkHttpStatusCodeHandler::HandleErrorMessage(exc.what());
               return;
             }
             serverURL = obj->resourceUri();
           }
           else
           {
             FilePathNotAvailableWarning("DICOM folder");
             return;
           }
         }
       }
     }
     else
     {
       ctkXnatFile* file = dynamic_cast<ctkXnatFile*>(xnatObject);
 
       if (file == nullptr)
       {
         MITK_ERROR << "Selected XNAT object not downloadable!";
         return;
       }
 
       QString uriId = file->parent()->resourceUri();
       uriId.replace("/data/archive/projects/", "");
 
       QString folderName = m_DownloadPath + uriId + "/";
       downloadPath = folderName;
 
       filePathExists = doesDirExist(downloadPath);
       filePath = folderName + file->name();
 
       // Checking if the file exists already
       if (downloadPath.exists(file->name()))
       {
         MITK_INFO << "File '" << file->name().toStdString() << "' already exists!";
         serverURL = file->parent()->resourceUri();
       }
       else
       {
         if (file->property("collection") == QString("DICOM"))
         {
           isDICOM = true;
           ctkXnatObject* parent = file->parent();
 
           QString uriId = parent->resourceUri();
           uriId.replace("/data/archive/projects/", "");
           QString folderName = m_DownloadPath + uriId + "/";
           downloadPath = folderName;
           filePathExists = doesDirExist(downloadPath);
 
           if(filePathExists)
           {
             try
             {
               this->InternalDICOMDownload(parent, downloadPath);
             }
             catch(const ctkRuntimeException& exc)
             {
               QmitkHttpStatusCodeHandler::HandleErrorMessage(exc.what());
               return;
             }
           }
           else
           {
             FilePathNotAvailableWarning(parent->name());
             return;
           }
 
           serverURL = parent->resourceUri();
         }
         //Normal file download, no DICOM download
         else
         {
           if(filePathExists)
           {
             this->SetStatusInformation("Downloading file " + file->name());
             file->download(filePath);
           }
           else
           {
             MITK_INFO << "File Download Failed.";
           }
           serverURL = file->parent()->resourceUri();
 
           // Checking if the file exists now
           if (downloadPath.exists(file->name()))
           {
             MITK_INFO << "Download of " << file->name().toStdString() << " completed!";
             if(!m_SilentMode)
             {
               QMessageBox msgBox;
               msgBox.setText("Download of " + file->name() + " completed!");
               msgBox.setIcon(QMessageBox::Information);
               msgBox.exec();
             }
             m_Controls.groupBox->hide();
           }
           else
           {
             if(filePathExists)
             {
               MITK_INFO << "Download of " << file->name().toStdString() << " failed!";
               QMessageBox::critical(m_Controls.treeView, "Download failed!", "Download of " + file->name() + " failed!");
               m_Controls.groupBox->hide();
               return;
             }
             else
             {
               FilePathNotAvailableWarning(file->name());
               return;
             }
           }
         }
       }
     }
     if (loadData)
     {
       QFileInfoList fileList;
       if (isDICOM)
       {
         fileList = downloadPath.entryInfoList(QDir::Files);
       }
       else
       {
         QFileInfo fileInfo(filePath);
         fileList << fileInfo;
       }
 
       mitk::StringProperty::Pointer xnatURL = mitk::StringProperty::New(serverURL.toStdString());
       try
       {
         this->InternalOpenFiles(fileList, xnatURL);
       }
       catch(const ctkRuntimeException& exc)
       {
         QmitkHttpStatusCodeHandler::HandleErrorMessage(exc.what());
         return;
       }
     }
   }
 }
 
 void QmitkXnatTreeBrowserView::InternalDICOMDownload(ctkXnatObject *obj, QDir &DICOMDirPath)
 {
 
   QString filePath = m_DownloadPath + obj->property("label") + ".zip";
 
   this->SetStatusInformation("Downloading DICOM series " + obj->parent()->name());
   // In case of DICOM zip download we do not know the total file size
   // Because of that the dowload progres cannot be calculated
   // Because of that we use the busy indicator of the progress bar by setting min and max to 0
   m_Controls.progressBar->setMinimum(0);
   m_Controls.progressBar->setMaximum(0);
   m_Controls.progressBar->show();
   obj->download(filePath);
 
   std::ifstream in(filePath.toStdString().c_str(), std::ios::binary);
   poco_assert(in);
 
   // decompress to XNAT_DOWNLOAD dir
   Poco::Zip::Decompress dec(in, Poco::Path(DICOMDirPath.path().toStdString()), true);
   dec.decompressAllFiles();
 
   in.close();
   QFile::remove(filePath);
 
   // Checking if the file exists now
   if (DICOMDirPath.exists())
   {
     if(!m_SilentMode)
     {
       MITK_INFO << "Download of DICOM series completed!";
       QMessageBox msgBox;
       msgBox.setText("Download of DICOM series completed!");
       msgBox.setIcon(QMessageBox::Information);
       msgBox.exec();
       m_Controls.groupBox->hide();
     }
   }
   else
   {
     MITK_INFO << "Download of DICOM series failed!";
     QMessageBox msgBox;
     msgBox.setText("Download of DICOM series failed!");
     msgBox.setIcon(QMessageBox::Critical);
     msgBox.exec();
     m_Controls.groupBox->hide();
   }
 }
 
 void QmitkXnatTreeBrowserView::InternalOpenFiles(const QFileInfoList & fileList, mitk::StringProperty::Pointer xnatURL)
 {
 
   if (fileList.isEmpty())
   {
     MITK_WARN << "No files available for loading!";
     return;
   }
 
   mitk::IDataStorageService* dsService = m_DataStorageServiceTracker.getService();
   mitk::DataStorage::Pointer dataStorage = dsService->GetDataStorage()->GetDataStorage();
   QStringList list;
   list << fileList.at(0).absoluteFilePath();
   try
   {
     mitk::DataStorage::SetOfObjects::Pointer nodes = QmitkIOUtil::Load(list, *dataStorage);
     if (nodes->size() == 1)
     {
       mitk::DataNode* node = nodes->at(0);
       node->SetProperty("xnat.url", xnatURL);
     }
   }
   catch (const mitk::Exception& e)
   {
     MITK_INFO << e;
     return;
   }
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(
         dsService->GetDataStorage()->GetDataStorage());
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuDownloadFile()
 {
   QModelIndex index = m_Controls.treeView->currentIndex();
   InternalFileDownload(index, false);
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuDownloadAndOpenFile()
 {
   QModelIndex index = m_Controls.treeView->currentIndex();
 
   InternalFileDownload(index, true);
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuCreateResourceFolder()
 {
   const QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
   ctkXnatObject* parentObject = m_TreeModel->xnatObject(index);
 
   if (parentObject != nullptr)
   {
     this->InternalAddResourceFolder(parentObject);
   }
 }
 
 ctkXnatResource* QmitkXnatTreeBrowserView::InternalAddResourceFolder(ctkXnatObject *parent)
 {
   bool ok;
   QString folderName = QInputDialog::getText(m_Controls.treeView, tr("Create XNAT resource folder"),
                                              tr("Folder name:"), QLineEdit::Normal, tr("data"), &ok);
   if (ok)
   {
     if (folderName.isEmpty())
       folderName = "NO LABEL";
 
     // if called on the resource-folder level we need to provide he corresponding
     // parent instead of the folder
     ctkXnatResourceFolder* resourceFolder = dynamic_cast<ctkXnatResourceFolder*>(parent);
     if (resourceFolder != nullptr)
     {
       parent = parent->parent();
     }
 
     try
     {
       return parent->addResourceFolder(folderName);
     }
     catch(const ctkRuntimeException& exc)
     {
       QmitkHttpStatusCodeHandler::HandleErrorMessage(exc.what());
       return nullptr;
     }
   }
   else
   {
     return nullptr;
   }
 }
 
 void QmitkXnatTreeBrowserView::InternalFileUpload(ctkXnatFile* file)
 {
   m_Controls.groupBox->setTitle("Uploading file...");
   m_Controls.groupBox->show();
 
   try
   {
     file->save();
     MITK_INFO << "Upload of " << file->name().toStdString() << " completed!";
     if(!m_SilentMode)
     {
       QMessageBox msgBox;
       msgBox.setText("Upload of " + file->name() + " completed!");
       msgBox.setIcon(QMessageBox::Information);
       msgBox.show();
       msgBox.exec();
     }
   }
   catch (ctkXnatException &e)
   {
     QMessageBox msgbox;
     msgbox.setText(e.what());
     msgbox.setIcon(QMessageBox::Critical);
     msgbox.exec();
     m_Controls.progressBar->setValue(0);
   }
   m_Controls.groupBox->hide();
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuUploadFile()
 {
   QString filename = QFileDialog::getOpenFileName(m_Controls.treeView, tr("Open File"), QDir::homePath());
   const QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
   ctkXnatResource* resource = dynamic_cast<ctkXnatResource*>(m_TreeModel->xnatObject(index));
   if (resource != nullptr && filename.length() != 0)
   {
     ctkXnatFile* file = new ctkXnatFile(resource);
     file->setLocalFilePath(filename);
     QFileInfo fileInfo (filename);
     file->setName(fileInfo.fileName());
     try
     {
       this->InternalFileUpload(file);
     }
     catch(const ctkRuntimeException& exc)
     {
       QmitkHttpStatusCodeHandler::HandleErrorMessage(exc.what());
       return;
     }
     m_TreeModel->addChildNode(index, file);
   }
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuCopyXNATUrlToClipboard()
 {
   const QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
   ctkXnatObject* currentXnatObject = m_TreeModel->xnatObject(index);
   if (currentXnatObject != nullptr)
   {
     QString serverURL = berry::Platform::GetPreferencesService()->GetSystemPreferences()->Node(VIEW_ID)->Get("Server Address", "");
     serverURL.append(currentXnatObject->resourceUri());
     QClipboard *clipboard = QApplication::clipboard();
     clipboard->setText(serverURL);
   }
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuRefreshItem()
 {
   const QModelIndex index = m_Controls.treeView->selectionModel()->currentIndex();
   if (index.isValid())
   {
     this->m_TreeModel->refresh(index);
   }
 }
 
 void QmitkXnatTreeBrowserView::OnUploadResource(const QList<mitk::DataNode*>& droppedNodes, ctkXnatObject* parentObject, const QModelIndex& parentIndex)
 {
   if (parentObject == nullptr)
     return;
 
   //1. If not dropped on a resource, create a new folder
   //temporarily remove the annoying message box that upload was successful..
   ctkXnatResource* resource = dynamic_cast<ctkXnatResource*>(parentObject);
   // store original resource folder object for later use
   ctkXnatResourceFolder* originalResourceFolder = dynamic_cast<ctkXnatResourceFolder*>(parentObject);
   if (resource == nullptr)
   {
     resource = this->InternalAddResourceFolder(parentObject);
   }
 
   if (resource == nullptr)
   {
     MITK_WARN << "Resource folder could not be created!";
     return;
   }
 
   //2. Save files locally
   //3. Upload file
   mitk::DataNode* node = nullptr;
   foreach (node, droppedNodes)
   {
     mitk::BaseData* data = node->GetData();
     if (!data)
       return;
 
     //We have to replace special characters due to XNAT inability to get along with them (" " is replaced by "%20", what leads to nasty behaviour!)
     QString fileName(QString::fromStdString(ReplaceSpecialChars(node->GetName())));
 
     ctkXnatFile* xnatFile = new ctkXnatFile(resource);
 
     if (dynamic_cast<mitk::Image*>(data))
     {
       fileName.append(".nrrd");
     }
     else if (dynamic_cast<mitk::Surface*>(data))
     {
       fileName.append(".vtk");
     }
     else if (dynamic_cast<mitk::PointSet*>(data))
     {
       fileName.append(".mps");
     }
     else
     {
       MITK_WARN << "Could not upload file! File-type not supported";
       QMessageBox msgbox;
       msgbox.setText("Could not upload file! File-type not supported");
       msgbox.setIcon(QMessageBox::Critical);
       msgbox.exec();
       return;
     }
 
     xnatFile->setName(fileName);
 
     QString xnatFolder = "XNAT_UPLOADS";
     QDir dir(mitk::org_mitk_gui_qt_xnatinterface_Activator::GetContext()->getDataFile("").absoluteFilePath());
     dir.mkdir(xnatFolder);
 
     fileName = dir.path().append("/" + fileName);
     mitk::IOUtil::Save (data, fileName.toStdString());
 
     // TODO Check if file exists
     // AbstractFileReader::SetDefaultDataNodeProperties
     // und in die andere SetDefaultDataNodeProperties
     // PropertyName klein: mtime.initial + Kommentar
     mitk::StringProperty::Pointer orignalFilePath = mitk::StringProperty::New();
     node->GetProperty(orignalFilePath, "path");
 
     xnatFile->setLocalFilePath(fileName);
 
     try
     {
       this->InternalFileUpload(xnatFile);
     }
     catch(const ctkRuntimeException& exc)
     {
       QmitkHttpStatusCodeHandler::HandleErrorMessage(exc.what());
       return;
     }
     QFile::remove(fileName);
 
     if (originalResourceFolder == nullptr)
     {
       m_TreeModel->refresh(parentIndex);
     }
     else
     {
       m_TreeModel->refresh(parentIndex.parent());
     }
 
     // The filename for uploading
     //    QFileInfo fileInfo;
     //      if (surface)
     //      {
     //        // Save surface
     //        fileName.append(".stl");
     //        xnatFile->setName(fileName);
     //        dir.setPath(dir.path().append("/" + fileName));
 
     //    QString origFile = QString::fromStdString(orignalFilePath->GetValueAsString());
     //    origFile.append("/" + fileName);
     //        origFile.append(".stl");
 
     //        fileInfo.setFile(origFile);
     //        if (!fileInfo.exists())
     //          mitk::IOUtil::Save(surface, dir.path().toStdString());
     //      }
     //    this->uploadFileToXnat(xnatFile, dir.path());
   }
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuRequested(const QPoint & pos)
 {
   if(m_TreeModel==nullptr)
   {
     return;
   }
 
   QModelIndex index = m_Controls.treeView->indexAt(pos);
 
   if(index.isValid() == false)
   {
     return;
   }
 
   m_ContextMenu->clear();
 
   QAction* actRefreshItem = new QAction("Refresh", m_ContextMenu);
   m_ContextMenu->addAction(actRefreshItem);
   connect(actRefreshItem, SIGNAL(triggered()), this, SLOT(OnContextMenuRefreshItem()));
 
   QAction* actGetXNATURL = new QAction("Copy XNAT URL to clipboard", m_ContextMenu);
   m_ContextMenu->addAction(actGetXNATURL);
   connect(actGetXNATURL, SIGNAL(triggered()), this, SLOT(OnContextMenuCopyXNATUrlToClipboard()));
   m_ContextMenu->addSeparator();
 
   ctkXnatObject* xnatObject = m_TreeModel->xnatObject(index);
 
   bool downloadable = false;
   downloadable |= dynamic_cast<ctkXnatFile*>(xnatObject)!=nullptr;
   downloadable |= dynamic_cast<ctkXnatScan*>(xnatObject)!=nullptr;
   downloadable |= dynamic_cast<ctkXnatScanFolder*>(xnatObject)!=nullptr;
   downloadable |= dynamic_cast<ctkXnatAssessor*>(xnatObject)!=nullptr;
   downloadable |= dynamic_cast<ctkXnatAssessorFolder*>(xnatObject)!=nullptr;
   downloadable |= dynamic_cast<ctkXnatResource*>(xnatObject)!=nullptr;
   downloadable |= dynamic_cast<ctkXnatReconstruction*>(xnatObject)!=nullptr;
   downloadable |= dynamic_cast<ctkXnatReconstructionFolder*>(xnatObject)!=nullptr;
 
   bool canHaveResourceFolder = false;
   canHaveResourceFolder |= dynamic_cast<ctkXnatProject*>(xnatObject) != nullptr;
   canHaveResourceFolder |=  dynamic_cast<ctkXnatSubject*>(xnatObject) != nullptr;
   canHaveResourceFolder |=  dynamic_cast<ctkXnatExperiment*>(xnatObject) != nullptr;
   canHaveResourceFolder |= dynamic_cast<ctkXnatResourceFolder*>(xnatObject) != nullptr;
 
   bool uploadFilePossible = false;
   uploadFilePossible |= dynamic_cast<ctkXnatResource*>(xnatObject) != nullptr;
   uploadFilePossible |=  dynamic_cast<ctkXnatScan*>(xnatObject) != nullptr;
   uploadFilePossible |=  dynamic_cast<ctkXnatAssessor*>(xnatObject) != nullptr;
 
   if (downloadable)
   {
     QAction* actDownload = new QAction("Download", m_ContextMenu);
     connect(actDownload, SIGNAL(triggered()), this, SLOT(OnContextMenuDownloadFile()));
     m_ContextMenu->addAction(actDownload);
     ctkXnatFile* file = dynamic_cast<ctkXnatFile*>(xnatObject);
     if (file)
     {
       QAction* actView = new QAction("Download and Open", m_ContextMenu);
       connect(actView, SIGNAL(triggered()), this, SLOT(OnContextMenuDownloadAndOpenFile()));
       m_ContextMenu->addAction(actView);
     }
   }
 
   if (canHaveResourceFolder)
   {
     QAction* actCreateResource = new QAction("Add resource folder", m_ContextMenu);
     connect(actCreateResource, SIGNAL(triggered()), this, SLOT(OnContextMenuCreateResourceFolder()));
     m_ContextMenu->addAction(actCreateResource);
   }
 
   if (uploadFilePossible)
   {
     QAction* actUploadFile = new QAction("Upload File", m_ContextMenu);
     connect(actUploadFile, SIGNAL(triggered()), this, SLOT(OnContextMenuUploadFile()));
     m_ContextMenu->addAction(actUploadFile);
   }
 
   ctkXnatProject* project = dynamic_cast<ctkXnatProject*>(xnatObject);
   if (project != nullptr)
   {
     QAction* actCreateSubject = new QAction("Create new subject", m_ContextMenu);
     m_ContextMenu->addAction(actCreateSubject);
     connect(actCreateSubject, SIGNAL(triggered()), this, SLOT(OnContextMenuCreateNewSubject()));
   }
   ctkXnatSubject* subject = dynamic_cast<ctkXnatSubject*>(xnatObject);
   if (subject != nullptr)
   {
     QAction* actCreateExperiment = new QAction("Create new experiment", m_ContextMenu);
     m_ContextMenu->addAction(actCreateExperiment);
     connect(actCreateExperiment, SIGNAL(triggered()), this, SLOT(OnContextMenuCreateNewExperiment()));
   }
 
 
   m_ContextMenu->popup(QCursor::pos());
 
 }
 
 void QmitkXnatTreeBrowserView::CleanUp()
 {
   m_Controls.wgtExperimentInfo->hide();
   m_Controls.wgtSubjectInfo->hide();
   m_Controls.wgtProjectInfo->hide();
   m_Controls.btnCreateXnatFolder->setEnabled(false);
   m_Controls.btnXnatDownload->setEnabled(false);
   m_Controls.btnXnatUpload->setEnabled(false);
   m_Controls.searchField->setEnabled(false);
   m_Controls.searchField->setText("");
   m_Controls.searchModeBox->setEnabled(false);
 }
 
 std::string QmitkXnatTreeBrowserView::ReplaceSpecialChars(const std::string& input) const
 {
   QString convertedString = QString(QUrl::toPercentEncoding(QString::fromStdString(input)));
   return  convertedString.toStdString();
 }
 
 void QmitkXnatTreeBrowserView::ItemSelected(const QModelIndex& index)
 {
   //TODO: CTK seems to ignore spaces while creating the http request. This will lead to corrupted http request that will fail.
   QVariant variant = m_TreeModel->data(index, Qt::UserRole);
   if (variant.isValid())
   {
     ctkXnatSession *session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
           mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
 
     ctkXnatObject* object = variant.value<ctkXnatObject*>();
     ctkXnatProject* project = dynamic_cast<ctkXnatProject*>(object);
     ctkXnatSubject* subject = dynamic_cast<ctkXnatSubject*>(object);
     ctkXnatExperiment* experiment = dynamic_cast<ctkXnatExperiment*>(object);
 
     if (project != nullptr)
     {
       m_Controls.wgtExperimentInfo->hide();
       m_Controls.wgtSubjectInfo->hide();
 
       m_Controls.wgtProjectInfo->SetProject(project);
       m_Controls.wgtProjectInfo->show();
     }
     else if (subject != nullptr)
     {
       QMap<QString, QString> paramMap;
       paramMap.insert("columns", "dob,gender,handedness,weight,height");
       QUuid requestID = session->httpGet(QString("%1/subjects").arg(subject->parent()->resourceUri()), paramMap);
       QList<QVariantMap> results = session->httpSync(requestID);
 
       foreach(const QVariantMap& propertyMap, results)
       {
         QMapIterator<QString, QVariant> it(propertyMap);
         bool isConcretSubject = false;
 
         if (it.hasNext())
         {
           it.next();
 
           QVariant var = it.value();
 
           // After CTK Change (subjectID = name) to (subjectID = ID)
           // CHANGE TO: if (var == subject->property("ID"))
           if (var == subject->property("URI").right(11))
           {
             isConcretSubject = true;
           }
           else
           {
             isConcretSubject = false;
           }
           it.toFront();
         }
 
         while (it.hasNext() && isConcretSubject)
         {
           it.next();
 
           QString  str = it.key().toLatin1().data();
           QVariant var = it.value();
 
           subject->setProperty(str, var);
         }
       }
       m_Controls.wgtExperimentInfo->hide();
       m_Controls.wgtProjectInfo->hide();
 
       m_Controls.wgtSubjectInfo->SetSubject(subject);
       m_Controls.wgtSubjectInfo->show();
     }
     else if (experiment != nullptr)
     {
       QMap<QString, QString> paramMap;
       paramMap.insert("columns", "date,time,scanner,modality");
       QUuid requestID = session->httpGet(QString("%1/experiments").arg(experiment->parent()->resourceUri()), paramMap);
       QList<QVariantMap> results = session->httpSync(requestID);
 
       foreach(const QVariantMap& propertyMap, results)
       {
         QMapIterator<QString, QVariant> it(propertyMap);
         bool isConcretExperiment = false;
 
         if (it.hasNext())
         {
           it.next();
 
           QVariant var = it.value();
 
           if (var == experiment->property("URI"))
           {
             isConcretExperiment = true;
           }
           else
           {
             isConcretExperiment = false;
           }
           it.toFront();
         }
 
         while (it.hasNext() && isConcretExperiment)
         {
           it.next();
 
           QString  str = it.key().toLatin1().data();
           QVariant var = it.value();
 
           experiment->setProperty(str, var);
         }
       }
 
       m_Controls.wgtSubjectInfo->hide();
       m_Controls.wgtProjectInfo->hide();
 
       m_Controls.wgtExperimentInfo->SetExperiment(experiment);
       m_Controls.wgtExperimentInfo->show();
     }
   }
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuCreateNewSubject()
 {
   QModelIndex index = m_Controls.treeView->currentIndex();
   QVariant variant = m_TreeModel->data(index, Qt::UserRole);
   if (variant.isValid())
   {
     QmitkXnatCreateObjectDialog* dialog = new QmitkXnatCreateObjectDialog(QmitkXnatCreateObjectDialog::SpecificType::SUBJECT);
     if (dialog->exec() == QDialog::Accepted)
     {
       ctkXnatProject* project = dynamic_cast<ctkXnatProject*>(variant.value<ctkXnatObject*>());
       ctkXnatSubject* subject = dynamic_cast<ctkXnatSubject*>(dialog->GetXnatObject());
       subject->setParent(project);
       try
       {
         subject->save();
       }
       catch(const ctkRuntimeException& exc)
       {
         //TODO: Implement isValid-flag to check if ctkRuntimeExceptio is valid http-exception.
         QmitkHttpStatusCodeHandler::HandleErrorMessage(exc.what());
         project->remove(subject);
         delete subject;
         return;
       }
 
       // Get xnat session from micro service
       ctkXnatSession* session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
             mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
 
       // Update View
       m_TreeModel->removeDataModel(session->dataModel());
 
       UpdateSession(session);
     }
   }
 }
 
 void QmitkXnatTreeBrowserView::OnContextMenuCreateNewExperiment()
 {
   QModelIndex index = m_Controls.treeView->currentIndex();
   QVariant variant = m_TreeModel->data(index, Qt::UserRole);
   if (variant.isValid())
   {
     QmitkXnatCreateObjectDialog* dialog = new QmitkXnatCreateObjectDialog(QmitkXnatCreateObjectDialog::SpecificType::EXPERIMENT);
     if (dialog->exec() == QDialog::Accepted)
     {
       ctkXnatSubject* subject = dynamic_cast<ctkXnatSubject*>(variant.value<ctkXnatObject*>());
       ctkXnatExperiment* experiment = dynamic_cast<ctkXnatExperiment*>(dialog->GetXnatObject());
       experiment->setParent(subject);
       experiment->setProperty("xsiType", experiment->imageModality());
 
       try
       {
         experiment->save();
       }
       catch(const ctkRuntimeException& exc)
       {
         QmitkHttpStatusCodeHandler::HandleErrorMessage(exc.what());
         subject->remove(experiment);
         delete experiment;
         return;
       }
 
       // Get xnat session from micro service
       ctkXnatSession* session = mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetService(
             mitk::org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()->GetServiceReference<ctkXnatSession>());
 
       // Update View
       m_TreeModel->removeDataModel(session->dataModel());
       UpdateSession(session);
     }
   }
 }
 
 void QmitkXnatTreeBrowserView::SetStatusInformation(const QString& text)
 {
   m_Controls.groupBox->setTitle(text);
   m_Controls.progressBar->setValue(0);
   m_Controls.groupBox->show();
 }
 
 void QmitkXnatTreeBrowserView::SessionTimedOutMsg()
 {
   ctkXnatSession* session = qobject_cast<ctkXnatSession*>(QObject::sender());
 
   if (session == nullptr)
     return;
 
   ctkXnatDataModel* dataModel = session->dataModel();
   m_TreeModel->removeDataModel(dataModel);
   m_Controls.treeView->reset();
   session->close();
   QMessageBox::warning(m_Controls.treeView, "Session Timeout", "The session timed out.");
 
   m_Controls.btnXnatConnect->setToolTip("Connect");
   m_Controls.btnXnatConnect->setIcon(QIcon(":/xnat-plugin/xnat-connect.png"));
 
   CleanUp();
 }
 
 void QmitkXnatTreeBrowserView::SessionTimesOutSoonMsg()
 {
   ctkXnatSession* session = qobject_cast<ctkXnatSession*>(QObject::sender());
 
   if (session == nullptr)
     return;
 
   QMessageBox msgBox;
   msgBox.setIcon(QMessageBox::Warning);
   msgBox.setWindowTitle("Session Timeout Soon");
   msgBox.setText("The session will time out in 1 minute.\nDo you want to renew the session?");
   msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
   msgBox.setDefaultButton(QMessageBox::No);
   msgBox.show();
   QTimer* timer = new QTimer(this);
   timer->start(60000);
   this->connect(timer, SIGNAL(timeout()), &msgBox, SLOT(reject()));
   if (msgBox.exec() == QMessageBox::Yes){
     session->renew();
   }
   timer->stop();
 }
diff --git a/Plugins/org.mitk.gui.qt.xnat/src/internal/org_mitk_gui_qt_xnatinterface_Activator.cpp b/Plugins/org.mitk.gui.qt.xnat/src/internal/org_mitk_gui_qt_xnatinterface_Activator.cpp
index a979d98d59..7f91ac33fe 100644
--- a/Plugins/org.mitk.gui.qt.xnat/src/internal/org_mitk_gui_qt_xnatinterface_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.xnat/src/internal/org_mitk_gui_qt_xnatinterface_Activator.cpp
@@ -1,66 +1,66 @@
 /*===================================================================
 
 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 "org_mitk_gui_qt_xnatinterface_Activator.h"
 #include "QmitkUploadToXNATAction.h"
 #include "QmitkXnatTreeBrowserView.h"
 #include "QmitkXnatConnectionPreferencePage.h"
 
 #include <usGetModuleContext.h>
 #include <usModuleInitialization.h>
 
 US_INITIALIZE_MODULE
 
 namespace mitk {
 
 ctkPluginContext* org_mitk_gui_qt_xnatinterface_Activator::m_Context = nullptr;
 us::ModuleContext* org_mitk_gui_qt_xnatinterface_Activator::m_ModuleContext = nullptr;
 
 QmitkXnatSessionManager* org_mitk_gui_qt_xnatinterface_Activator::GetXnatSessionManager()
 {
   static QmitkXnatSessionManager manager;
   return &manager;
 }
 
 ctkPluginContext* org_mitk_gui_qt_xnatinterface_Activator::GetContext()
 {
   return m_Context;
 }
 
 us::ModuleContext* org_mitk_gui_qt_xnatinterface_Activator::GetXnatModuleContext()
 {
   return m_ModuleContext;
 }
 
 void org_mitk_gui_qt_xnatinterface_Activator::start(ctkPluginContext* context)
 {
   this->m_Context = context;
   this->m_ModuleContext = us::GetModuleContext();
 
   BERRY_REGISTER_EXTENSION_CLASS(QmitkXnatTreeBrowserView, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkXnatConnectionPreferencePage, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkUploadToXNATAction, context)
 }
 
 void org_mitk_gui_qt_xnatinterface_Activator::stop(ctkPluginContext* context)
 {
   Q_UNUSED(context)
   Q_UNUSED(us::GetModuleContext())
-  this->m_Context = 0;
-  this->m_ModuleContext = 0;
+  this->m_Context = nullptr;
+  this->m_ModuleContext = nullptr;
 }
 
 }
diff --git a/Plugins/org.mitk.matchpoint.core.helper/src/internal/MatchPointBrowserPreferencesPage.cpp b/Plugins/org.mitk.matchpoint.core.helper/src/internal/MatchPointBrowserPreferencesPage.cpp
index 56254f8163..8b0a4311c8 100644
--- a/Plugins/org.mitk.matchpoint.core.helper/src/internal/MatchPointBrowserPreferencesPage.cpp
+++ b/Plugins/org.mitk.matchpoint.core.helper/src/internal/MatchPointBrowserPreferencesPage.cpp
@@ -1,160 +1,160 @@
 /*===================================================================
 
 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 "MatchPointBrowserPreferencesPage.h"
 #include "MatchPointBrowserConstants.h"
 
 #include <QWidget>
 #include <QLabel>
 #include <QFormLayout>
 #include <QCheckBox>
 #include <QComboBox>
 #include <QMessageBox>
 #include <QSpinBox>
 #include <ctkDirectoryButton.h>
 #include <berryIPreferencesService.h>
 #include <berryPlatform.h>
 
 #include "QmitkDirectoryListWidget.h"
 #include "QmitkFileListWidget.h"
 
 //-----------------------------------------------------------------------------
 MatchPointBrowserPreferencesPage::MatchPointBrowserPreferencesPage()
-: m_MainControl(0)
-, m_AlgDirectories(0)
-, m_AlgFiles(0)
-, m_LoadFromHomeDir(0)
-, m_LoadFromCurrentDir(0)
-, m_LoadFromApplicationDir(0)
-, m_LoadFromAutoLoadPathDir(0)
-, m_BrowserPreferencesNode(0)
+: m_MainControl(nullptr)
+, m_AlgDirectories(nullptr)
+, m_AlgFiles(nullptr)
+, m_LoadFromHomeDir(nullptr)
+, m_LoadFromCurrentDir(nullptr)
+, m_LoadFromApplicationDir(nullptr)
+, m_LoadFromAutoLoadPathDir(nullptr)
+, m_BrowserPreferencesNode(nullptr)
 {
 
 }
 
 
 //-----------------------------------------------------------------------------
 MatchPointBrowserPreferencesPage::~MatchPointBrowserPreferencesPage()
 {
 
 }
 
 
 //-----------------------------------------------------------------------------
 void MatchPointBrowserPreferencesPage::Init(berry::IWorkbench::Pointer )
 {
 
 }
 
 
 //-----------------------------------------------------------------------------
 void MatchPointBrowserPreferencesPage::CreateQtControl(QWidget* parent)
 {
   berry::IPreferencesService* prefService
     = berry::Platform::GetPreferencesService();
 
   QString id = tr("/") + tr(MatchPointBrowserConstants::VIEW_ID.c_str());
   m_BrowserPreferencesNode = prefService->GetSystemPreferences()->Node(id);
 
   m_MainControl = new QWidget(parent);
 
   m_AlgDirectories = new QmitkDirectoryListWidget(m_MainControl);
   m_AlgDirectories->m_Label->setText("Select directories to scan:");
   m_AlgFiles = new QmitkFileListWidget(m_MainControl);
   m_AlgFiles->m_Label->setText("Select additional executables:");
   m_DebugOutput = new QCheckBox(m_MainControl);
 
   m_LoadFromAutoLoadPathDir = new QCheckBox(m_MainControl);
   m_LoadFromApplicationDir = new QCheckBox(m_MainControl);
   m_LoadFromHomeDir = new QCheckBox(m_MainControl);
   m_LoadFromCurrentDir = new QCheckBox(m_MainControl);
 
   QFormLayout *formLayout = new QFormLayout;
   formLayout->addRow("show debug output:", m_DebugOutput);
   formLayout->addRow("scan home directory:", m_LoadFromHomeDir);
   formLayout->addRow("scan current directory:", m_LoadFromCurrentDir);
   formLayout->addRow("scan installation directory:", m_LoadFromApplicationDir);
   formLayout->addRow("scan MAP_MDRA_LOAD_PATH:", m_LoadFromAutoLoadPathDir);
   formLayout->addRow("additional algorithm directories:", m_AlgDirectories);
   formLayout->addRow("additional algorithms:", m_AlgFiles);
 
   m_MainControl->setLayout(formLayout);
 
   this->Update();
 }
 
 
 //-----------------------------------------------------------------------------
 QWidget* MatchPointBrowserPreferencesPage::GetQtControl() const
 {
   return m_MainControl;
 }
 
 
 //-----------------------------------------------------------------------------
 QString MatchPointBrowserPreferencesPage::ConvertToString( const QStringList& list )
 {
   QString output;
   for (int i = 0; i < list.count(); i++)
   {
     QString path = list[i] + ";";
     output = output + path;
   }
   return output;
 }
 
 //-----------------------------------------------------------------------------
 bool MatchPointBrowserPreferencesPage::PerformOk()
 {
   m_BrowserPreferencesNode->PutBool(MatchPointBrowserConstants::DEBUG_OUTPUT_NODE_NAME.c_str(), m_DebugOutput->isChecked());
   m_BrowserPreferencesNode->PutBool(MatchPointBrowserConstants::LOAD_FROM_APPLICATION_DIR.c_str(), m_LoadFromApplicationDir->isChecked());
   m_BrowserPreferencesNode->PutBool(MatchPointBrowserConstants::LOAD_FROM_HOME_DIR.c_str(), m_LoadFromHomeDir->isChecked());
   m_BrowserPreferencesNode->PutBool(MatchPointBrowserConstants::LOAD_FROM_CURRENT_DIR.c_str(), m_LoadFromCurrentDir->isChecked());
   m_BrowserPreferencesNode->PutBool(MatchPointBrowserConstants::LOAD_FROM_AUTO_LOAD_DIR.c_str(), m_LoadFromAutoLoadPathDir->isChecked());
 
   QString paths = this->ConvertToString(m_AlgDirectories->directories());
   m_BrowserPreferencesNode->Put(MatchPointBrowserConstants::MDAR_DIRECTORIES_NODE_NAME.c_str(), paths);
 
   QString modules = this->ConvertToString(m_AlgFiles->files());
   m_BrowserPreferencesNode->Put(MatchPointBrowserConstants::MDAR_FILES_NODE_NAME.c_str(), modules);
 
   return true;
 }
 
 
 //-----------------------------------------------------------------------------
 void MatchPointBrowserPreferencesPage::PerformCancel()
 {
 }
 
 
 //-----------------------------------------------------------------------------
 void MatchPointBrowserPreferencesPage::Update()
 {
   m_DebugOutput->setChecked(m_BrowserPreferencesNode->GetBool(MatchPointBrowserConstants::DEBUG_OUTPUT_NODE_NAME.c_str(), false));
   m_LoadFromApplicationDir->setChecked(m_BrowserPreferencesNode->GetBool(MatchPointBrowserConstants::LOAD_FROM_APPLICATION_DIR.c_str(), true));
   m_LoadFromHomeDir->setChecked(m_BrowserPreferencesNode->GetBool(MatchPointBrowserConstants::LOAD_FROM_HOME_DIR.c_str(), false));
   m_LoadFromCurrentDir->setChecked(m_BrowserPreferencesNode->GetBool(MatchPointBrowserConstants::LOAD_FROM_CURRENT_DIR.c_str(), false));
   m_LoadFromAutoLoadPathDir->setChecked(m_BrowserPreferencesNode->GetBool(MatchPointBrowserConstants::LOAD_FROM_AUTO_LOAD_DIR.c_str(), false));
 
   QString paths = m_BrowserPreferencesNode->Get(MatchPointBrowserConstants::MDAR_DIRECTORIES_NODE_NAME.c_str(), tr(""));
   QStringList directoryList = paths.split(";", QString::SkipEmptyParts);
   m_AlgDirectories->setDirectories(directoryList);
 
   QString files = m_BrowserPreferencesNode->Get(MatchPointBrowserConstants::MDAR_FILES_NODE_NAME.c_str(), tr(""));
   QStringList fileList = files.split(";", QString::SkipEmptyParts);
   m_AlgFiles->setFiles(fileList);
 }
diff --git a/Plugins/org.mitk.matchpoint.core.helper/src/internal/QmitkDirectoryListWidget.h b/Plugins/org.mitk.matchpoint.core.helper/src/internal/QmitkDirectoryListWidget.h
index 4abeacba46..34483c3098 100644
--- a/Plugins/org.mitk.matchpoint.core.helper/src/internal/QmitkDirectoryListWidget.h
+++ b/Plugins/org.mitk.matchpoint.core.helper/src/internal/QmitkDirectoryListWidget.h
@@ -1,58 +1,58 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) University College London (UCL).
 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 QMITKDIRECTORYLISTWIDGET_H
 #define QMITKDIRECTORYLISTWIDGET_H
 
 #include "ui_QmitkPathListWidget.h"
 #include <QWidget>
 
 /**
  * \class QmitkDirectoryListWidget
  * \brief Widget to contain a ctkPathListWidget and a ctkPathListButtonsWidget
  * and provide simple directory access for readable, executable directories.
  * \author Matt Clarkson (m.clarkson@ucl.ac.uk)
  * \ingroup org_mitk_gui_qt_cmdlinemodules_internal
  */
 class QmitkDirectoryListWidget : public QWidget, public Ui::QmitkPathListWidget
 {
   Q_OBJECT
 
 public:
-  QmitkDirectoryListWidget(QWidget* parent=0);
+  QmitkDirectoryListWidget(QWidget* parent=nullptr);
 
   /**
    * \brief Get all directory entries.
    * \param absolutePath If <code>true</code>, resolve all entries to absolute paths.
    * \return A list of all directory entries.
    */
   QStringList directories(bool absolutePath = false) const;
 
   /**
    * \brief Sets the list of directory entries.
    * \param paths The new path list.
    */
   void setDirectories(const QStringList& paths);
 
 Q_SIGNALS:
 
   void pathsChanged(const QStringList&, const QStringList&);
 
 private Q_SLOTS:
 
   void OnPathsChanged(const QStringList&, const QStringList&);
 };
 
 #endif // QMITKDIRECTORYLISTWIDGET_H
diff --git a/Plugins/org.mitk.matchpoint.core.helper/src/internal/QmitkFileListWidget.h b/Plugins/org.mitk.matchpoint.core.helper/src/internal/QmitkFileListWidget.h
index 7339cb8a95..31fa33081c 100644
--- a/Plugins/org.mitk.matchpoint.core.helper/src/internal/QmitkFileListWidget.h
+++ b/Plugins/org.mitk.matchpoint.core.helper/src/internal/QmitkFileListWidget.h
@@ -1,58 +1,58 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) University College London (UCL).
 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 QMITKFILELISTWIDGET_H
 #define QMITKFILELISTWIDGET_H
 
 #include "ui_QmitkPathListWidget.h"
 #include <QWidget>
 
 /**
  * \class QmitkFileListWidget
  * \brief Widget to contain a ctkPathListWidget and a ctkPathListButtonsWidget
  * and provide simple file access for readable, executable files.
  * \author Matt Clarkson (m.clarkson@ucl.ac.uk)
  * \ingroup org_mitk_gui_qt_cmdlinemodules_internal
  */
 class QmitkFileListWidget : public QWidget, public Ui::QmitkPathListWidget
 {
   Q_OBJECT
 
 public:
-  QmitkFileListWidget(QWidget* parent=0);
+  QmitkFileListWidget(QWidget* parent=nullptr);
 
   /**
    * \brief Get all file entries.
    * \param absolutePath If <code>true</code>, resolve all entries to absolute paths.
    * \return A list of all file entries.
    */
   QStringList files(bool absolutePath = false) const;
 
   /**
    * \brief Sets the list of file entries.
    * \param paths The new path list.
    */
   void setFiles(const QStringList& paths);
 
 Q_SIGNALS:
 
   void pathsChanged(const QStringList&, const QStringList&);
 
 private Q_SLOTS:
 
   void OnPathsChanged(const QStringList&, const QStringList&);
 };
 
 #endif // QMITKDIRECTORYLISTWIDGET_H
diff --git a/Utilities/IpSegmentation/ipSegmentation.h b/Utilities/IpSegmentation/ipSegmentation.h
index 31a689fb32..834826196f 100644
--- a/Utilities/IpSegmentation/ipSegmentation.h
+++ b/Utilities/IpSegmentation/ipSegmentation.h
@@ -1,213 +1,213 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 /*! \mainpage
 
   \author Tobias Kunert, Thomas Boettger, Tobias Heimann (Deutsches Krebsforschungszentrum, Heidelberg)
   \date October 2002
 
   The ipMITKSegmentation library manages the results of the
   segmentation process. It provides basic capabilities
   to modify segmentation images. It includes also an
   undo mechanism which allows to trace back the changes. 
 
 */
 
 #ifndef IPSEGMENTATION_H
 #define IPSEGMENTATION_H
 
 #include <mitkIpPic.h>
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C"
 {
 #endif
 
   /*!
     \brief Defines the data type of the segmentation images.
     */
 #define ipMITKSegmentationTYPE mitkIpUInt1_t
 #define ipMITKSegmentationTYPE_ID mitkIpPicUInt
 #define ipMITKSegmentationBPE 8
 #define tagSEGMENTATION_EMPTY "SEGMENTATION_EMPTY"
 
   /*!
     \brief Initializes the segmentation.
     @param image the original image which will be segmented
     @return the segmentation.
     */
   extern mitkIpPicDescriptor* ipMITKSegmentationNew (mitkIpPicDescriptor* image);
 
   /*!
     \brief Destroys the segmentation.
     @param segmentation the segmentation.
     */
   extern void ipMITKSegmentationFree (mitkIpPicDescriptor* segmentation);
 
   /*!
     \brief Clears the segmentation data, i.e. the pixels will
     be set to zero.
     @param segmentation the segmentation
     */
   extern void ipMITKSegmentationClear (mitkIpPicDescriptor* segmentation);
 
   /*!
     \brief Interpolates the shape of segmentations.
     @param pic1,pic2 the images of the segmentation
     @param ratio the ratio of the images, the ratios 0.0 and 1.0 will 
     produce pic1 and pic2, accordingly.
     */
   extern mitkIpPicDescriptor* ipMITKSegmentationInterpolate (mitkIpPicDescriptor* pic1, mitkIpPicDescriptor* pic2, const mitkIpFloat4_t ratio);
 
   /*!
     \brief The type of logical operation.
     */
   enum LogicalOp {
     IPSEGMENTATION_OP    /*! copy of input image */,
     IPSEGMENTATION_AND   /*! logical and operator */,
     IPSEGMENTATION_OR    /*! the or operator */,
     IPSEGMENTATION_XOR   /*! the exclusive-or operator */
   };
 
   /*!
     \brief Combines the region with the segmentation image.
     @param points the array of points, each point is represented
     by a 2-D vector (x, y)
     @param segmentation the segmentation.
     @param num the number of points
     @param mask the image which restricts the operation to a particular region 
     @param operation the operation which will be performed (see above)
     @param value the operand value of the operation
     \note The last point is automatically connected with the first one.
     */
   extern void ipMITKSegmentationCombineRegion (mitkIpPicDescriptor* segmentation, const mitkIpInt4_t* const points, const int num, mitkIpPicDescriptor* mask, const int operation, int value);
 
   /*!
     \brief Enables the undo operation for the specified segmentation.
     @param segmentation the segmentation 
     @param level the number of undo levels
     */
   extern void ipMITKSegmentationUndoEnable (mitkIpPicDescriptor* segmentation, const mitkIpUInt1_t level);
 
   /*!
     \brief Disables the undo operation for the specified segmentation.
     The available data will be discarded.
     @param segmentation the segmentation 
     */
   extern void ipMITKSegmentationUndoDisable (mitkIpPicDescriptor* segmentation);
 
   /*!
     \brief Checks if the undo operation is enabled.
     @param segmentation the segmentation
     */
   extern mitkIpBool_t ipMITKSegmentationUndoIsEnabled (mitkIpPicDescriptor* segmentation);
 
   /*!
     \brief Checks if any data for undo is available.
     pending?
     */
   extern mitkIpBool_t ipMITKSegmentationUndoAvailable (mitkIpPicDescriptor* segmentation);
 
   /*!
     \brief Save the segmentation image before it is changed.
     @param segmentation the segmentation
     */
   extern void ipMITKSegmentationUndoSave (mitkIpPicDescriptor* segmentation);
 
   /*!
     \brief Steps to the previous undo level. The data which has been saved 
     before the last modifications will be restored.
     */
   extern void ipMITKSegmentationUndo (mitkIpPicDescriptor* segmentation);
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }
 #endif
 
 /*!
   Starts a 4 neighbourhood region growing at startOfs (y*picWidth+x) of the 2D image src.
   If relativeBounds is true, the region grows in [base-lowerBound, base+upperBound], in which base is the average
   color of the 9 pixels around startOfs. If relativeBounds is false, the region grows in [lowerBound, upperBound].
   If maxIterations is > 0, the growing process is stopped after maxIterations.
   If segBuffer is 0, new memory for the segmented image is allocated and returned, else the segBuffer is used
   to store the result (has to be an 8-bit datatype, e.g. mitkIpUInt1_t).
   histBuffer must be 0 or a pointer to a 16-bit mitkIpPicUInt image of the same size as src. In case of the latter, 
   history data is written to that buffer: the seed pixel gets a 1, all direct neighbours 2 etc. The buffer is
   not cleared in this function and can thus hold history data of several growing processes in different areas.
   */
-extern mitkIpPicDescriptor* ipMITKSegmentationGrowRegion4N( mitkIpPicDescriptor *src, int startOfs, bool relativeBounds, float lowerBound, float upperBound, int maxIterations, mitkIpPicDescriptor *segBuffer, mitkIpPicDescriptor *histBuffer=0 );
+extern mitkIpPicDescriptor* ipMITKSegmentationGrowRegion4N( mitkIpPicDescriptor *src, int startOfs, bool relativeBounds, float lowerBound, float upperBound, int maxIterations, mitkIpPicDescriptor *segBuffer, mitkIpPicDescriptor *histBuffer=nullptr );
 
 /*!
   Same as the other ipMITKSegmentationGrowRegion4N with two additional return values:
   contourOfs holds the lowest point of the resulting region and is thus guaranteed to be part of the contour
   Take care: if the region could not grow at all (e.g. with fixed borders) contourOfs will be -1 !!!
   startCol holds the color that was used as base if relativeBounds is true
   */
-extern mitkIpPicDescriptor* ipMITKSegmentationGrowRegion4N( mitkIpPicDescriptor *src, int startOfs, bool relativeBounds, float lowerBound, float upperBound, int maxIterations, mitkIpPicDescriptor *segBuffer, int &contourOfs, float &startCol, mitkIpPicDescriptor *histBuffer=0 );
+extern mitkIpPicDescriptor* ipMITKSegmentationGrowRegion4N( mitkIpPicDescriptor *src, int startOfs, bool relativeBounds, float lowerBound, float upperBound, int maxIterations, mitkIpPicDescriptor *segBuffer, int &contourOfs, float &startCol, mitkIpPicDescriptor *histBuffer=nullptr );
 
 /*!
   Replaces the 4 neighbourhood region around startOfs (y*picWidth+x) of the 2D segmented image seg with newValue.
   Seg has to be an 8-bit datatype, e.g. mitkIpUInt1_t.
   Returns the number of replaced pixels. If newValue is the same as the old value, the function returns 0.
   */
 extern int ipMITKSegmentationReplaceRegion4N( mitkIpPicDescriptor *seg, int startOfs, mitkIpInt1_t newValue );
 
 /*!
   Same as above, but for the 8 neighbourhood contour.
   */
-extern float* ipMITKSegmentationGetContour8N( const mitkIpPicDescriptor *seg, int startOfs, int &numPoints, int &sizeBuffer, float *pointBuffer=0 );
+extern float* ipMITKSegmentationGetContour8N( const mitkIpPicDescriptor *seg, int startOfs, int &numPoints, int &sizeBuffer, float *pointBuffer=nullptr );
 
 
 typedef struct {
   float *traceline;    // x/y points describing the calculated path - memory has to be freed!
   bool  *onGradient;   // flags for each point if path was calculated based on gradient (true) or on max distance (false) - memory has to be freed!
   int    numPoints;    // number of points in the path
   int    absMin;       // indexes the point at the narrowest part of the path
   bool  cutIt;         // true if a leak has been found
   float cutCoords[4];  // x1,y1,x2,y2 of the two contour points where the leak can be cut
   float *deleteCurve;  // x/y points of the closed contour describing the leak region
   int   deleteSize;    // number of points in this contour
 } tCutResult;
 
 /*!
   Calculates a path from ofs to the origin of the growing process, when possible on the skeleton of the
   segmented area. The narrowest part of this path is used to create two cut points that are part of the contour
   and can later be used to split the segmentation. This funtion is useful for detecting and removing leaks in
   region growing.
   */
 extern tCutResult ipMITKSegmentationGetCutPoints( mitkIpPicDescriptor *seg, mitkIpPicDescriptor *history, int ofs );
 
 /*!
   Creates a grower history (i.e. the order in which a region grower would have segmented the area) of the given
   segmentation, origin of the grower is startOfs. histBuffer must be a 16bit unsigned int or 0, in the latter
   case the pic is created.
   */
 extern mitkIpPicDescriptor* ipMITKSegmentationCreateGrowerHistory( mitkIpPicDescriptor *seg, int startOfs, mitkIpPicDescriptor *histBuffer );
 
 /*!
   Splits a contour in two parts. contour is the original contour, cutCoords a pointer to an x1-y1-x2-y2 array that
   specifies the two points where the contour should be cut (these cutpoints must be points of the original contour!).
   part1 and part2 have to be float arrays of a sufficient size to store the two parts. The sizes of the two parts
   are returned in size1 and size2.
   */
 extern void ipMITKSegmentationSplitContour( float *contour, int sizeContour, float *cutCoords, float *part1, int &size1, float *part2, int &size2 );
 
 /*!
   Returns true if the specified point lies insede the contour, else returns false.
   */
 extern bool ipMITKSegmentationIsInsideContour( float *contour, int sizeContour, float x, float y );
 
 #endif
diff --git a/Utilities/IpSegmentation/ipSegmentationContourExtraction.cpp b/Utilities/IpSegmentation/ipSegmentationContourExtraction.cpp
index dfa1f88ea1..7985df9ad9 100755
--- a/Utilities/IpSegmentation/ipSegmentationContourExtraction.cpp
+++ b/Utilities/IpSegmentation/ipSegmentationContourExtraction.cpp
@@ -1,198 +1,198 @@
 /*===================================================================
 
 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 <mitkIpPicTypeMultiplex.h>
 #include "ipSegmentation.h"
 
 
 // only make macros available in local scope:
 namespace {
 
 // returns true if segmentation pixel at ofs is set, includes check for border pixels, i.e. border pixels do not result in returning true
 #define SEGSET(ofs) (              \
 ((ofs)>=0 && (ofs)<maxOfs) &&          \
 ( *(((PicType*)seg->data) + (ofs)) != 0 ) &&  \
 ( (ofs)%line != 0 || (pos+1)%line != 0 ) &&    \
 ( (ofs+1)%line != 0 || (pos)%line != 0 )      \
 )
 
 
 // appends a point to result, sets finished to true if this point is the same as the first one
 // allocates new momory if necessary
 #define ADD_CONTOUR_POINT            \
 result[numPts*2]   = xPos+xCorner[dir];      \
 result[numPts*2+1] = yPos+yCorner[dir];      \
 if (result[numPts*2]==result[0] && result[numPts*2+1]==result[1] && numPts>0) finished = true; \
 numPts++;                    \
 if (numPts==resSize) {              \
   resSize+=16+resSize/2;            \
   result = (float*)realloc( result, resSize*2*sizeof(float) ); \
   if (!result) finished = true;        \
 }
 
 }
 
 template<typename PicType>
 float* tmGetContour4N( const mitkIpPicDescriptor *seg, int startOfs, int &numPts, int &resSize, float *result )
 // returns the number of contour points (xy-pairs) in result
 // optimized macros: DON'T TOUCH THE CODE (removed smiley, this is not funny but cruel for any maintainer!)
 {
   numPts = 0;
   int line   = seg->n[0];
   int maxOfs = seg->n[0] * seg->n[1];
 
   int straight[4]  = { 1, -line, -1, line };
   int right[4]  = { line, 1, -line, -1 };
   float xMod[4]    = { 1.0, 0.0, -1.0, 0.0 };
   float yMod[4]    = { 0.0, -1.0, 0.0, 1.0 };
   float xCorner[4]  = { 1.0, 1.0, 0.0, 0.0 };
   float yCorner[4]  = { 1.0, 0.0, 0.0, 1.0 };
 
   int dir = 0;
   int pos = startOfs;
   float xPos = (float)(pos % line);
   float yPos = (float)(pos / line);
 
   while ( dir<4 && SEGSET( pos+right[dir] ) ) dir++;
   if (dir==4) return result;  // no contour pixel
 
   bool finished = false;
-  if (result==0) {
+  if (result==nullptr) {
     resSize = 2048;
     result = (float*)malloc( resSize*2*sizeof(float) );
   }
 
   do {
     if ( SEGSET( pos+right[dir] ) ) {
       // modify direction (turn right):
       dir = (dir-1) & 3;
       // modify position:
       pos  += straight[dir];
       xPos += xMod[dir];
       yPos += yMod[dir];
     }
     else if ( SEGSET( pos+straight[dir] ) ) {
       ADD_CONTOUR_POINT
       // modify position:
       pos += straight[dir];
       xPos += xMod[dir];
       yPos += yMod[dir];
     }
     else {
       ADD_CONTOUR_POINT
       // modify direction (turn left):
       dir = (dir+1) & 3;
     }
   } while (!finished);
   return result;
 }
 
 
 float* ipMITKSegmentationGetContour4N( const mitkIpPicDescriptor *seg, int startOfs, int &numPoints, int &sizeBuffer, float *pointBuffer )
 {
   float *newBuffer = nullptr;
   mitkIpPicTypeMultiplexR4( tmGetContour4N, seg, newBuffer, startOfs, numPoints, sizeBuffer, pointBuffer );
   return newBuffer;
 }
 
 
 template<typename PicType>
 float* tmGetContour8N( const mitkIpPicDescriptor *seg, int startOfs, int &numPts, int &resSize, float *result )
 // returns the number of contour points (xy-pairs) in result
 // optimized macros: DON'T TOUCH THE CODE ;-)
 {
   numPts = 0;
   int line   = seg->n[0];               // width of segmentation in pixels
   int maxOfs = seg->n[0] * seg->n[1];  // memory offset of pixel just beyond bottom-right-most pixel of segmentation (not a valid offset)
 
   int straight[4]  = { 1, -line, -1, line };  // right, top, left, down   (memory offsets)
   int right[4]  = { line, 1, -line, -1 };     // down, right, top, left
   float xMod[4]    = { 1.0, 0.0, -1.0, 0.0 };
   float yMod[4]    = { 0.0, -1.0, 0.0, 1.0 };
   float xCorner[4]  = { 1.0, 1.0, 0.0, 0.0 };
   float yCorner[4]  = { 1.0, 0.0, 0.0, 1.0 };
 
   int dir = 0;
   int pos = startOfs;    // initial position, this is where the contour search starts
   float xPos = (float)(pos % line); // calculate x and y from the memory offset
   float yPos = (float)(pos / line);
 
   while ( dir<4 && SEGSET( pos+right[dir] ) ) dir++;
   if (dir==4) {
     // check diagonal pixels:
     dir = 0;
     while ( dir<4 && SEGSET( pos+right[dir]+straight[dir] ) ) dir++;
     if (dir==4) return result;  // no contour pixel
     // chose next suitable neighbour:
     pos  += straight[dir];
     xPos += xMod[dir];
     yPos += yMod[dir];
   }
 
   bool finished = false;
-  if (result==0) {
+  if (result==nullptr) {
     resSize = 2048;
     result = (float*)malloc( resSize*2*sizeof(float) );
   }
 
   // here xPos,yPos are on some pixel next to a segmentation pixel. Where is "next to"? This is defined by the value of dir and the offsets in right[dir].
 
   // tries to complete the contour until a point is added that is identical to the first point
   do {
     if ( SEGSET( pos+right[dir] ) ) {      // valgrind complaint: jump dependent on uninitialized value (from my current understanding this could only be some pixel value outside the image
       // modify direction (turn right):    // this if will evaluate to true during the first iteration
       dir = (dir-1) & 3;   // ok, some weird logic selects a new direction
       // modify position:
       pos  += straight[dir];   // definitions of right and straight (plus xMod and yMod) lead to a counter-clockwise movement around the contour
       xPos += xMod[dir];
       yPos += yMod[dir];
     }
     else if ( SEGSET( pos+straight[dir] ) ) {
       ADD_CONTOUR_POINT
       // modify position:
       pos += straight[dir];
       xPos += xMod[dir];
       yPos += yMod[dir];
     }
     else if ( SEGSET( pos+right[dir]+straight[dir] ) ) {   // valgrind complaint: jump dependent on uninitialized value
       ADD_CONTOUR_POINT
       // modify position:
       pos += straight[dir];
       xPos += xMod[dir];
       yPos += yMod[dir];
       // modify direction (turn right):
       dir = (dir-1) & 3;
       // modify position second time:
       pos += straight[dir];
       xPos += xMod[dir];
       yPos += yMod[dir];
     }
     else {
       ADD_CONTOUR_POINT
       // modify direction (turn left):
       dir = (dir+1) & 3;
     }
   } while (!finished);
   return result;
 }
 
 
 float* ipMITKSegmentationGetContour8N( const mitkIpPicDescriptor *seg, int startOfs, int &numPoints, int &sizeBuffer, float *pointBuffer )
 {
   float *newBuffer = nullptr;
   mitkIpPicTypeMultiplexR4( tmGetContour8N, seg, newBuffer, startOfs, numPoints, sizeBuffer, pointBuffer );
   return newBuffer;
 }
diff --git a/Utilities/IpSegmentation/ipSegmentationGrowerHistory.cpp b/Utilities/IpSegmentation/ipSegmentationGrowerHistory.cpp
index 7bba6e9afc..ddbe5c21a2 100755
--- a/Utilities/IpSegmentation/ipSegmentationGrowerHistory.cpp
+++ b/Utilities/IpSegmentation/ipSegmentationGrowerHistory.cpp
@@ -1,125 +1,125 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <queue>
 #include "ipSegmentation.h"
 
 
 mitkIpPicDescriptor*
 ipMITKSegmentationCreateGrowerHistory( mitkIpPicDescriptor *seg, int startOfs, mitkIpPicDescriptor *histBuffer )
 {
   std::queue<int> ofsQueue;
 
-  if (!seg) return 0;
+  if (!seg) return nullptr;
   if (!histBuffer) {
     histBuffer = mitkIpPicCopyHeader( seg, histBuffer );
     histBuffer->type = mitkIpPicUInt;
     histBuffer->bpe = 16;
     mitkIpUInt4_t size = _mitkIpPicSize( histBuffer );
     histBuffer->data = malloc( size );
     memset( histBuffer->data, 0, size );  // clear buffer
   }
   else {
     // check if dimension of histBuffer is valid, if not: change it!
     if (histBuffer->n[0] != seg->n[0] || histBuffer->n[1] != seg->n[1]) {
       histBuffer->n[0] = seg->n[0];
       histBuffer->n[1] = seg->n[1];
       mitkIpUInt4_t size = _mitkIpPicSize( histBuffer );
       histBuffer->data = realloc( histBuffer->data, size );
-      if (histBuffer->data == 0) return 0;
+      if (histBuffer->data == nullptr) return nullptr;
       memset( histBuffer->data, 0, size );  // clear buffer
     }
   }
 
   // create a clear buffer to check wether a point has already been visited
   // (seg cannot be modifier and histBuffer can contain any value)
-  mitkIpPicDescriptor *flagBuffer = mitkIpPicCopyHeader( seg, 0 );
+  mitkIpPicDescriptor *flagBuffer = mitkIpPicCopyHeader( seg, nullptr );
   mitkIpUInt4_t size = _mitkIpPicSize( flagBuffer );
   flagBuffer->data = malloc( size );
   memset( flagBuffer->data, 0, size );
   *((mitkIpUInt1_t*)flagBuffer->data+startOfs) = 1;    // flag pixel as visited
 
   int line = seg->n[0];
   int maxOfs = (int)(line * seg->n[1]);
   int testOfs;
   mitkIpUInt1_t segVal, flagVal;
   int iteration = 0;
   int currentWave = 1;
   int nextWave = 0;
 
   ofsQueue.push( startOfs );
 
   while (!ofsQueue.empty()) {
     int nextOfs = ofsQueue.front();
     ofsQueue.pop();
     currentWave--;
     *((mitkIpUInt2_t*)histBuffer->data+nextOfs) = (mitkIpUInt2_t)(iteration+1);  // seed point should get history = 1
 
     // check right:
     testOfs = nextOfs+1;
     if (testOfs%line!=0) {
       segVal = *((mitkIpUInt1_t*)seg->data+testOfs);
       flagVal = *((mitkIpUInt1_t*)flagBuffer->data+testOfs);
       if ( segVal != 0 && flagVal == 0) {
         ofsQueue.push( testOfs );
         *((mitkIpUInt1_t*)flagBuffer->data+testOfs) = 1;    // flag pixel as visited
         nextWave++;
       }
     }
     // check top:
     testOfs = nextOfs-line;
     if (testOfs > 0) {
       segVal = *((mitkIpUInt1_t*)seg->data+testOfs);
       flagVal = *((mitkIpUInt1_t*)flagBuffer->data+testOfs);
       if ( segVal != 0 && flagVal == 0) {
         ofsQueue.push( testOfs );
         *((mitkIpUInt1_t*)flagBuffer->data+testOfs) = 1;    // flag pixel as visited
         nextWave++;
       }
     }
     // check left:
     testOfs = nextOfs-1;
     if (nextOfs%line!=0) {
       segVal = *((mitkIpUInt1_t*)seg->data+testOfs);
       flagVal = *((mitkIpUInt1_t*)flagBuffer->data+testOfs);
       if ( segVal != 0 && flagVal == 0) {
         ofsQueue.push( testOfs );
         *((mitkIpUInt1_t*)flagBuffer->data+testOfs) = 1;    // flag pixel as visited
         nextWave++;
       }
     }
     // check bottom:
     testOfs = nextOfs+line;
     if (testOfs < maxOfs) {
       segVal = *((mitkIpUInt1_t*)seg->data+testOfs);
       flagVal = *((mitkIpUInt1_t*)flagBuffer->data+testOfs);
       if ( segVal != 0 && flagVal == 0) {
         ofsQueue.push( testOfs );
         *((mitkIpUInt1_t*)flagBuffer->data+testOfs) = 1;    // flag pixel as visited
         nextWave++;
       }
     }
     // check for number of iterations:
     if (currentWave == 0) {
       currentWave = nextWave;
       nextWave = 0;
       iteration++;
     }
   }
 
   mitkIpPicFree( flagBuffer );
   return histBuffer;
 }
diff --git a/Utilities/IpSegmentation/ipSegmentationRegionCutter.cpp b/Utilities/IpSegmentation/ipSegmentationRegionCutter.cpp
index f6a0aea657..2021f5da8d 100755
--- a/Utilities/IpSegmentation/ipSegmentationRegionCutter.cpp
+++ b/Utilities/IpSegmentation/ipSegmentationRegionCutter.cpp
@@ -1,331 +1,331 @@
 /*===================================================================
 
 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 <mitkIpPicTypeMultiplex.h>
 #include <ANN/ANN.h>
 #include "ipSegmentation.h"
 
 
 
 static ANNkd_tree *annTree;
 static ANNpoint queryPt;
 static ANNidxArray nnIdx;
 static ANNdistArray dists;
 
 
 
 // find next pixel in ANN:
 #define QUERY_DIST(qOfs)                  \
   queryPt[0] = (float)(qOfs % line) + 0.5;        \
     queryPt[1] = (float)(qOfs / line) + 0.5;        \
     annTree->annkSearch( queryPt, 1, nnIdx, dists );
 
 
 #define PROCESS_PIXEL                        \
   histVal = *((mitkIpUInt2_t*)history->data+testOfs);          \
   segVal = *((mitkIpUInt1_t*)seg->data+testOfs);            \
   if ( segVal > 0 && histVal <= maxHist && testOfs!=oldOfs ) {  \
     grad = ipMITKSegmentationGetDistGradient( testOfs, seg );    \
     QUERY_DIST(testOfs)                      \
     if (grad<minGrad) {                      \
       minGrad = grad;                      \
       gradCand = testOfs;                    \
     }                              \
     if (dists[0] > maxDist) {                  \
       maxDist = dists[0];                    \
       candOfs = testOfs;                    \
     }                              \
   }
 
 
 float ipMITKSegmentationGetDistGradient( int ofs, mitkIpPicDescriptor *seg )
 {
   mitkIpUInt4_t unsignedOfs = ofs < 0 ? seg->n[0]*seg->n[1] - seg->n[0] : ofs;
   if (unsignedOfs < seg->n[0] || unsignedOfs >= seg->n[0]*seg->n[1] - seg->n[0]) // exclude image borders
   {
     return 1.0; // initialization value of minGrad (high gradient)
   }
   float x = (float)(ofs % seg->n[0]) + 0.5;
         float y = (float)(ofs / seg->n[0]) + 0.5;
   mitkIpUInt1_t segVal = 0; // initialize to stop valgrind's warning about "Conditional jump or move depends on uninitialised value(s)"
 
   queryPt[0] = x+1;    queryPt[1] = y;
     annTree->annkSearch( queryPt, 1, nnIdx, dists );
   float d1 = sqrt( dists[0] );  // right dist
   segVal = *((mitkIpUInt1_t*)seg->data+ofs+1);
   if (!segVal) d1 = -10.0;
   queryPt[0] = x-1;    queryPt[1] = y;
     annTree->annkSearch( queryPt, 1, nnIdx, dists );
   float d2 = sqrt( dists[0] );  // left dist
   segVal = *((mitkIpUInt1_t*)seg->data+ofs-1);
   if (!segVal) d2 = -10.0;
   queryPt[0] = x;      queryPt[1] = y+1;
     annTree->annkSearch( queryPt, 1, nnIdx, dists );
   float d3 = sqrt( dists[0] );  // lower dist
   segVal = *((mitkIpUInt1_t*)seg->data+ofs+seg->n[0]);
   if (!segVal) d3 = -10.0;
   queryPt[0] = x;      queryPt[1] = y-1;
     annTree->annkSearch( queryPt, 1, nnIdx, dists );
   float d4 = sqrt( dists[0] );  // upper dist
   segVal = *((mitkIpUInt1_t*)seg->data+ofs-seg->n[0]);
   if (!segVal) d4 = -10.0;
   float res = 0.5*(float)sqrt( (d1-d2)*(d1-d2) + (d3-d4)*(d3-d4) );
   return res;
 }
 
 
 
 tCutResult ipMITKSegmentationGetCutPoints( mitkIpPicDescriptor *seg, mitkIpPicDescriptor *history, int ofs )
 {
   bool debug(false);
   tCutResult res;
   int resContourSize = 5000;
   res.traceline = (float*)malloc( resContourSize*sizeof(float)*2 );
   res.onGradient = (bool*)malloc( resContourSize*sizeof(bool) );
   res.numPoints = 0;
   res.absMin = 0;
   res.cutIt = false;
-  res.deleteCurve = 0;
+  res.deleteCurve = nullptr;
 
   if (!history) return res;                  // no history!
   if (*((mitkIpUInt2_t*)history->data + ofs) == 0) return res;  // ofs not inside known history
 
   // get one point on the contour:
   mitkIpUInt1_t *ptr = (mitkIpUInt1_t*)seg->data + ofs;
     int endLine = ((ofs / seg->n[0]) + 1) * seg->n[0] -1;
   int contourOfs = ofs;
   while (contourOfs!=endLine && *ptr!=0) {
     ptr++;
     contourOfs++;
   }
   if (*ptr == 0) contourOfs--;  // get back on the contour!
 
   // extract the contour:
   int sizeContour, sizeBuffer;
   float *contour = ipMITKSegmentationGetContour8N( seg, contourOfs, sizeContour, sizeBuffer );
   // init ANN tree with contour points:
   queryPt    = annAllocPt( 2 );
     ANNpointArray dataPts  = annAllocPts( sizeContour, 2 );
     nnIdx    = new ANNidx[10];
     dists    = new ANNdist[10];
     for (int i=0; i<sizeContour; i++) {
         (dataPts[i])[0] = contour[2*i];
         (dataPts[i])[1] = contour[2*i+1];
     }
     annTree = new ANNkd_tree( dataPts, sizeContour, 2 );
 
   // trace to center:
   int line = history->n[0];
 
   int maxOfs = line * history->n[1];
   QUERY_DIST(ofs)
   float maxDist = dists[0];
   float minDist = 10000;  // current minimum distance from border
   float oldDist = 0;
   int candOfs = ofs;
   int nextOfs = -1;
   int oldOfs, testOfs, gradCand=-1;
   float grad, minGrad;
   bool skelettonReached = false;
   mitkIpUInt2_t histVal;
   mitkIpUInt1_t segVal;
   mitkIpUInt2_t maxHist = 10000;
   if (maxHist==0 && debug) printf( "maxHist = 0!\n" );
   do {
     oldOfs = nextOfs;
     nextOfs = candOfs;
     // store point info:
     if (res.numPoints < resContourSize) {
       res.traceline[2*res.numPoints] = (float)(nextOfs % line) + 0.5;
       res.traceline[2*res.numPoints+1] = (float)(nextOfs / line) + 0.5;
       if (nextOfs==gradCand) res.onGradient[res.numPoints] = true;
       else res.onGradient[res.numPoints] = false;
 
       if (debug)
       {
         printf( "(%.f,%.f): H=%i, G=%i\n", res.traceline[2*res.numPoints],
         res.traceline[2*res.numPoints+1],
         *((mitkIpUInt2_t*)history->data+nextOfs),
         res.onGradient[res.numPoints] );
       }
       res.numPoints++;
 
       if (res.numPoints == resContourSize)
       {
         resContourSize *= 2; // explodes, but such contours must be very strange
         res.traceline = (float*)realloc( res.traceline,  resContourSize*sizeof(float)*2 );
         res.onGradient = (bool*)realloc( res.onGradient, resContourSize*sizeof(bool) );
         if ((res.traceline == nullptr) || (res.onGradient == nullptr))
         {
           res.numPoints = 0;
           res.cutIt = false;
           return res;
         }
       }
     }
 
     maxHist = *((mitkIpUInt2_t*)history->data + nextOfs);  // don't exceed this history!
     maxDist = 0;  // clear maxDist
     minGrad = 1.0;  // clear minGrad
 
     int traceSinceMin = res.numPoints - 1 - res.absMin;
     float weight = 20.0 / (20.0+traceSinceMin);
     if (weight < 0.5) weight = 0.5;
     QUERY_DIST(nextOfs)
     if (!skelettonReached && dists[0] < oldDist) {
       skelettonReached = true;
                         if (debug) printf( "skeletton reached at %i, oldDist=%.1f, currentDist=%.1f\n",
         res.numPoints - 1, oldDist, dists[0] );
     }
     oldDist = dists[0];
     if (skelettonReached && weight*dists[0] < minDist) {
       minDist = dists[0];
       res.absMin = res.numPoints - 1;  // has already been increased
     }
 
     // check right:
     testOfs = nextOfs+1;
     if (testOfs%line!=0) {
       // check top right:
       PROCESS_PIXEL
       testOfs = nextOfs-line;
       if (testOfs > 0) {
         testOfs++;
         PROCESS_PIXEL
       }
       // check bottom right:
       testOfs = nextOfs+line;
       if (testOfs < maxOfs) {
         testOfs++;
         PROCESS_PIXEL
       }
     }
     // check top:
     testOfs = nextOfs-line;
     if (testOfs > 0) {
       PROCESS_PIXEL
     }
     // check left:
     testOfs = nextOfs-1;
     if (nextOfs%line!=0) {
       PROCESS_PIXEL
       // check top left:
       testOfs = nextOfs-line;
       if (testOfs > 0) {
         testOfs--;
         PROCESS_PIXEL
       }
       // check bottom left:
       testOfs = nextOfs+line;
       if (testOfs < maxOfs) {
         testOfs--;
         PROCESS_PIXEL
       }
     }
     // check bottom:
     testOfs = nextOfs+line;
     if (testOfs < maxOfs) {
       PROCESS_PIXEL
     }
     // check for run on gradient:
     if (minGrad < 0.5) {
       candOfs = gradCand;
                         if (debug) printf( "." );
     }
     else if (debug) printf( "x" );
   } while (candOfs != nextOfs && maxHist > 0);
 
   if (res.absMin < (res.numPoints-10)) {
     res.absMin += (int)(sqrt(minDist)/2.0);
 //  int cutX = (int)(res.traceline[2*res.absMin]-0.5);
 //  int cutY = (int)(res.traceline[2*res.absMin+1]-0.5);
 //  int cutOfs = cutX + line*cutY;
 //  histVal = *((mitkIpUInt2_t*)history->data+cutOfs);
 //  printf( "histVal at Cut=%i\n", histVal );
 //  if (histVal > 1) {
     res.cutIt = true;
     float cutXf = (float)res.traceline[2*res.absMin];
     float cutYf = (float)res.traceline[2*res.absMin+1];
     queryPt[0] = cutXf;
     queryPt[1] = cutYf;
     annTree->annkSearch( queryPt, 1, nnIdx, dists );
     int cutIdx1 = nnIdx[0];
     res.cutCoords[0] = contour[2*cutIdx1];
     res.cutCoords[1] = contour[2*cutIdx1+1];
     int cutIdx2 = cutIdx1;
     float minDist = 100000000;
     int testCnt = 0;
     for (int i=0; i<sizeContour; i++) {
       int idxDif = abs(cutIdx1-i);
       // take wraparound into account:
       if (idxDif > (sizeContour/2)) idxDif = sizeContour - idxDif;
       if ( idxDif > 50 ) {
         float dist = (cutXf-contour[2*i])*(cutXf-contour[2*i]) + (cutYf-contour[2*i+1])*(cutYf-contour[2*i+1]);
         if (dist < minDist) {
           minDist = dist;
           cutIdx2 = i;
         }
       }
       else testCnt++;
     }
     res.cutCoords[2] = contour[2*cutIdx2];
     res.cutCoords[3] = contour[2*cutIdx2+1];
     if (debug) printf( "idx1=%i, idx2=%i, %i pts not evaluated.\n", cutIdx1, cutIdx2, testCnt );
 
                 if ((res.cutCoords[0] == res.cutCoords[2]) &&
                     (res.cutCoords[1] == res.cutCoords[3]))
                 {
                   free( contour );
                   // free ANN stuff:
                   annDeallocPt( queryPt );
                   annDeallocPts( dataPts );
                   delete[] nnIdx;
                   delete[] dists;
                   delete annTree;
 
                   res.cutIt = false;
 
                   return res;
                 }
     float *curve1 = (float*)malloc( 2*sizeof(float)*sizeContour );
     float *curve2 = (float*)malloc( 2*sizeof(float)*sizeContour );
     int    sizeCurve1, sizeCurve2;
     ipMITKSegmentationSplitContour( contour, sizeContour, res.cutCoords, curve1, sizeCurve1, curve2, sizeCurve2 );
     float clickX = (float)(ofs % line) + 0.5;
     float clickY = (float)(ofs / line) + 0.5;
     if (ipMITKSegmentationIsInsideContour( curve1, sizeCurve1, clickX, clickY )) {
       res.deleteCurve = curve1;
       res.deleteSize = sizeCurve1;
       free( curve2 );
     }
     else {
       res.deleteCurve = curve2;
       res.deleteSize = sizeCurve2;
       free( curve1 );
     }
   }
 
 
   free( contour );
   // free ANN stuff:
   annDeallocPt( queryPt );
   annDeallocPts( dataPts );
   delete[] nnIdx;
   delete[] dists;
   delete annTree;
 
   return res;
 }
diff --git a/Utilities/IpSegmentation/ipSegmentationRegionGrower.cpp b/Utilities/IpSegmentation/ipSegmentationRegionGrower.cpp
index 2750055df1..ad339fbf07 100755
--- a/Utilities/IpSegmentation/ipSegmentationRegionGrower.cpp
+++ b/Utilities/IpSegmentation/ipSegmentationRegionGrower.cpp
@@ -1,222 +1,222 @@
 /*===================================================================
 
 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 <assert.h>
 #include <queue>
 #include <mitkIpPicTypeMultiplex.h>
 #include "ipSegmentation.h"
 
 /*
 Starts a 4 neighbourhood region growing at startOfs (y*picWidth+x) of the 2D image src.
 If relativeBounds is true, the region grows in [base-lowerBound, base+upperBound], in which base is the average
 color of the 9 pixels around startOfs. If relativeBounds is false, the region grows in [lowerBound, upperBound].
 If maxIterations is > 0, the growing process is stopped after maxIterations.
 If segBuffer is 0, new memory for the segmented image is allocated and returned, else the segBuffer is used
 to store the result (has to be an 8-bit datatype, e.g. mitkIpUInt1_t).
 histBuffer must be 0 or a pointer to a 16-bit mitkIpUInt1_t image of the same size as src. In case of the latter,
 history data is written to that buffer: the seed pixel gets a 1, all direct neighbours 2 etc. The buffer is
 not cleared in this function and can thus hold history data of several growing processes in different areas.
 */
 template<typename PicType>
 mitkIpPicDescriptor*
 tmGrowRegion4N( mitkIpPicDescriptor *src, int startOfs, bool relativeBounds, float lowerBoundFlt, float upperBoundFlt, int maxIterations, mitkIpPicDescriptor *segBuffer, int &contourOfs, float &startCol, mitkIpPicDescriptor *histBuffer )
 {
   PicType lowerBound = static_cast<PicType>(lowerBoundFlt);
   PicType upperBound = static_cast<PicType>(upperBoundFlt);
   std::queue<int> ofsQueue;
 
   if (maxIterations <= 0) maxIterations = 32000;
-  if (!src) return 0;
+  if (!src) return nullptr;
   if (!segBuffer) {
     segBuffer = mitkIpPicCopyHeader( src, segBuffer );
     segBuffer->type = mitkIpPicUInt;
     segBuffer->bpe = 8;
     mitkIpUInt4_t size = _mitkIpPicSize( segBuffer );
     segBuffer->data = malloc( size );
   }
   else {
     // check if dimension of segBuffer is valid, if not: change it!
     if (segBuffer->n[0] != src->n[0] || segBuffer->n[1] != src->n[1]) {
       segBuffer->n[0] = src->n[0];
       segBuffer->n[1] = src->n[1];
       mitkIpUInt4_t size = _mitkIpPicSize( segBuffer );
       segBuffer->data = realloc( segBuffer->data, size );
-      if (segBuffer->data == 0) return 0;
+      if (segBuffer->data == nullptr) return nullptr;
     }
   }
   if (histBuffer) {
     // check if dimension of histBuffer is valid, if not: change it!
     if (histBuffer->n[0] != src->n[0] || histBuffer->n[1] != src->n[1]) {
       histBuffer->n[0] = src->n[0];
       histBuffer->n[1] = src->n[1];
       mitkIpUInt4_t size = _mitkIpPicSize( histBuffer );
       histBuffer->data = realloc( histBuffer->data, size );
-      if (histBuffer->data == 0) return 0;
+      if (histBuffer->data == nullptr) return nullptr;
       memset( histBuffer->data, 0, size );  // clear buffer
     }
   }
 
   int line = segBuffer->n[0];
   int maxOfs = (int)(line * segBuffer->n[1]);
   //PicType *start = ((PicType*)src->data) + startOfs;
   // init borders:
   PicType lowest, highest;
   if (relativeBounds) {
 
     // average base color from 3x3 block:
     // check for edges of image
     int offset;
     int numberOfValidOffsets = 0;
     int baseCol = 0;
     offset = startOfs;           if ( (offset >= 0) && (offset < (int)(src->n[0] * src->n[1])) ) { baseCol += *((PicType*)(src->data)+offset); ++numberOfValidOffsets; }
     offset = startOfs+1;         if ( (offset >= 0) && (offset < (int)(src->n[0] * src->n[1])) ) { baseCol += *((PicType*)(src->data)+offset); ++numberOfValidOffsets; }
     offset = startOfs+1-line;    if ( (offset >= 0) && (offset < (int)(src->n[0] * src->n[1])) ) { baseCol += *((PicType*)(src->data)+offset); ++numberOfValidOffsets; }
     offset = startOfs-line;      if ( (offset >= 0) && (offset < (int)(src->n[0] * src->n[1])) ) { baseCol += *((PicType*)(src->data)+offset); ++numberOfValidOffsets; }
     offset = startOfs-1-line;    if ( (offset >= 0) && (offset < (int)(src->n[0] * src->n[1])) ) { baseCol += *((PicType*)(src->data)+offset); ++numberOfValidOffsets; }
     offset = startOfs-1;         if ( (offset >= 0) && (offset < (int)(src->n[0] * src->n[1])) ) { baseCol += *((PicType*)(src->data)+offset); ++numberOfValidOffsets; }
     offset = startOfs-1+line;    if ( (offset >= 0) && (offset < (int)(src->n[0] * src->n[1])) ) { baseCol += *((PicType*)(src->data)+offset); ++numberOfValidOffsets; }
     offset = startOfs+line;      if ( (offset >= 0) && (offset < (int)(src->n[0] * src->n[1])) ) { baseCol += *((PicType*)(src->data)+offset); ++numberOfValidOffsets; }
     offset = startOfs+1+line;    if ( (offset >= 0) && (offset < (int)(src->n[0] * src->n[1])) ) { baseCol += *((PicType*)(src->data)+offset); ++numberOfValidOffsets; }
 
     if ( numberOfValidOffsets > 0 )
       baseCol = (PicType)( (float)baseCol / (float)numberOfValidOffsets );
 
     lowest = baseCol - lowerBound;
     highest = baseCol + upperBound;
     startCol = (float)baseCol;
   }
   else {
     lowest = lowerBound;
     highest = upperBound;
     startCol = 0.0f;
   }
 
   memset( segBuffer->data, 0, _mitkIpPicSize(segBuffer) );  // clear buffer
 
   PicType value = *((PicType*)src->data+startOfs);
   if ( value >=lowest && value <=highest ) {
     ofsQueue.push( startOfs );
   }
 
   contourOfs = -1;
   int testOfs;
   mitkIpUInt1_t segVal;
   int iteration = 0;
   int currentWave = 1;
   int nextWave = 0;
 
   while (!ofsQueue.empty() && iteration<=maxIterations) {
     int nextOfs = ofsQueue.front();
     ofsQueue.pop();
     currentWave--;
     *((mitkIpUInt1_t*)segBuffer->data+nextOfs) = 1;
     if (histBuffer) {
       *((mitkIpUInt2_t*)histBuffer->data+nextOfs) = (mitkIpUInt2_t)(iteration+1);  // seed point should get history = 1
     }
     if (nextOfs > contourOfs) contourOfs = nextOfs;
     // check right:
     testOfs = nextOfs+1;
     if (testOfs%line!=0) {
       segVal = *((mitkIpUInt1_t*)segBuffer->data+testOfs);
       if ( segVal == 0 ) {
         value = *((PicType*)src->data+testOfs);
         if ( value >=lowest && value <=highest ) {
           ofsQueue.push( testOfs );
           nextWave++;
           *((mitkIpUInt1_t*)segBuffer->data+testOfs) = 2;
         }
       }
     }
     // check top:
     testOfs = nextOfs-line;
     if (testOfs > 0) {
       segVal = *((mitkIpUInt1_t*)segBuffer->data+testOfs);
       if ( segVal == 0 ) {
         value = *((PicType*)src->data+testOfs);
         if ( value >=lowest && value <=highest ) {
           ofsQueue.push( testOfs );
           nextWave++;
           *((mitkIpUInt1_t*)segBuffer->data+testOfs) = 2;
         }
       }
     }
     // check left:
     testOfs = nextOfs-1;
     if (nextOfs%line!=0) {
       segVal = *((mitkIpUInt1_t*)segBuffer->data+testOfs);
       if ( segVal == 0 ) {
         value = *((PicType*)src->data+testOfs);
         if ( value >=lowest && value <=highest ) {
           ofsQueue.push( testOfs );
           nextWave++;
           *((mitkIpUInt1_t*)segBuffer->data+testOfs) = 2;
         }
       }
     }
     // check bottom:
     testOfs = nextOfs+line;
     if (testOfs < maxOfs) {
       segVal = *((mitkIpUInt1_t*)segBuffer->data+testOfs);
       if ( segVal == 0 ) {
         value = *((PicType*)src->data+testOfs);
         if ( value >=lowest && value <=highest ) {
           ofsQueue.push( testOfs );
           nextWave++;
           *((mitkIpUInt1_t*)segBuffer->data+testOfs) = 2;
         }
       }
     }
     // check for number of iterations:
     if (currentWave == 0) {
       currentWave = nextWave;
       nextWave = 0;
       iteration++;
     }
   }
 
   return segBuffer;
 }
 
 
 mitkIpPicDescriptor*
 ipMITKSegmentationGrowRegion4N( mitkIpPicDescriptor *src, int startOfs, bool relativeBounds, float lowerBound, float upperBound, int maxIterations, mitkIpPicDescriptor *segBuffer, mitkIpPicDescriptor *histBuffer )
 {
-  mitkIpPicDescriptor *result = 0;
+  mitkIpPicDescriptor *result = nullptr;
   int contourOfs;
   float startCol;
 
   if (ipMITKSegmentationUndoIsEnabled (segBuffer)) {
     ipMITKSegmentationUndoSave (segBuffer);
   }
 
   mitkIpPicTypeMultiplexR9( tmGrowRegion4N, src, result, startOfs, relativeBounds, lowerBound, upperBound, maxIterations, segBuffer, contourOfs, startCol, histBuffer );
   return result;
 }
 
 
 
 mitkIpPicDescriptor*
 ipMITKSegmentationGrowRegion4N( mitkIpPicDescriptor *src, int startOfs, bool relativeBounds, float lowerBound, float upperBound, int maxIterations, mitkIpPicDescriptor *segBuffer, int &contourOfs, float &startCol, mitkIpPicDescriptor *histBuffer )
 {
-  mitkIpPicDescriptor *result = 0;
+  mitkIpPicDescriptor *result = nullptr;
 
   if (ipMITKSegmentationUndoIsEnabled (segBuffer)) {
     ipMITKSegmentationUndoSave (segBuffer);
   }
 
   mitkIpPicTypeMultiplexR9( tmGrowRegion4N, src, result, startOfs, relativeBounds, lowerBound, upperBound, maxIterations, segBuffer, contourOfs, startCol, histBuffer );
   return result;
 }