diff --git a/Modules/SemanticRelationsUI/include/QmitkPatientTableModel.h b/Modules/SemanticRelationsUI/include/QmitkPatientTableModel.h
index ec30915c9a..a63d0ab83b 100644
--- a/Modules/SemanticRelationsUI/include/QmitkPatientTableModel.h
+++ b/Modules/SemanticRelationsUI/include/QmitkPatientTableModel.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.
 
 ===================================================================*/
 
 #ifndef QMITKPATIENTTABLEMODEL_H
 #define QMITKPATIENTTABLEMODEL_H
 
 // semantic relations UI module
 #include "QmitkAbstractSemanticRelationsStorageModel.h"
 
 // semantic relations module
 #include <mitkSemanticTypes.h>
 
 // mitk core
 #include <mitkDataNode.h>
 
 // qt
 #include <QPixmap>
 #include <QStandardItemModel>
 
 /**
 * @brief The QmitkPatientTableModel is a subclass of the QmitkAbstractSemanticRelationsStorageModel and holds the semantic relations data of the currently selected case.
 *
 *   The QmitkPatientTableModel uses the 'data' function to return either the data node of a table cell or the thumbnail of the underlying image.
 *   The horizontal header of the table shows the control points of the current case and the vertical header of the table shows the information types of the current case.
 *   Using the 'GetFilteredData'-function of the SemanticRelations-class the model is able to retrieve the correct data node for each table entry.
 *
 *   Additionally the model creates and holds the QPixmaps of the known data nodes in order to return a thumbnail, if needed.
 */
 class QmitkPatientTableModel : public QmitkAbstractSemanticRelationsStorageModel
 {
   Q_OBJECT 
    
 public:
 
   QmitkPatientTableModel(QObject* parent = nullptr);
   ~QmitkPatientTableModel();
 
   //////////////////////////////////////////////////////////////////////////
   // overridden functions from QAbstractItemModel
   //////////////////////////////////////////////////////////////////////////
   virtual QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override;
   virtual QModelIndex parent(const QModelIndex& child) const override;
 
   virtual int rowCount(const QModelIndex& parent = QModelIndex()) const override;
   virtual int columnCount(const QModelIndex& parent = QModelIndex()) const override;
 
   virtual QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
 
-  virtual QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
+  virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
   virtual Qt::ItemFlags flags(const QModelIndex& index) const override;
   //////////////////////////////////////////////////////////////////////////
   /// end override
   /////////////////////////////////////////////////////////////////////////
 
   void SetNodeType(const std::string& nodeType);
 
 protected:
 
   // the following functions have to be overridden but are not implemented in this model
   virtual void NodePredicateChanged() override;
   virtual void NodeAdded(const mitk::DataNode* node) override;
   virtual void NodeChanged(const mitk::DataNode* node) override;
   virtual void NodeRemoved(const mitk::DataNode* node) override;
   /**
   * @brief Overridden from 'QmitkAbstractSemanticRelationsStorageModel': This function retrieves all control points
   *        and information types of the current case and stores them to define the header of the table.
   *        Furthermore all images are retrieved and the pixmap of the images are generated and stored.
   */
   virtual void SetData() override;
 
 private:
 
   void SetHeaderModel();
   void SetPixmaps();
   void SetLesionPresences();
 
   /**
   * @brief The function uses the ID of the node to see if a pixmap was already set. If not, the given pixmap
   *        is used and stored inside a member variable. If the pixmap was already set, it will be overwritten.
   *        Using 'nullptr' as a pixmap will erase the entry for the given data node.
   *
   * @param dataNode           The data node whose pixmap should be set
   * @param pixmapFromImage    The pixmap that shows an image of the content of the data node
   */
   void SetPixmapOfNode(const mitk::DataNode* dataNode, QPixmap* pixmapFromImage);
   /**
   * @brief The function uses the ID of the node to see if a lesion presence was already set. If not, the given
   *        bool value is used and stored inside a member variable. If the lesion presence was already set, it
   *        will be overwritten.
   *        The function is used by the 'SetLesionPresences' function.
   *
   * @param dataNode           The data node whose lesion presence should be set
   * @param lesionPresence     The bool value that defines the lesion presence of the given data node
   */
   void SetLesionPresenceOfNode(const mitk::DataNode* dataNode, bool lesionPresence);
   /**
   * @brief Returns the data node that is associated with the given table entry (index).
   *
   *         The function uses the SemanticRelations-class and the current control point data and information type data to
   *         filter the nodes of the current case.
   *         The index is used to access the correct row in the table (information type) and the correct column in the table (control point).
   *
   * @par index    The QModelIndex of the table entry
   */
   mitk::DataNode* GetCurrentDataNode(const QModelIndex &index) const;
 
   std::map<mitk::DataNode::ConstPointer, QPixmap> m_PixmapMap;
   std::map<mitk::DataNode::ConstPointer, bool> m_LesionPresence;
 
   mitk::SemanticTypes::InformationTypeVector m_InformationTypes;
   mitk::SemanticTypes::ControlPointVector m_ControlPoints;
   mitk::SemanticTypes::ExaminationPeriodVector m_ExaminationPeriods;
   mitk::SemanticRelations::DataNodeVector m_CurrentDataNodes;
   std::string m_SelectedNodeType;
 
   QStandardItemModel* m_HeaderModel;
 };
 
 #endif // QMITKPATIENTTABLEMODEL_H
diff --git a/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp b/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp
index 8e59cf7b28..7b02bd0e59 100644
--- a/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp
+++ b/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp
@@ -1,182 +1,182 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // semantic relations UI module
 #include "QmitkPatientTableInspector.h"
 #include "QmitkPatientTableHeaderView.h"
 
 // mitk qt widgets module
 #include "QmitkCustomVariants.h"
 #include "QmitkEnums.h"
 
 // qt
 #include <QKeyEvent>
 #include <QSignalMapper>
 
 QmitkPatientTableInspector::QmitkPatientTableInspector(QWidget* parent/* =nullptr*/)
 {
   m_Controls.setupUi(this);
 
   QmitkPatientTableHeaderView* patientTableHeaderView = new QmitkPatientTableHeaderView(m_Controls.tableView);
   m_Controls.tableView->setHorizontalHeader(patientTableHeaderView);
   m_Controls.tableView->horizontalHeader()->setHighlightSections(false);
   m_Controls.tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::Fixed);
   m_Controls.tableView->verticalHeader()->setHighlightSections(false);
   m_Controls.tableView->verticalHeader()->setSectionResizeMode(QHeaderView::Fixed);
   m_Controls.tableView->setSelectionMode(QAbstractItemView::SingleSelection);
   m_Controls.tableView->setSelectionBehavior(QAbstractItemView::SelectItems);
   m_Controls.tableView->setContextMenuPolicy(Qt::CustomContextMenu);
 
   m_StorageModel = new QmitkPatientTableModel(m_Controls.tableView);
   m_Controls.tableView->setModel(m_StorageModel);
   m_ItemDelegate = new QmitkTableItemThumbnailDelegate(m_Controls.tableView);
   //m_Controls.tableView->setItemDelegate(m_ItemDelegate);
 
   SetUpConnections();
 }
 
 QAbstractItemView* QmitkPatientTableInspector::GetView()
 {
   return m_Controls.tableView;
 }
 
 const QAbstractItemView* QmitkPatientTableInspector::GetView() const
 {
   return m_Controls.tableView;
 }
 
 void QmitkPatientTableInspector::SetSelectionMode(SelectionMode mode)
 {
   m_Controls.tableView->setSelectionMode(mode);
 }
 
 QmitkPatientTableInspector::SelectionMode QmitkPatientTableInspector::GetSelectionMode() const
 {
   return m_Controls.tableView->selectionMode();
 }
 
 void QmitkPatientTableInspector::SetCaseID(const mitk::SemanticTypes::CaseID& caseID)
 {
   m_StorageModel->SetCaseID(caseID);
 }
 
 void QmitkPatientTableInspector::SetLesion(const mitk::SemanticTypes::Lesion& lesion)
 {
   m_StorageModel->SetLesion(lesion);
 }
 
 QItemSelectionModel* QmitkPatientTableInspector::GetSelectionModel()
 {
   return m_Controls.tableView->selectionModel();
 }
 
 void QmitkPatientTableInspector::Initialize()
 {
   if (m_DataStorage.IsExpired())
   {
     return;
   }
 
   auto dataStorage = m_DataStorage.Lock();
 
   m_StorageModel->SetDataStorage(dataStorage);
   m_StorageModel->SetNodePredicate(m_NodePredicate);
 
   m_Connector->SetView(m_Controls.tableView);
 }
 
 void QmitkPatientTableInspector::OnModelUpdated()
 {
   m_Controls.tableView->resizeRowsToContents();
   m_Controls.tableView->resizeColumnsToContents();
 }
 
 void QmitkPatientTableInspector::OnNodeButtonClicked(const QString& nodeType)
 {
   m_StorageModel->SetNodeType(nodeType.toStdString());
 }
 
 void QmitkPatientTableInspector::OnDataNodeSelectionChanged(const QList<mitk::DataNode::Pointer>& dataNodeSelection)
 {
   if (m_StorageModel->GetLesion().UID.empty())
   {
     return;
   }
 
   // if lesion is set, reset to empty lesion to hide the "lesion presence background highlighting" in the model
   m_StorageModel->SetLesion(mitk::SemanticTypes::Lesion());
   // need to explicitly set the data node selection
   SetCurrentSelection(dataNodeSelection);
 }
 
 void QmitkPatientTableInspector::OnItemDoubleClicked(const QModelIndex& itemIndex)
 {
   if (itemIndex.isValid())
   {
     QVariant qvariantDataNode = m_StorageModel->data(itemIndex, QmitkDataNodeRawPointerRole);
     if (qvariantDataNode.canConvert<mitk::DataNode*>())
     {
       mitk::DataNode* dataNode = qvariantDataNode.value<mitk::DataNode*>();
       emit DataNodeDoubleClicked(dataNode);
     }
   }
 }
 
 void QmitkPatientTableInspector::SetUpConnections()
 {
   connect(m_StorageModel, &QmitkPatientTableModel::ModelUpdated, this, &QmitkPatientTableInspector::OnModelUpdated);
   connect(m_Controls.tableView, &QTableView::customContextMenuRequested, this, &QmitkPatientTableInspector::OnContextMenuRequested);
 
   QSignalMapper* nodeButtonSignalMapper = new QSignalMapper(this);
   nodeButtonSignalMapper->setMapping(m_Controls.imageNodeButton, QString("Image"));
   nodeButtonSignalMapper->setMapping(m_Controls.segmentationNodeButton, QString("Segmentation"));
   connect(nodeButtonSignalMapper, static_cast<void (QSignalMapper::*)(const QString&)>(&QSignalMapper::mapped), this, &QmitkPatientTableInspector::OnNodeButtonClicked);
-  connect(m_Controls.imageNodeButton, SIGNAL(clicked()), nodeButtonSignalMapper, SLOT(map()));
-  connect(m_Controls.segmentationNodeButton, SIGNAL(clicked()), nodeButtonSignalMapper, SLOT(map()));
+  connect(m_Controls.imageNodeButton, &QRadioButton::clicked, nodeButtonSignalMapper, static_cast<void(QSignalMapper::*)()>(&QSignalMapper::map));
+  connect(m_Controls.segmentationNodeButton, &QRadioButton::clicked, nodeButtonSignalMapper, static_cast<void(QSignalMapper::*)()>(&QSignalMapper::map));
   m_Controls.imageNodeButton->setChecked(true);
 
   connect(this, &QmitkPatientTableInspector::CurrentSelectionChanged, this, &QmitkPatientTableInspector::OnDataNodeSelectionChanged);
   connect(m_Controls.tableView, &QTableView::doubleClicked, this, &QmitkPatientTableInspector::OnItemDoubleClicked);
 }
 
 void QmitkPatientTableInspector::keyPressEvent(QKeyEvent* e)
 {
   mitk::DataNode* dataNode = nullptr;
   QModelIndex selectedIndex = m_Controls.tableView->currentIndex();
   if (selectedIndex.isValid())
   {
     QVariant qvariantDataNode = m_StorageModel->data(selectedIndex, QmitkDataNodeRawPointerRole);
     if (qvariantDataNode.canConvert<mitk::DataNode*>())
     {
       dataNode = qvariantDataNode.value<mitk::DataNode*>();
     }
   }
 
   if (nullptr == dataNode)
   {
     return;
   }
 
   int key = e->key();
   switch (key)
   {
   case Qt::Key_Delete:
     emit OnNodeRemoved(dataNode);
     break;
   default:
     break;
   }
 }
diff --git a/Modules/SemanticRelationsUI/src/QmitkPatientTableModel.cpp b/Modules/SemanticRelationsUI/src/QmitkPatientTableModel.cpp
index 3d9846fb93..4509f76a69 100644
--- a/Modules/SemanticRelationsUI/src/QmitkPatientTableModel.cpp
+++ b/Modules/SemanticRelationsUI/src/QmitkPatientTableModel.cpp
@@ -1,356 +1,358 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // semantic relations UI module
 #include "QmitkPatientTableModel.h"
 #include "QmitkPatientTableHeaderView.h"
 #include "QmitkSemanticRelationsUIHelper.h"
 
 // semantic relations module
 #include <mitkControlPointManager.h>
 #include <mitkNodePredicates.h>
 #include <mitkSemanticRelationException.h>
 
 #include <QmitkCustomVariants.h>
 #include <QmitkEnums.h>
 
 // qt
 #include <QColor>
 
 // c++
 #include <iostream>
 #include <string>
 
 QmitkPatientTableModel::QmitkPatientTableModel(QObject* parent /*= nullptr*/)
   : QmitkAbstractSemanticRelationsStorageModel(parent)
   , m_SelectedNodeType("Image")
 {
   m_HeaderModel = new QStandardItemModel(this);
 }
 
 QmitkPatientTableModel::~QmitkPatientTableModel()
 {
   // nothing here
 }
 
 QModelIndex QmitkPatientTableModel::index(int row, int column, const QModelIndex& parent/* = QModelIndex()*/) const
 {
   if (hasIndex(row, column, parent))
   {
     return createIndex(row, column);
   }
 
   return QModelIndex();
 }
 
 QModelIndex QmitkPatientTableModel::parent(const QModelIndex& child) const
 {
   return QModelIndex();
 }
 
 int QmitkPatientTableModel::rowCount(const QModelIndex& parent/* = QModelIndex()*/) const
 {
   if (parent.isValid())
   {
     return 0;
   }
 
   return m_InformationTypes.size();
 }
 
 int QmitkPatientTableModel::columnCount(const QModelIndex& parent/* = QModelIndex()*/) const
 {
   return m_ControlPoints.size();
 }
 
 QVariant QmitkPatientTableModel::data(const QModelIndex& index, int role/* = Qt::DisplayRole*/) const
 {
+  // special role for returning the horizontal header
   if (QmitkPatientTableHeaderView::HorizontalHeaderDataRole == role)
   {
     return QVariant::fromValue<QStandardItemModel*>(m_HeaderModel);
   }
+
   if (!index.isValid())
   {
     return QVariant();
   }
 
   if (index.row() < 0 || index.row() >= static_cast<int>(m_InformationTypes.size())
    || index.column() < 0 || index.column() >= static_cast<int>(m_ControlPoints.size()))
   {
     return QVariant();
   }
 
   mitk::DataNode* dataNode = GetCurrentDataNode(index);
   if (nullptr == dataNode)
   {
     return QVariant();
   }
 
   if (Qt::DecorationRole == role)
   {
     auto it = m_PixmapMap.find(dataNode);
     if (it != m_PixmapMap.end())
     {
       return QVariant(it->second);
     }
   }
 
   if (QmitkDataNodeRole == role)
   {
     return QVariant::fromValue<mitk::DataNode::Pointer>(mitk::DataNode::Pointer(dataNode));
   }
 
   if (QmitkDataNodeRawPointerRole == role)
   {
     return QVariant::fromValue<mitk::DataNode*>(dataNode);
   }
 
   if (Qt::BackgroundColorRole == role)
   {
     auto it = m_LesionPresence.find(dataNode);
     if (it != m_LesionPresence.end())
     {
       return it->second ? QVariant(QColor(Qt::darkGreen)) : QVariant(QColor(Qt::transparent));
     }
 
     return QVariant(QColor(Qt::transparent));
   }
 
   return QVariant();
 }
 
 QVariant QmitkPatientTableModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if (Qt::Vertical == orientation && Qt::DisplayRole == role)
   {
     if (m_InformationTypes.size() > section)
     {
       mitk::SemanticTypes::InformationType currentInformationType = m_InformationTypes.at(section);
       return QVariant(QString::fromStdString(currentInformationType));
     }
   }
 
   return QVariant();
 }
 
 Qt::ItemFlags QmitkPatientTableModel::flags(const QModelIndex& index) const
 {
   Qt::ItemFlags flags;
   mitk::DataNode* dataNode = GetCurrentDataNode(index);
   if (nullptr != dataNode)
   {
     flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
   }
 
   return flags;
 }
 
 void QmitkPatientTableModel::SetNodeType(const std::string& nodeType)
 {
   m_SelectedNodeType = nodeType;
   UpdateModelData();
 }
 
 void QmitkPatientTableModel::NodePredicateChanged()
 {
   UpdateModelData();
 }
 
 void QmitkPatientTableModel::NodeAdded(const mitk::DataNode* node)
 {
   // does not react to data storage changes
 }
 
 void QmitkPatientTableModel::NodeChanged(const mitk::DataNode* node)
 {
   // nothing here, since the "'NodeChanged'-event is currently sent far too often
   //UpdateModelData();
 }
 
 void QmitkPatientTableModel::NodeRemoved(const mitk::DataNode* node)
 {
   // does not react to data storage changes
 }
 
 void QmitkPatientTableModel::SetData()
 {
   // get all control points of current case
   m_ControlPoints = m_SemanticRelations->GetAllControlPointsOfCase(m_CaseID);
   // sort the vector of control points for the timeline
   std::sort(m_ControlPoints.begin(), m_ControlPoints.end());
 
   // get all examination periods of current case
   m_ExaminationPeriods = m_SemanticRelations->GetAllExaminationPeriodsOfCase(m_CaseID);
   // sort the vector of examination periods for the timeline
   mitk::SortExaminationPeriods(m_ExaminationPeriods, m_ControlPoints);
 
   // get all information types points of current case
   m_InformationTypes = m_SemanticRelations->GetAllInformationTypesOfCase(m_CaseID);
 
   if ("Image" == m_SelectedNodeType)
   {
     m_CurrentDataNodes = m_SemanticRelations->GetAllImagesOfCase(m_CaseID);
   }
   else if ("Segmentation" == m_SelectedNodeType)
   {
     m_CurrentDataNodes = m_SemanticRelations->GetAllSegmentationsOfCase(m_CaseID);
   }
 
   SetHeaderModel();
   SetPixmaps();
   SetLesionPresences();
 }
 
 void QmitkPatientTableModel::SetHeaderModel()
 {
   m_HeaderModel->clear();
   QStandardItem* rootItem = new QStandardItem("Timeline");
   QList<QStandardItem*> standardItems;
 
   for (const auto& examinationPeriod : m_ExaminationPeriods)
   {
     QStandardItem* examinationPeriodItem = new QStandardItem(QString::fromStdString(examinationPeriod.name));
     standardItems.push_back(examinationPeriodItem);
     rootItem->appendColumn(standardItems);
     standardItems.clear();
 
     const auto& currentControlPoints = examinationPeriod.controlPointUIDs;
     for (const auto& controlPointUID : currentControlPoints)
     {
       const auto& controlPoint = mitk::GetControlPointByUID(controlPointUID, m_ControlPoints);
       QStandardItem* controlPointItem = new QStandardItem(QString::fromStdString(controlPoint.ToString()));
       standardItems.push_back(controlPointItem);
       examinationPeriodItem->appendColumn(standardItems);
       standardItems.clear();
     }
   }
 
   m_HeaderModel->setItem(0, 0, rootItem);
 }
 
 void QmitkPatientTableModel::SetPixmaps()
 {
   m_PixmapMap.clear();
   for (const auto& dataNode : m_CurrentDataNodes)
   {
     // set the pixmap for the current node
     QPixmap pixmapFromImage = QmitkSemanticRelationsUIHelper::GetPixmapFromImageNode(dataNode);
     SetPixmapOfNode(dataNode, &pixmapFromImage);
   }
 }
 
 void QmitkPatientTableModel::SetPixmapOfNode(const mitk::DataNode* dataNode, QPixmap* pixmapFromImage)
 {
   if (nullptr == dataNode)
   {
     return;
   }
 
   std::map<mitk::DataNode::ConstPointer, QPixmap>::iterator iter = m_PixmapMap.find(dataNode);
   if (iter != m_PixmapMap.end())
   {
     // key already existing
     if (nullptr != pixmapFromImage)
     {
       // overwrite already stored pixmap
       iter->second = pixmapFromImage->scaled(120, 120, Qt::IgnoreAspectRatio);
     }
     else
     {
       // remove key if no pixmap is given
       m_PixmapMap.erase(iter);
     }
   }
   else
   {
     m_PixmapMap.insert(std::make_pair(dataNode, pixmapFromImage->scaled(120, 120, Qt::IgnoreAspectRatio)));
   }
 }
 
 void QmitkPatientTableModel::SetLesionPresences()
 {
   m_LesionPresence.clear();
   if (!m_SemanticRelations->InstanceExists(m_CaseID, m_Lesion))
   {
     return;
   }
 
   for (const auto& dataNode : m_CurrentDataNodes)
   {
     if (!m_SemanticRelations->InstanceExists(dataNode))
     {
       continue;
     }
 
     try
     {
       // set the lesion presence for the current node
       bool lesionPresence = m_SemanticRelations->IsLesionPresentOnDataNode(m_Lesion, dataNode);
       SetLesionPresenceOfNode(dataNode, lesionPresence);
     }
     catch (const mitk::SemanticRelationException&)
     {
       continue;
     }
   }
 }
 
 void QmitkPatientTableModel::SetLesionPresenceOfNode(const mitk::DataNode* dataNode, bool lesionPresence)
 {
   std::map<mitk::DataNode::ConstPointer, bool>::iterator iter = m_LesionPresence.find(dataNode);
   if (iter != m_LesionPresence.end())
   {
     // key already existing, overwrite already stored bool value
     iter->second = lesionPresence;
   }
   else
   {
     m_LesionPresence.insert(std::make_pair(dataNode, lesionPresence));
   }
 }
 
 mitk::DataNode* QmitkPatientTableModel::GetCurrentDataNode(const QModelIndex& index) const
 {
   if (!index.isValid())
   {
     return nullptr;
   }
 
   mitk::SemanticTypes::ControlPoint currentControlPoint = m_ControlPoints.at(index.column());
   mitk::SemanticTypes::InformationType currentInformationType = m_InformationTypes.at(index.row());
   try
   {
     std::vector<mitk::DataNode::Pointer> filteredDataNodes;
     if ("Image" == m_SelectedNodeType)
     {
       filteredDataNodes = m_SemanticRelations->GetAllSpecificImages(m_CaseID, currentControlPoint, currentInformationType);
     }
     else if ("Segmentation" == m_SelectedNodeType)
     {
       filteredDataNodes = m_SemanticRelations->GetAllSpecificSegmentations(m_CaseID, currentControlPoint, currentInformationType);
     }
 
     if (filteredDataNodes.empty())
     {
       return nullptr;
     }
     return filteredDataNodes.front();
   }
   catch (const mitk::SemanticRelationException&)
   {
     return nullptr;
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.cpp
index d5dd92e18f..4131253d55 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.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.
 
 ===================================================================*/
 
 // semantic relations plugin
 #include "QmitkDataNodeAddToSemanticRelationsAction.h"
 
 // semantic relations module
 #include <mitkNodePredicates.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkUIDGeneratorBoost.h>
 
 // mitk gui common plugin
 #include <mitkDataNodeSelection.h>
 
 // berry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchPage.h>
 
 // qt
 #include <QMessageBox>
 
 // namespace that contains the concrete action
-namespace AdddToSemanticRelationsAction
+namespace AddToSemanticRelationsAction
 {
   void Run(mitk::SemanticRelations* semanticRelations, const mitk::DataStorage* dataStorage, const mitk::DataNode* dataNode)
   {
     if (nullptr == dataNode)
     {
       return;
     }
 
     if (mitk::NodePredicates::GetImagePredicate()->CheckNode(dataNode))
     {
       AddImage(semanticRelations, dataNode);
     }
     else if (mitk::NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
     {
       AddSegmentation(semanticRelations, dataStorage, dataNode);
     }
   }
 
   void AddImage(mitk::SemanticRelations* semanticRelations, const mitk::DataNode* image)
   {
     if (nullptr == image)
     {
       return;
     }
 
     try
     {
       // add the image to the semantic relations storage
       semanticRelations->AddImage(image);
     }
     catch (const mitk::SemanticRelationException& e)
     {
       std::stringstream exceptionMessage; exceptionMessage << e;
       QMessageBox msgBox;
       msgBox.setWindowTitle("Could not add the selected image.");
       msgBox.setText("The program wasn't able to correctly add the selected images.\n"
         "Reason:\n" + QString::fromStdString(exceptionMessage.str()));
       msgBox.setIcon(QMessageBox::Warning);
       msgBox.exec();
       return;
     }
   }
 
   void AddSegmentation(mitk::SemanticRelations* semanticRelations, const mitk::DataStorage* dataStorage, const mitk::DataNode* segmentation)
   {
     if (nullptr == segmentation)
     {
       return;
     }
 
     mitk::BaseData* baseData = segmentation->GetData();
     if (nullptr == baseData)
     {
       return;
     }
 
     // continue with valid segmentation data
     // get parent node of the current segmentation node with the node predicate
     mitk::DataStorage::SetOfObjects::ConstPointer parentNodes = dataStorage->GetSources(segmentation, mitk::NodePredicates::GetImagePredicate(), false);
 
     // check for already existing, identifying base properties
     mitk::BaseProperty* caseIDProperty = baseData->GetProperty("DICOM.0010.0010");
     mitk::BaseProperty* nodeIDProperty = baseData->GetProperty("DICOM.0020.000E");
     if (nullptr == caseIDProperty || nullptr == nodeIDProperty)
     {
       MITK_INFO << "No DICOM tags for case and node identification found. Transferring DICOM tags from the parent node to the selected segmentation node.";
 
       mitk::SemanticTypes::CaseID caseID = mitk::GetCaseIDFromDataNode(parentNodes->front());
       mitk::SemanticTypes::ID nodeID = mitk::GetIDFromDataNode(parentNodes->front());
       // transfer DICOM tags to the segmentation node
       mitk::StringProperty::Pointer caseIDTag = mitk::StringProperty::New(caseID);
       baseData->SetProperty("DICOM.0010.0010", caseIDTag); // DICOM tag is "PatientName"
 
                                                            // add UID to distinguish between different segmentations of the same parent node
       mitk::StringProperty::Pointer nodeIDTag = mitk::StringProperty::New(nodeID + mitk::UIDGeneratorBoost::GenerateUID());
       baseData->SetProperty("DICOM.0020.000E", nodeIDTag); // DICOM tag is "SeriesInstanceUID"
     }
 
     try
     {
       semanticRelations->AddSegmentation(segmentation, parentNodes->front());
     }
     catch (const mitk::SemanticRelationException& e)
     {
       std::stringstream exceptionMessage; exceptionMessage << e;
       QMessageBox msgBox;
       msgBox.setWindowTitle("Could not add the selected segmentation.");
       msgBox.setText("The program wasn't able to correctly add the selected segmentation.\n"
         "Reason:\n" + QString::fromStdString(exceptionMessage.str()));
       msgBox.setIcon(QMessageBox::Warning);
       msgBox.exec();
       return;
     }
   }
 }
 
 QmitkDataNodeAddToSemanticRelationsAction::QmitkDataNodeAddToSemanticRelationsAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QAction(parent)
   , m_WorkbenchPartSite(workbenchPartSite)
 {
   setText(tr("Add to semantic relations"));
   InitializeAction();
 }
 
 QmitkDataNodeAddToSemanticRelationsAction::QmitkDataNodeAddToSemanticRelationsAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QAction(parent)
   , m_WorkbenchPartSite(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   setText(tr("Add to semantic relations"));
   InitializeAction();
 }
 
 QmitkDataNodeAddToSemanticRelationsAction::~QmitkDataNodeAddToSemanticRelationsAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeAddToSemanticRelationsAction::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (m_DataStorage != dataStorage)
   {
     // set the new data storage
     m_DataStorage = dataStorage;
     m_SemanticRelations = std::make_unique<mitk::SemanticRelations>(m_DataStorage.Lock());
   }
 }
 
 void QmitkDataNodeAddToSemanticRelationsAction::InitializeAction()
 {
   connect(this, &QAction::triggered, this, &QmitkDataNodeAddToSemanticRelationsAction::OnActionTriggered);
 }
 
 void QmitkDataNodeAddToSemanticRelationsAction::OnActionTriggered(bool checked)
 {
   if (nullptr == m_SemanticRelations)
   {
     return;
   }
 
   if (m_DataStorage.IsExpired())
   {
     return;
   }
 
   auto dataNode = GetSelectedNode();
-  AdddToSemanticRelationsAction::Run(m_SemanticRelations.get(), m_DataStorage.Lock(), dataNode);
+  AddToSemanticRelationsAction::Run(m_SemanticRelations.get(), m_DataStorage.Lock(), dataNode);
 }
 
 QList<mitk::DataNode::Pointer> QmitkDataNodeAddToSemanticRelationsAction::GetSelectedNodes()
 {
   QList<mitk::DataNode::Pointer> selectedNodes;
   if (m_WorkbenchPartSite.Expired())
   {
     return selectedNodes;
   }
 
   berry::ISelection::ConstPointer selection = m_WorkbenchPartSite.Lock()->GetWorkbenchWindow()->GetSelectionService()->GetSelection();
   mitk::DataNodeSelection::ConstPointer currentSelection = selection.Cast<const mitk::DataNodeSelection>();
 
   if (currentSelection.IsNull() || currentSelection->IsEmpty())
   {
     return selectedNodes;
   }
 
   selectedNodes = QList<mitk::DataNode::Pointer>::fromStdList(currentSelection->GetSelectedDataNodes());
   return selectedNodes;
 }
 
 mitk::DataNode::Pointer QmitkDataNodeAddToSemanticRelationsAction::GetSelectedNode()
 {
   QList<mitk::DataNode::Pointer> selectedNodes = GetSelectedNodes();
   if (selectedNodes.empty())
   {
     return nullptr;
   }
 
   // no batch action; should only be called with a single node
   mitk::DataNode::Pointer dataNode = selectedNodes.front();
   if (nullptr == dataNode)
   {
     return nullptr;
   }
 
   return dataNode;
 }
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.h b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.h
index b3ce3d5598..34cfaca946 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.h
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.h
@@ -1,73 +1,73 @@
 /*===================================================================
 
 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 QMITKDATANODEADDTOSEMANTICRELATIONSACTION_H
 #define QMITKDATANODEADDTOSEMANTICRELATIONSACTION_H
 
 #include <org_mitk_gui_qt_semanticrelations_Export.h>
 
 // mitk core
 #include <mitkDataNode.h>
 #include <mitkDataStorage.h>
 #include <mitkWeakPointer.h>
 
 // semantic relations module
 #include <mitkSemanticRelations.h>
 
 // berry
 #include <berryIWorkbenchPartSite.h>
 
 // qt
 #include <QAction.h>
 
-namespace AdddToSemanticRelationsAction
+namespace AddToSemanticRelationsAction
 {
   MITK_GUI_SEMANTICRELATIONS_EXPORT void Run(mitk::SemanticRelations* semanticRelations, const mitk::DataStorage* dataStorage, const mitk::DataNode* image);
   
   void AddImage(mitk::SemanticRelations* semanticRelations, const mitk::DataNode* image);
   void AddSegmentation(mitk::SemanticRelations* semanticRelations, const mitk::DataStorage* dataStorage, const mitk::DataNode* segmentation);
 }
 
 class MITK_GUI_SEMANTICRELATIONS_EXPORT QmitkDataNodeAddToSemanticRelationsAction : public QAction
 {
   Q_OBJECT
 
 public:
 
   QmitkDataNodeAddToSemanticRelationsAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite);
   QmitkDataNodeAddToSemanticRelationsAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite);
 
   virtual ~QmitkDataNodeAddToSemanticRelationsAction() override;
 
   void SetDataStorage(mitk::DataStorage* dataStorage);
 
 private Q_SLOTS:
 
   void OnActionTriggered(bool);
 
 protected:
 
   void InitializeAction();
 
   QList<mitk::DataNode::Pointer> GetSelectedNodes();
   mitk::DataNode::Pointer GetSelectedNode();
 
   berry::IWorkbenchPartSite::WeakPtr m_WorkbenchPartSite;
   mitk::WeakPointer<mitk::DataStorage> m_DataStorage;
   std::unique_ptr<mitk::SemanticRelations> m_SemanticRelations;
 };
 
 #endif // QMITKDATANODEADDTOSEMANTICRELATIONSACTION_H
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.cpp
index dac5eeb28a..d94e035cbb 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.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.
 
 ===================================================================*/
 
 // semantic relations plugin
 #include "QmitkSemanticRelationsView.h"
 #include "QmitkSemanticRelationsNodeSelectionDialog.h"
 #include "QmitkDataNodeAddToSemanticRelationsAction.h"
 #include "QmitkDataNodeRemoveFromSemanticRelationsAction.h"
 
 // semantic relations module
 #include <mitkNodePredicates.h>
 #include <mitkSemanticRelationException.h>
 
 // mitk qt widgets module
 #include <QmitkDnDDataNodeWidget.h>
 #include <QmitkRenderWindow.h>
 
 // mitk multi label module
 #include <mitkLabelSetImage.h>
 
 // berry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // qt
 #include <QMenu>
 #include <QTreeView>
 
 const std::string QmitkSemanticRelationsView::VIEW_ID = "org.mitk.views.semanticrelations";
 
 void QmitkSemanticRelationsView::SetFocus()
 {
   // nothing here
 }
 
 void QmitkSemanticRelationsView::CreateQtPartControl(QWidget* parent)
 {
   // create GUI widgets
   m_Controls.setupUi(parent);
 
   // initialize the semantic relations
   m_SemanticRelations = std::make_unique<mitk::SemanticRelations>(GetDataStorage());
 
   m_LesionInfoWidget = new QmitkLesionInfoWidget(GetDataStorage(), parent);
   m_Controls.gridLayout->addWidget(m_LesionInfoWidget);
 
   m_PatientTableInspector = new QmitkPatientTableInspector(parent);
   m_PatientTableInspector->SetDataStorage(GetDataStorage());
   m_Controls.gridLayout->addWidget(m_PatientTableInspector);
 
   QGridLayout* dndDataNodeWidgetLayout = new QGridLayout;
   dndDataNodeWidgetLayout->addWidget(m_PatientTableInspector, 0, 0);
   dndDataNodeWidgetLayout->setContentsMargins(0, 0, 0, 0);
 
   m_DnDDataNodeWidget = new QmitkDnDDataNodeWidget(parent);
   m_DnDDataNodeWidget->setLayout(dndDataNodeWidgetLayout);
 
   m_Controls.gridLayout->addWidget(m_DnDDataNodeWidget);
 
   m_ContextMenu = new QmitkSemanticRelationsContextMenu(GetSite(), m_PatientTableInspector);
   m_ContextMenu->SetDataStorage(GetDataStorage());
 
   mitk::IRenderWindowPart* renderWindowPart = GetRenderWindowPart();
   if (nullptr != renderWindowPart)
   {
     RenderWindowPartActivated(renderWindowPart);
   }
 
   SetUpConnections();
 }
 
 void QmitkSemanticRelationsView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   // connect QmitkRenderWindows - underlying vtkRenderWindow is the same as "mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows()"
   QHash<QString, QmitkRenderWindow*> windowMap = renderWindowPart->GetQmitkRenderWindows();
   QHash<QString, QmitkRenderWindow*>::Iterator it;
 
   mitk::BaseRenderer* baseRenderer = nullptr;
   RenderWindowLayerUtilities::RendererVector controlledRenderer;
   for (it = windowMap.begin(); it != windowMap.end(); ++it)
   {
     baseRenderer = mitk::BaseRenderer::GetInstance(it.value()->GetVtkRenderWindow());
     if (nullptr != baseRenderer)
     {
       controlledRenderer.push_back(baseRenderer);
     }
   }
 
   m_ContextMenu->SetControlledRenderer(controlledRenderer);
 }
 
 void QmitkSemanticRelationsView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   // nothing here
 }
 
 void QmitkSemanticRelationsView::SetUpConnections()
 {
   connect(m_Controls.caseIDComboBox, static_cast<void (QComboBox::*)(const QString&)>(&QComboBox::currentIndexChanged), this, &QmitkSemanticRelationsView::OnCaseIDSelectionChanged);
   connect(m_LesionInfoWidget, &QmitkLesionInfoWidget::LesionSelectionChanged, this, &QmitkSemanticRelationsView::OnLesionSelectionChanged);
   connect(m_PatientTableInspector, &QmitkPatientTableInspector::CurrentSelectionChanged, this, &QmitkSemanticRelationsView::OnDataNodeSelectionChanged);
   connect(m_PatientTableInspector, &QmitkPatientTableInspector::DataNodeDoubleClicked, this, &QmitkSemanticRelationsView::OnDataNodeDoubleClicked);
   connect(m_DnDDataNodeWidget, &QmitkDnDDataNodeWidget::NodesDropped, this, &QmitkSemanticRelationsView::OnNodesAdded);
 
   connect(m_PatientTableInspector, &QmitkPatientTableInspector::OnContextMenuRequested, m_ContextMenu, &QmitkSemanticRelationsContextMenu::OnContextMenuRequested);
   connect(m_PatientTableInspector, &QmitkPatientTableInspector::OnNodeRemoved, this, &QmitkSemanticRelationsView::NodeRemoved);
 }
 
 QItemSelectionModel* QmitkSemanticRelationsView::GetDataNodeSelectionModel() const
 {
   return m_PatientTableInspector->GetSelectionModel();
 }
 
 void QmitkSemanticRelationsView::NodeRemoved(const mitk::DataNode* dataNode)
 {
   if (nullptr == dataNode)
   {
     return;
   }
 
   if (m_SemanticRelations->InstanceExists(dataNode))
   {
     RemoveFromSemanticRelationsAction::Run(m_SemanticRelations.get(), dataNode);
     mitk::SemanticTypes::CaseID caseID = mitk::GetCaseIDFromDataNode(dataNode);
     RemoveFromComboBox(caseID);
   }
 }
 
 void QmitkSemanticRelationsView::OnLesionSelectionChanged(const mitk::SemanticTypes::Lesion& lesion)
 {
   m_PatientTableInspector->SetLesion(lesion);
 }
 
 void QmitkSemanticRelationsView::OnDataNodeSelectionChanged(const QList<mitk::DataNode::Pointer>& dataNodeSelection)
 {
   m_LesionInfoWidget->SetDataNodeSelection(dataNodeSelection);
 }
 
 void QmitkSemanticRelationsView::OnDataNodeDoubleClicked(const mitk::DataNode* dataNode)
 {
   if (nullptr == dataNode)
   {
     return;
   }
 
   if (mitk::NodePredicates::GetImagePredicate()->CheckNode(dataNode))
   {
     OpenInEditor(dataNode);
   }
   else if (mitk::NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
   {
     JumpToPosition(dataNode);
   }
 }
 
 void QmitkSemanticRelationsView::OnCaseIDSelectionChanged(const QString& caseID)
 {
   m_LesionInfoWidget->SetCaseID(caseID.toStdString());
   m_PatientTableInspector->SetCaseID(caseID.toStdString());
 }
 
 void QmitkSemanticRelationsView::OnNodesAdded(QmitkDnDDataNodeWidget* dnDDataNodeWidget, std::vector<mitk::DataNode*> nodes)
 {
   mitk::SemanticTypes::CaseID caseID = "";
   for (mitk::DataNode* dataNode : nodes)
   {
-    AdddToSemanticRelationsAction::Run(m_SemanticRelations.get(), GetDataStorage(), dataNode);
+    AddToSemanticRelationsAction::Run(m_SemanticRelations.get(), GetDataStorage(), dataNode);
     caseID = mitk::GetCaseIDFromDataNode(dataNode);
     AddToComboBox(caseID);
   }
 }
 
 void QmitkSemanticRelationsView::OnNodeRemoved(const mitk::DataNode* dataNode)
 {
   NodeRemoved(dataNode);
 }
 
 void QmitkSemanticRelationsView::AddToComboBox(const mitk::SemanticTypes::CaseID& caseID)
 {
   int foundIndex = m_Controls.caseIDComboBox->findText(QString::fromStdString(caseID));
   if (-1 == foundIndex)
   {
     // add the caseID to the combo box, as it is not already contained
     m_Controls.caseIDComboBox->addItem(QString::fromStdString(caseID));
   }
 }
 
 void QmitkSemanticRelationsView::RemoveFromComboBox(const mitk::SemanticTypes::CaseID& caseID)
 {
   std::vector<mitk::SemanticTypes::ControlPoint> allControlPoints = m_SemanticRelations->GetAllControlPointsOfCase(caseID);
   int foundIndex = m_Controls.caseIDComboBox->findText(QString::fromStdString(caseID));
   if (allControlPoints.empty() && -1 != foundIndex)
   {
     // TODO: find new way to check for empty case id
     // caseID does not contain any control points and therefore no data
     // remove the caseID, if it is still contained
     m_Controls.caseIDComboBox->removeItem(foundIndex);
   }
 }
 
 void QmitkSemanticRelationsView::OpenInEditor(const mitk::DataNode* dataNode)
 {
   auto renderWindowPart = GetRenderWindowPart();
   if (nullptr == renderWindowPart)
   {
     renderWindowPart = GetRenderWindowPart(QmitkAbstractView::BRING_TO_FRONT | QmitkAbstractView::OPEN);
     if (nullptr == renderWindowPart)
     {
       // no render window available
       return;
     }
   }
 
   auto image = dynamic_cast<mitk::Image*>(dataNode->GetData());
   if (nullptr != image)
   {
     mitk::RenderingManager::GetInstance()->InitializeViews(image->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
   }
 }
 
 void QmitkSemanticRelationsView::JumpToPosition(const mitk::DataNode* dataNode)
 {
   if (nullptr == dataNode)
   {
     return;
   }
 
   mitk::LabelSetImage* labelSetImage = dynamic_cast<mitk::LabelSetImage*>(dataNode->GetData());
   if (nullptr == labelSetImage)
   {
     return;
   }
 
   int activeLayer = labelSetImage->GetActiveLayer();
   mitk::Label* activeLabel = labelSetImage->GetActiveLabel(activeLayer);
   labelSetImage->UpdateCenterOfMass(activeLabel->GetValue(), activeLayer);
   const mitk::Point3D& centerPosition = activeLabel->GetCenterOfMassCoordinates();
   if (centerPosition.GetVnlVector().max_value() > 0.0)
   {
     auto renderWindowPart = GetRenderWindowPart();
     if (nullptr == renderWindowPart)
     {
       renderWindowPart = GetRenderWindowPart(QmitkAbstractView::BRING_TO_FRONT | QmitkAbstractView::OPEN);
       if (nullptr == renderWindowPart)
       {
         // no render window available
         return;
       }
     }
 
     auto segmentation = dynamic_cast<mitk::LabelSetImage*>(dataNode->GetData());
     if (nullptr != segmentation)
     {
       renderWindowPart->SetSelectedPosition(centerPosition);
       mitk::RenderingManager::GetInstance()->InitializeViews(segmentation->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
     }
   }
 }