diff --git a/Modules/SemanticRelationsUI/include/QmitkPatientTableInspector.h b/Modules/SemanticRelationsUI/include/QmitkPatientTableInspector.h
index 1095851a41..eae348e7aa 100644
--- a/Modules/SemanticRelationsUI/include/QmitkPatientTableInspector.h
+++ b/Modules/SemanticRelationsUI/include/QmitkPatientTableInspector.h
@@ -1,86 +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.
 
 ===================================================================*/
 
 #ifndef QMITKPATIENTTABLEINSPECTOR_H
 #define QMITKPATIENTTABLEINSPECTOR_H
 
 // semantic relations UI module
 #include "MitkSemanticRelationsUIExports.h"
 #include <QmitkAbstractSemanticRelationsStorageInspector.h>
 #include <QmitkPatientTableModel.h>
 
 #include "ui_QmitkPatientTableInspector.h"
 
 // qt widgets module
 #include "QmitkEnums.h"
 
 // qt
 #include <QMenu>
 
 /*
 * @brief The QmitkPatientTableInspector is a QmitkAbstractSemanticRelationsStorageInspector that shows the currently
 *        available data of the semantic relations storage model in a control-point - information type matrix.
 *
 *   The QmitkPatientTableInspector uses the QmitkSemanticRelationsStorageModel, a QmitkAbstractDataStorageModel that
 *   presents the semantic relations data as a table, showing a QPixmap as thumbnail for the data nodes.
 */
 class MITKSEMANTICRELATIONSUI_EXPORT QmitkPatientTableInspector : public QmitkAbstractSemanticRelationsStorageInspector
 {
   Q_OBJECT
 
 public:
 
   QmitkPatientTableInspector(QWidget* parent = nullptr);
 
   virtual QAbstractItemView* GetView() override;
   virtual const QAbstractItemView* GetView() const override;
 
   virtual void SetSelectionMode(SelectionMode mode) override;
   virtual SelectionMode GetSelectionMode() const override;
 
   virtual void SetCaseID(const mitk::SemanticTypes::CaseID& caseID) override;
   virtual void SetLesion(const mitk::SemanticTypes::Lesion& lesion) override;
 
   QItemSelectionModel* GetSelectionModel();
 
 Q_SIGNALS:
 
-  void DataNodeDoubleClicked(const mitk::DataNode::Pointer);
+  void DataNodeDoubleClicked(const mitk::DataNode*);
   void OnContextMenuRequested(const QPoint&);
+  void OnNodeRemoved(const mitk::DataNode*);
 
 private Q_SLOTS:
 
   void OnModelUpdated();
   void OnNodeButtonClicked(const QString&);
   void OnContextMenuSetControlPoint();
   void OnItemDoubleClicked(const QModelIndex&);
 
 protected:
 
   virtual void Initialize() override;
 
 private:
 
   void SetUpConnections();
 
+  virtual void keyPressEvent(QKeyEvent* e) override;
+
   Ui::QmitkPatientTableInspector m_Controls;
   QmitkPatientTableModel* m_StorageModel;
 
   mitk::DataNode* m_SelectedDataNode;
 
 };
 
 #endif // QMITKPATIENTTABLEINSPECTOR_H
diff --git a/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp b/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp
index 1f3b9720a9..b61b5b617b 100644
--- a/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp
+++ b/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp
@@ -1,235 +1,265 @@
 /*===================================================================
 
 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 "QmitkControlPointDialog.h"
 
 // mitk qt widgets module
 #include "QmitkCustomVariants.h"
 #include "QmitkEnums.h"
 
 // semantic relations module
 #include <mitkDICOMHelper.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkUIDGeneratorBoost.h>
 
 // qt
+#include <QKeyEvent>
 #include <QSignalMapper>
 
 QmitkPatientTableInspector::QmitkPatientTableInspector(QWidget* parent/* =nullptr*/)
 {
   m_Controls.setupUi(this);
 
   m_Controls.tableView->horizontalHeader()->setHighlightSections(false);
   m_Controls.tableView->verticalHeader()->setHighlightSections(false);
   m_Controls.tableView->setSelectionMode(QAbstractItemView::SingleSelection);
   m_Controls.tableView->setSelectionBehavior(QAbstractItemView::SelectItems);
   m_Controls.tableView->setContextMenuPolicy(Qt::CustomContextMenu);
 
   m_StorageModel = new QmitkPatientTableModel(this);
 
   m_Controls.tableView->setModel(m_StorageModel);
 
   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()
 {
   m_StorageModel->SetDataStorage(m_DataStorage.Lock());
   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::OnContextMenuSetControlPoint()
 {
   QmitkControlPointDialog* inputDialog = new QmitkControlPointDialog(m_Controls.tableView);
   inputDialog->setWindowTitle("Set control point");
   inputDialog->SetCurrentDate(mitk::GetDICOMDateFromDataNode(m_SelectedDataNode));
 
   int dialogReturnValue = inputDialog->exec();
   if (QDialog::Rejected == dialogReturnValue)
   {
     return;
   }
 
   // store the current control point to relink it, if anything goes wrong
   mitk::SemanticTypes::ControlPoint originalControlPoint = m_StorageModel->GetSemanticRelations()->GetControlPointOfData(m_SelectedDataNode);
   // unlink the data, that is about to receive a new date
   // this is needed in order to not extend a single control point, to which the selected node is currently linked
   m_StorageModel->GetSemanticRelations()->UnlinkDataFromControlPoint(m_SelectedDataNode);
 
   const QDate& userSelectedDate = inputDialog->GetCurrentDate();
   mitk::SemanticTypes::Date date;
   date.UID = mitk::UIDGeneratorBoost::GenerateUID();
   date.year = userSelectedDate.year();
   date.month = userSelectedDate.month();
   date.day = userSelectedDate.day();
 
   std::vector<mitk::SemanticTypes::ControlPoint> allControlPoints = m_StorageModel->GetSemanticRelations()->GetAllControlPointsOfCase(m_StorageModel->GetCaseID());
   if (!allControlPoints.empty())
   {
     // need to check if an already existing control point fits/contains the user control point
     mitk::SemanticTypes::ControlPoint fittingControlPoint = mitk::FindFittingControlPoint(date, allControlPoints);
     if (!fittingControlPoint.UID.empty())
     {
       try
       {
         // found a fitting control point
         m_StorageModel->GetSemanticRelations()->LinkDataToControlPoint(m_SelectedDataNode, fittingControlPoint, false);
         m_StorageModel->UpdateModelData();
       }
       catch (const mitk::SemanticRelationException&)
       {
         MITK_INFO << "The data can not be linked to the fitting control point.";
         try
         {
           // link to the original control point
           m_StorageModel->GetSemanticRelations()->LinkDataToControlPoint(m_SelectedDataNode, originalControlPoint, false);
         }
         catch (const mitk::SemanticRelationException&)
         {
           MITK_INFO << "The data can not be linked to its original control point. Inconsistency in the semantic relations storage assumed.";
         }
       }
       return;
     }
 
     // did not find a fitting control point, although some control points already exist
     // need to check if a close control point can be found and extended
     mitk::SemanticTypes::ControlPoint extendedControlPoint = mitk::ExtendClosestControlPoint(date, allControlPoints);
     if (!extendedControlPoint.UID.empty())
     {
       try
       {
         // found and extended a close control point
         m_StorageModel->GetSemanticRelations()->OverwriteControlPointAndLinkData(m_SelectedDataNode, extendedControlPoint, false);
         m_StorageModel->UpdateModelData();
       }
       catch (const mitk::SemanticRelationException&)
       {
         MITK_INFO << "The extended control point can not be overwritten and the data can not be linked to this control point.";
         try
         {
           // link to the original control point
           m_StorageModel->GetSemanticRelations()->LinkDataToControlPoint(m_SelectedDataNode, originalControlPoint, false);
         }
         catch (const mitk::SemanticRelationException&)
         {
           MITK_INFO << "The data can not be linked to its original control point. Inconsistency in the semantic relations storage assumed.";
         }
       }
       return;
     }
   }
 
   // generate a control point from the user-given date
   mitk::SemanticTypes::ControlPoint controlPointFromUserDate = mitk::GenerateControlPoint(date);
   try
   {
     m_StorageModel->GetSemanticRelations()->AddControlPointAndLinkData(m_SelectedDataNode, controlPointFromUserDate, false);
     m_StorageModel->UpdateModelData();
   }
   catch (const mitk::SemanticRelationException&)
   {
     MITK_INFO << "The control point can not be added and the data can not be linked to this control point.";
     try
     {
       // link to the original control point
       m_StorageModel->GetSemanticRelations()->LinkDataToControlPoint(m_SelectedDataNode, originalControlPoint, false);
     }
     catch (const mitk::SemanticRelationException&)
     {
       MITK_INFO << "The data can not be linked to its original control point. Inconsistency in the semantic relations storage assumed.";
     }
   }
 }
 
 void QmitkPatientTableInspector::OnItemDoubleClicked(const QModelIndex& itemIndex)
 {
   if (itemIndex.isValid())
   {
-    QVariant qvariantDataNode = m_StorageModel->data(itemIndex, QmitkDataNodeRole);
-    if (qvariantDataNode.canConvert<mitk::DataNode::Pointer>())
+    QVariant qvariantDataNode = m_StorageModel->data(itemIndex, QmitkDataNodeRawPointerRole);
+    if (qvariantDataNode.canConvert<mitk::DataNode*>())
     {
-      mitk::DataNode::Pointer dataNode = qvariantDataNode.value<mitk::DataNode::Pointer>();
+      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()));
   m_Controls.imageNodeButton->setChecked(true);
 
   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/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.cpp
index 88b4e9f18a..b2316b2f92 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.cpp
@@ -1,389 +1,395 @@
 /*===================================================================
 
 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"
 
 // semantic relations module
 #include <mitkNodePredicates.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkUIDGeneratorBoost.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 <QMessageBox>
 
 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 QMenu(m_PatientTableInspector);
 
   m_InformationTypeAction = new QmitkDataNodeInformationTypeAction(m_ContextMenu, GetSite());
   m_InformationTypeAction->SetDataStorage(GetDataStorage());
   m_ContextMenu->addAction(m_InformationTypeAction);
 
   m_OpenInAction = new QmitkDataNodeOpenInAction(m_ContextMenu, GetSite());
   m_ContextMenu->addAction(m_OpenInAction);
 
   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_OpenInAction->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::LesionChanged, this, &QmitkSemanticRelationsView::OnLesionChanged);
   connect(m_PatientTableInspector, &QmitkPatientTableInspector::DataNodeDoubleClicked, this, &QmitkSemanticRelationsView::OnDataNodeDoubleClicked);
   connect(m_DnDDataNodeWidget, &QmitkDnDDataNodeWidget::NodesDropped, this, &QmitkSemanticRelationsView::OnNodesAdded);
 
   connect(m_PatientTableInspector, &QmitkPatientTableInspector::OnContextMenuRequested, this, &QmitkSemanticRelationsView::OnContextMenuRequested);
+  connect(m_PatientTableInspector, &QmitkPatientTableInspector::OnNodeRemoved, this, &QmitkSemanticRelationsView::OnNodeRemoved);
 }
 
 QItemSelectionModel* QmitkSemanticRelationsView::GetDataNodeSelectionModel() const
 {
   return m_PatientTableInspector->GetSelectionModel();
 }
 
 void QmitkSemanticRelationsView::NodeRemoved(const mitk::DataNode* dataNode)
 {
   if (nullptr == dataNode)
   {
     return;
   }
 
   if (mitk::NodePredicates::GetImagePredicate()->CheckNode(dataNode))
   {
     RemoveImage(dataNode);
   }
   else if (mitk::NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
   {
     RemoveSegmentation(dataNode);
   }
 }
 
 void QmitkSemanticRelationsView::OnCaseIDSelectionChanged(const QString& caseID)
 {
   m_LesionInfoWidget->SetCurrentCaseID(caseID.toStdString());
   m_PatientTableInspector->SetCaseID(caseID.toStdString());
 }
 
 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::OnLesionChanged(const mitk::SemanticTypes::Lesion& lesion)
 {
   m_PatientTableInspector->SetLesion(lesion);
 }
 
-void QmitkSemanticRelationsView::OnDataNodeDoubleClicked(const mitk::DataNode::Pointer dataNode)
+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::OnNodesAdded(QmitkDnDDataNodeWidget* dnDDataNodeWidget, std::vector<mitk::DataNode*> nodes)
 {
   for (mitk::DataNode* dataNode : nodes)
   {
     if (nullptr == dataNode)
     {
       continue;
     }
 
     if (mitk::NodePredicates::GetImagePredicate()->CheckNode(dataNode))
     {
       AddImage(dataNode);
     }
     else if (mitk::NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
     {
       AddSegmentation(dataNode);
     }
   }
 }
 
 void QmitkSemanticRelationsView::OnContextMenuRequested(const QPoint& /*pos*/)
 {
   m_ContextMenu->popup(QCursor::pos());
 }
 
+void QmitkSemanticRelationsView::OnNodeRemoved(const mitk::DataNode* dataNode)
+{
+  NodeRemoved(dataNode);
+}
+
 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::Pointer dataNode)
+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::Pointer dataNode)
+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);
     }
   }
 }
 
 void QmitkSemanticRelationsView::AddImage(const mitk::DataNode* image)
 {
   if (nullptr == image)
   {
     return;
   }
 
   try
   {
     // add the image to the semantic relations storage
     m_SemanticRelations->AddImage(image);
     mitk::SemanticTypes::CaseID caseID = mitk::GetCaseIDFromDataNode(image);
     AddToComboBox(caseID);
   }
   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 QmitkSemanticRelationsView::AddSegmentation(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 = GetDataStorage()->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
   {
     m_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;
   }
 }
 
 void QmitkSemanticRelationsView::RemoveImage(const mitk::DataNode* image)
 {
   try
   {
     m_SemanticRelations->RemoveImage(image);
     mitk::SemanticTypes::CaseID caseID = mitk::GetCaseIDFromDataNode(image);
     RemoveFromComboBox(caseID);
   }
   catch (const mitk::SemanticRelationException& e)
   {
     std::stringstream exceptionMessage; exceptionMessage << e;
     MITK_WARN << "Could not correctly remove the selected image from the semantic relations model.\n"
       << "Reason: " + exceptionMessage.str();
   }
 }
 
 void QmitkSemanticRelationsView::RemoveSegmentation(const mitk::DataNode* segmentation)
 {
   try
   {
     m_SemanticRelations->RemoveSegmentation(segmentation);
   }
   catch (const mitk::SemanticRelationException& e)
   {
     std::stringstream exceptionMessage; exceptionMessage << e;
     MITK_WARN << "Could not correctly remove the selected segmentation from the semantic relations model.\n"
               << "Reason: " + exceptionMessage.str();
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.h b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.h
index 4b804197be..b2d51657b9 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.h
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.h
@@ -1,122 +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 QMITKSEMANTICRELATIONSVIEW_H
 #define QMITKSEMANTICRELATIONSVIEW_H
 
 // semantic relations plugin
 #include "ui_QmitkSemanticRelationsControls.h"
 #include "QmitkDataNodeInformationTypeAction.h"
 #include "QmitkDataNodeOpenInAction.h"
 #include "QmitkLesionInfoWidget.h"
 
 // semantic relations module
 #include <mitkSemanticRelations.h>
 #include <mitkSemanticTypes.h>
 
 // semantic relations UI module
 #include <QmitkPatientTableInspector.h>
 
 // mitk gui common plugin
 #include <mitkIRenderWindowPartListener.h>
 
 // berry
 #include <berryISelectionListener.h>
 
 // mitk qt
 #include <QmitkAbstractView.h>
 
 class QmitkDnDDataNodeWidget;
 class QMenu;
 
 /*
 * @brief The QmitkSemanticRelationsView is an MITK view to combine and show the widgets of the 'SemanticRelationsUI'-module and this semantic relations plugin.
 *
 *         It allows the MITK user to see and modify the content of the SemanticRelations-session.
 *         A combo box is used to select and show the current patient.
 *
 *         SIDE NOTE: Modifying the control points and information types of data in the semantic relations model is currently done
 *                    by using the right-click context-menu of the "PatientTableWidget" in the "Select Patient Node"-Dialog.
 *                    This is a leftover from when the widget was not used as a selection widget. Those functionality will be moved
 *                    to this main GUI soon.
 */
 class QmitkSemanticRelationsView : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
 protected:
 
   virtual void SetFocus() override;
   virtual void CreateQtPartControl(QWidget* parent) override;
 
   virtual void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
   virtual void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override;
 
 private Q_SLOTS:
 
   void OnCaseIDSelectionChanged(const QString&);
 
   void AddToComboBox(const mitk::SemanticTypes::CaseID&);
   void OnLesionChanged(const mitk::SemanticTypes::Lesion&);
-  void OnDataNodeDoubleClicked(const mitk::DataNode::Pointer);
+  void OnDataNodeDoubleClicked(const mitk::DataNode*);
   void OnNodesAdded(QmitkDnDDataNodeWidget*, std::vector<mitk::DataNode*>);
 
   void OnContextMenuRequested(const QPoint&);
+  void OnNodeRemoved(const mitk::DataNode* dataNode);
 
 private:
 
   void SetUpConnections();
   /**
   * @brief Provide a QItemSelectionModel, which supports the data role 'QmitkDataNodeRole' (\see QmitkRenderWindowDataModel).
   *
   * The provided QItemSelectionModel is used in the QmitkAbstractView-base class as the selection model of
   * the selection provider (\see QmitkAbstractView::SetSelectionProvider()).
   * The default selection provider is a QmitkDataNodeSelectionProvider. Each time a selection in the provided
   * QItemSeletionModel is changed, a selection changed event is fired. All plugins (views), that subclass the
   * QmitkAbstractView will be informed about the selection changed via the OnSelectionChanged-function.
   */
   virtual QItemSelectionModel* GetDataNodeSelectionModel() const override;
 
   virtual void NodeRemoved(const mitk::DataNode* dataNode) override;
 
   void RemoveFromComboBox(const mitk::SemanticTypes::CaseID& caseID);
 
-  void OpenInEditor(const mitk::DataNode::Pointer dataNode);
-  void JumpToPosition(const mitk::DataNode::Pointer dataNode);
+  void OpenInEditor(const mitk::DataNode* dataNode);
+  void JumpToPosition(const mitk::DataNode* dataNode);
 
   void AddImage(const mitk::DataNode* image);
   void AddSegmentation(const mitk::DataNode* segmentation);
 
   void RemoveImage(const mitk::DataNode* image);
   void RemoveSegmentation(const mitk::DataNode* segmentation);
 
   Ui::QmitkSemanticRelationsControls m_Controls;
   QmitkLesionInfoWidget* m_LesionInfoWidget;
   QmitkPatientTableInspector* m_PatientTableInspector;
   QmitkDnDDataNodeWidget* m_DnDDataNodeWidget;
 
   QMenu* m_ContextMenu;
   QmitkDataNodeInformationTypeAction* m_InformationTypeAction;
   QmitkDataNodeOpenInAction* m_OpenInAction;
 
   std::unique_ptr<mitk::SemanticRelations> m_SemanticRelations;
 };
 
 #endif // QMITKSEMANTICRELATIONSVIEW_H