diff --git a/Modules/DICOMQI/mitkDICOMQIIOMimeTypes.cpp b/Modules/DICOMQI/mitkDICOMQIIOMimeTypes.cpp
index f21818f64a..ff60364979 100644
--- a/Modules/DICOMQI/mitkDICOMQIIOMimeTypes.cpp
+++ b/Modules/DICOMQI/mitkDICOMQIIOMimeTypes.cpp
@@ -1,137 +1,135 @@
 /*===================================================================
 
 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 "mitkDICOMQIIOMimeTypes.h"
 #include "mitkIOMimeTypes.h"
 
 #include <mitkLogMacros.h>
 
 #include <itkGDCMImageIO.h>
 #include <itksys/SystemTools.hxx>
 
 #include <dcmtk/dcmdata/dcfilefo.h>
 #include <dcmtk/dcmdata/dcdeftag.h>
 
 namespace mitk
 {
   std::vector<CustomMimeType *> MitkDICOMQIIOMimeTypes::Get()
   {
     std::vector<CustomMimeType *> mimeTypes;
 
     // order matters here (descending rank for mime types)
 
     mimeTypes.push_back(DICOMSEG_MIMETYPE().Clone());
     //mimeTypes.push_back(DICOMPM_MIMETYPE().Clone());
 
     return mimeTypes;
   }
 
   // Mime Types
 
   //======= Mime Type DICOM SEG =======
   MitkDICOMQIIOMimeTypes::MitkDICOMSEGMimeType::MitkDICOMSEGMimeType() : CustomMimeType(DICOMSEG_MIMETYPE_NAME())
   {
     this->AddExtension("dcm");
     this->SetCategory(IOMimeTypes::CATEGORY_IMAGES());
     this->SetComment("DICOM SEG");
   }
 
   bool MitkDICOMQIIOMimeTypes::MitkDICOMSEGMimeType::AppliesTo(const std::string &path) const
   {
     std::ifstream myfile;
     myfile.open(path, std::ios::binary);
     //    myfile.seekg (128);
     char *buffer = new char[128];
     myfile.read(buffer, 128);
     myfile.read(buffer, 4);
     if (std::string(buffer).compare("DICM") != 0)
     {
       delete[] buffer;
       return false;
     }
     delete[] buffer;
 
     bool canRead(CustomMimeType::AppliesTo(path));
 
     // fix for bug 18572
     // Currently this function is called for writing as well as reading, in that case
     // the image information can of course not be read
     // This is a bug, this function should only be called for reading.
     if (!itksys::SystemTools::FileExists(path.c_str()))
     {
       return canRead;
     }
     // end fix for bug 18572
 
 
     DcmFileFormat dcmFileFormat;
     OFCondition status = dcmFileFormat.loadFile(path.c_str());
 
     if (status.bad())
     {
       canRead = false;
     }
 
     if (!canRead)
     {
       return canRead;
     }
 
     OFString modality;
     OFString sopClassUID;
     if (dcmFileFormat.getDataset()->findAndGetOFString(DCM_Modality, modality).good() && dcmFileFormat.getDataset()->findAndGetOFString(DCM_SOPClassUID, sopClassUID).good())
     {
       if (modality.compare("SEG") == 0)
       {//atm we could read SegmentationStorage files. Other storage classes with "SEG" modality, e.g. SurfaceSegmentationStorage (1.2.840.10008.5.1.4.1.1.66.5), are not supported yet.
         if (sopClassUID.compare("1.2.840.10008.5.1.4.1.1.66.4") == 0)
         {
           canRead = true;
         }
         else
         {
           canRead = false;
         }
       }
       else
       {
         canRead = false;
       }
     }
 
     return canRead;
   }
 
   MitkDICOMQIIOMimeTypes::MitkDICOMSEGMimeType *MitkDICOMQIIOMimeTypes::MitkDICOMSEGMimeType::Clone() const
   {
     return new MitkDICOMSEGMimeType(*this);
   }
 
   MitkDICOMQIIOMimeTypes::MitkDICOMSEGMimeType MitkDICOMQIIOMimeTypes::DICOMSEG_MIMETYPE()
   {
     return MitkDICOMSEGMimeType();
   }
 
   std::string MitkDICOMQIIOMimeTypes::DICOMSEG_MIMETYPE_NAME()
   {
     // create a unique and sensible name for this mime type
-    static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".image.dicom.seg";
-    return name;
+    return IOMimeTypes::DEFAULT_BASE_NAME() + ".image.dicom.seg";
   }
 
-
   //======= Mime Type DICOM PM =======
   //...
 }
diff --git a/Modules/Multilabel/mitkLabel.cpp b/Modules/Multilabel/mitkLabel.cpp
index e4045dbd12..8955f49d8c 100644
--- a/Modules/Multilabel/mitkLabel.cpp
+++ b/Modules/Multilabel/mitkLabel.cpp
@@ -1,301 +1,303 @@
 /*===================================================================
 
 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 "mitkLabel.h"
 
 #include "itkProcessObject.h"
 #include "tinyxml.h"
 #include <itkCommand.h>
 #include <mitkProperties.h>
-
+#include <mitkDICOMSegmentationPropertyHelper.h>
 #include <mitkStringProperty.h>
 
 const mitk::Label::PixelType mitk::Label::MAX_LABEL_VALUE = std::numeric_limits<mitk::Label::PixelType>::max();
 
 mitk::Label::Label() : PropertyList()
 {
   if (GetProperty("locked") == nullptr)
     SetLocked(true);
   if (GetProperty("visible") == nullptr)
     SetVisible(true);
   if (GetProperty("opacity") == nullptr)
     SetOpacity(0.6);
   if (GetProperty("center.coordinates") == nullptr)
   {
     mitk::Point3D pnt;
     pnt.SetElement(0, 0);
     pnt.SetElement(1, 0);
     pnt.SetElement(2, 0);
     SetCenterOfMassCoordinates(pnt);
   }
   if (GetProperty("center.index") == nullptr)
   {
     mitk::Point3D pnt;
     pnt.SetElement(0, 0);
     pnt.SetElement(1, 0);
     pnt.SetElement(2, 0);
     SetCenterOfMassIndex(pnt);
   }
   if (GetProperty("color") == nullptr)
   {
     mitk::Color col;
     col.Set(0, 0, 0);
     SetColor(col);
   }
   if (GetProperty("name") == nullptr)
     SetName("noName!");
   if (GetProperty("value") == nullptr)
     SetValue(0);
   if (GetProperty("layer") == nullptr)
     SetLayer(0);
+
+  DICOMSegmentationPropertyHandler::SetDICOMSegmentProperties(this);
 }
 
 mitk::Label::Label(const Label &other) : PropertyList(other)
 // copyconstructer of property List handles the coping action
 {
   auto *map = this->GetMap();
   auto it = map->begin();
   auto end = map->end();
 
   for (; it != end; ++it)
   {
     itk::SimpleMemberCommand<Label>::Pointer command = itk::SimpleMemberCommand<Label>::New();
     command->SetCallbackFunction(this, &Label::Modified);
     it->second->AddObserver(itk::ModifiedEvent(), command);
   }
 }
 
 mitk::Label::~Label()
 {
 }
 
 void mitk::Label::SetProperty(const std::string &propertyKey, BaseProperty *property, const std::string &contextName, bool fallBackOnDefaultContext)
 {
   itk::SimpleMemberCommand<Label>::Pointer command = itk::SimpleMemberCommand<Label>::New();
   command->SetCallbackFunction(this, &Label::Modified);
   property->AddObserver(itk::ModifiedEvent(), command);
 
   Superclass::SetProperty(propertyKey, property, contextName, fallBackOnDefaultContext);
 }
 
 void mitk::Label::SetLocked(bool locked)
 {
   mitk::BoolProperty *property = dynamic_cast<mitk::BoolProperty *>(GetProperty("locked"));
   if (property != nullptr)
     // Update Property
     property->SetValue(locked);
   else
     // Create new Property
     SetBoolProperty("locked", locked);
 }
 
 bool mitk::Label::GetLocked() const
 {
   bool locked;
   GetBoolProperty("locked", locked);
   return locked;
 }
 
 void mitk::Label::SetVisible(bool visible)
 {
   mitk::BoolProperty *property = dynamic_cast<mitk::BoolProperty *>(GetProperty("visible"));
   if (property != nullptr)
     // Update Property
     property->SetValue(visible);
   else
     // Create new Property
     SetBoolProperty("visible", visible);
 }
 
 bool mitk::Label::GetVisible() const
 {
   bool visible;
   GetBoolProperty("visible", visible);
   return visible;
 }
 
 void mitk::Label::SetOpacity(float opacity)
 {
   mitk::FloatProperty *property = dynamic_cast<mitk::FloatProperty *>(GetProperty("opacity"));
   if (property != nullptr)
     // Update Property
     property->SetValue(opacity);
   else
     // Create new Property
     SetFloatProperty("opacity", opacity);
 }
 
 float mitk::Label::GetOpacity() const
 {
   float opacity;
   GetFloatProperty("opacity", opacity);
   return opacity;
 }
 
 void mitk::Label::SetName(const std::string &name)
 {
   SetStringProperty("name", name.c_str());
 }
 
 std::string mitk::Label::GetName() const
 {
   std::string name;
   GetStringProperty("name", name);
   return name;
 }
 
 void mitk::Label::SetValue(PixelType pixelValue)
 {
   mitk::UShortProperty *property = dynamic_cast<mitk::UShortProperty *>(GetProperty("value"));
   if (property != nullptr)
     // Update Property
     property->SetValue(pixelValue);
   else
     // Create new Property
     SetProperty("value", mitk::UShortProperty::New(pixelValue));
 }
 
 mitk::Label::PixelType mitk::Label::GetValue() const
 {
   PixelType pixelValue;
   mitk::UShortProperty *property = dynamic_cast<UShortProperty *>(GetProperty("value"));
   assert(property);
   pixelValue = property->GetValue();
   return pixelValue;
 }
 
 void mitk::Label::SetLayer(unsigned int layer)
 {
   mitk::UIntProperty *property = dynamic_cast<mitk::UIntProperty *>(GetProperty("layer"));
   if (property != nullptr)
     // Update Property
     property->SetValue(layer);
   else
     // Create new Property
     SetProperty("layer", mitk::UIntProperty::New(layer));
 }
 
 unsigned int mitk::Label::GetLayer() const
 {
   unsigned int layer;
   mitk::UIntProperty *prop = dynamic_cast<mitk::UIntProperty *>(GetProperty("layer"));
   layer = prop->GetValue();
   return layer;
 }
 
 const mitk::Color &mitk::Label::GetColor() const
 {
   mitk::ColorProperty *colorProp = dynamic_cast<mitk::ColorProperty *>(GetProperty("color"));
   return colorProp->GetColor();
 }
 
 void mitk::Label::SetColor(const mitk::Color &_color)
 {
   mitk::ColorProperty *colorProp = dynamic_cast<mitk::ColorProperty *>(GetProperty("color"));
   if (colorProp != nullptr)
     // Update Property
     colorProp->SetColor(_color);
   else
     // Create new Property
     SetProperty("color", mitk::ColorProperty::New(_color));
 }
 
 void mitk::Label::SetCenterOfMassIndex(const mitk::Point3D &center)
 {
   mitk::Point3dProperty *property = dynamic_cast<mitk::Point3dProperty *>(GetProperty("center.index"));
   if (property != nullptr)
     // Update Property
     property->SetValue(center);
   else
     // Create new Property
     SetProperty("center.index", mitk::Point3dProperty::New(center));
 }
 
 mitk::Point3D mitk::Label::GetCenterOfMassIndex() const
 {
   mitk::Point3dProperty *property = dynamic_cast<mitk::Point3dProperty *>(GetProperty("center.index"));
   return property->GetValue();
 }
 
 void mitk::Label::SetCenterOfMassCoordinates(const mitk::Point3D &center)
 {
   mitk::Point3dProperty *property = dynamic_cast<mitk::Point3dProperty *>(GetProperty("center.coordinates"));
   if (property != nullptr)
     // Update Property
     property->SetValue(center);
   else
     // Create new Property
     SetProperty("center.coordinates", mitk::Point3dProperty::New(center));
 }
 
 mitk::Point3D mitk::Label::GetCenterOfMassCoordinates() const
 {
   mitk::Point3dProperty *property = dynamic_cast<mitk::Point3dProperty *>(GetProperty("center.coordinates"));
   return property->GetValue();
 }
 
 itk::LightObject::Pointer mitk::Label::InternalClone() const
 {
   itk::LightObject::Pointer result(new Self(*this));
   result->UnRegister();
   return result;
 }
 
 void mitk::Label::PrintSelf(std::ostream & /*os*/, itk::Indent /*indent*/) const
 {
   // todo
 }
 
 bool mitk::Equal(const mitk::Label &leftHandSide, const mitk::Label &rightHandSide, ScalarType /*eps*/, bool verbose)
 {
   MITK_INFO(verbose) << "--- Label Equal ---";
 
   bool returnValue = true;
   // have to be replaced until a PropertyList Equal was implemented :
   // returnValue = mitk::Equal((const mitk::PropertyList &)leftHandSide,(const mitk::PropertyList
   // &)rightHandSide,eps,verbose);
 
   const mitk::PropertyList::PropertyMap *lhsmap = leftHandSide.GetMap();
   const mitk::PropertyList::PropertyMap *rhsmap = rightHandSide.GetMap();
 
   returnValue = lhsmap->size() == rhsmap->size();
 
   if (!returnValue)
   {
     MITK_INFO(verbose) << "Labels in label container are not equal.";
     return returnValue;
   }
 
   auto lhsmapIt = lhsmap->begin();
   auto lhsmapItEnd = lhsmap->end();
 
   for (; lhsmapIt != lhsmapItEnd; ++lhsmapIt)
   {
     if (rhsmap->find(lhsmapIt->first) == rhsmap->end())
     {
       returnValue = false;
       break;
     }
   }
 
   if (!returnValue)
   {
     MITK_INFO(verbose) << "Labels in label container are not equal.";
     return returnValue;
   }
 
   return returnValue;
 }
diff --git a/Modules/QtWidgets/include/QmitkDnDDataNodeWidget.h b/Modules/QtWidgets/include/QmitkDnDDataNodeWidget.h
index 7a927a3314..baad4fe34b 100644
--- a/Modules/QtWidgets/include/QmitkDnDDataNodeWidget.h
+++ b/Modules/QtWidgets/include/QmitkDnDDataNodeWidget.h
@@ -1,66 +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 QMITKDNDDATANODEWIDGET_H
 #define QMITKDNDDATANODEWIDGET_H
 
 #include "MitkQtWidgetsExports.h"
 
 // mitk core module
 #include <mitkDataNode.h>
 
 // qt
 #include <QFrame>
 
 class QDragEnterEvent;
 class QDropEvent;
 
 /**
 * @brief A drag 'n' drop widget (QFrame) that checks the mime data of the incoming
 *        event. If the drag event is coming from another widget and the mime data
 *        is of type 'application/x-qmitk-datanode-ptrs' the node(s) will be dropped
 *        and a signal is emitted.
-*        A class including this dnd-widget can than handle the vector of dropped nodes
+*        A class including this DnD-widget can than handle the vector of dropped nodes
 *        appropriately.
-*
 */
 class MITKQTWIDGETS_EXPORT QmitkDnDDataNodeWidget : public QFrame
 {
   Q_OBJECT
 
 public:
 
   QmitkDnDDataNodeWidget(QWidget* parent = nullptr);
   ~QmitkDnDDataNodeWidget() override;
 
 Q_SIGNALS:
 
   /**
   * @brief The signal will be emitted if the drag events are accepted.
-  *        It contains the sending dnd-widget and the vector of nodes that have been dropped.
-  *
+  *        It contains the vector of nodes that have been dropped.
   */
-  void NodesDropped(QmitkDnDDataNodeWidget* dnDDataNodeWidget, std::vector<mitk::DataNode*> nodes);
+  void NodesDropped(std::vector<mitk::DataNode*> nodes);
 
 private:
 
   void dragEnterEvent(QDragEnterEvent* event) override;
   void dragMoveEvent(QDragMoveEvent* event) override;
   void dropEvent(QDropEvent* event) override;
 
 };
 
 #endif // QMITKDNDDATANODEWIDGET_H
diff --git a/Modules/QtWidgets/src/QmitkDnDDataNodeWidget.cpp b/Modules/QtWidgets/src/QmitkDnDDataNodeWidget.cpp
index 010e2504a0..fbdab13999 100644
--- a/Modules/QtWidgets/src/QmitkDnDDataNodeWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkDnDDataNodeWidget.cpp
@@ -1,70 +1,70 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <QmitkDnDDataNodeWidget.h>
 
 // mitk qt widgets module
 #include "QmitkMimeTypes.h"
 
 // qt
 #include <QMimeData>
 
 QmitkDnDDataNodeWidget::QmitkDnDDataNodeWidget(QWidget* parent /*= nullptr*/)
   : QFrame(parent)
 {
-  setAcceptDrops(true);
+  this->setAcceptDrops(true);
 }
 
 QmitkDnDDataNodeWidget::~QmitkDnDDataNodeWidget()
 {
   // nothing here
 }
 
 void QmitkDnDDataNodeWidget::dragEnterEvent(QDragEnterEvent* event)
 {
   if (this != event->source())
   {
     event->acceptProposedAction();
   }
   else
   {
     event->ignore();
   }
 }
 
 void QmitkDnDDataNodeWidget::dragMoveEvent(QDragMoveEvent* event)
 {
   if (event->mimeData()->hasFormat(QmitkMimeTypes::DataNodePtrs))
   {
     event->acceptProposedAction();
   }
   else
   {
     event->ignore();
   }
 }
 
 void QmitkDnDDataNodeWidget::dropEvent(QDropEvent* event)
 {
   QList<mitk::DataNode*> dataNodeList = QmitkMimeTypes::ToDataNodePtrList(event->mimeData());
   if (!dataNodeList.empty())
   {
-    emit NodesDropped(this, dataNodeList.toVector().toStdVector());
+    emit NodesDropped(dataNodeList.toVector().toStdVector());
   }
 
   event->acceptProposedAction();
 }
 
diff --git a/Modules/SemanticRelations/CMakeLists.txt b/Modules/SemanticRelations/CMakeLists.txt
index 916ed197cc..72db95214f 100644
--- a/Modules/SemanticRelations/CMakeLists.txt
+++ b/Modules/SemanticRelations/CMakeLists.txt
@@ -1,7 +1,7 @@
 MITK_CREATE_MODULE(
   DEPENDS MitkSceneSerializationBase MitkDICOMReader MitkMultilabel MitkPersistence
 )
 
 if(BUILD_TESTING)
-  ADD_SUBDIRECTORY(Testing)
+  ADD_SUBDIRECTORY(Test)
 endif(BUILD_TESTING)
diff --git a/Modules/SemanticRelations/Testing/CMakeLists.txt b/Modules/SemanticRelations/Test/CMakeLists.txt
similarity index 100%
rename from Modules/SemanticRelations/Testing/CMakeLists.txt
rename to Modules/SemanticRelations/Test/CMakeLists.txt
diff --git a/Modules/SemanticRelations/Test/files.cmake b/Modules/SemanticRelations/Test/files.cmake
new file mode 100644
index 0000000000..3e491291c0
--- /dev/null
+++ b/Modules/SemanticRelations/Test/files.cmake
@@ -0,0 +1,7 @@
+set(MODULE_TESTS
+    mitkSemanticRelationsTest.cpp
+)
+
+set(CPP_FILES
+    mitkSemanticRelationsTestHelper.cpp
+)
diff --git a/Modules/SemanticRelations/Test/mitkSemanticRelationsTest.cpp b/Modules/SemanticRelations/Test/mitkSemanticRelationsTest.cpp
new file mode 100644
index 0000000000..c38f4dcde7
--- /dev/null
+++ b/Modules/SemanticRelations/Test/mitkSemanticRelationsTest.cpp
@@ -0,0 +1,812 @@
+/*===================================================================
+
+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 semantic relations
+#include "mitkSemanticRelationException.h"
+#include "mitkSemanticRelationsInference.h"
+#include "mitkSemanticRelationsIntegration.h"
+#include "mitkSemanticRelationsDataStorageAccess.h"
+#include "mitkRelationStorage.h"
+#include "mitkControlPointManager.h"
+#include "mitkDICOMHelper.h"
+#include "mitkLesionManager.h"
+#include "mitkSemanticRelationsTestHelper.h"
+#include "mitkUIDGeneratorBoost.h"
+
+// mitk core
+#include <mitkStandaloneDataStorage.h>
+#include <mitkTestFixture.h>
+#include <mitkTestingMacros.h>
+#include <mitkPropertyNameHelper.h>
+
+// mitk persistence
+#include <mitkPersistenceService.h>
+
+class mitkSemanticRelationsTestSuite : public mitk::TestFixture
+{
+  CPPUNIT_TEST_SUITE(mitkSemanticRelationsTestSuite);
+  MITK_TEST(IntegrationTest);
+  MITK_TEST(InferenceTest);
+  MITK_TEST(DataStorageAccessTest);
+  MITK_TEST(RemoveAndUnlinkTest);
+  CPPUNIT_TEST_SUITE_END();
+
+private:
+
+  mitk::DataStorage::Pointer m_DataStorage;
+
+public:
+
+  void setUp() override
+  {
+    mitk::PersistenceService::LoadModule();
+    m_DataStorage = mitk::StandaloneDataStorage::New();
+  }
+
+  void tearDown() override
+  {
+    // clear semantic relations storage
+    mitk::SemanticRelationsTestHelper::ClearRelationStorage();
+  }
+
+  //////////////////////////////////////////////////////////////////////////
+  // SPECIFIC TEST GROUPS
+  //////////////////////////////////////////////////////////////////////////
+  void IntegrationTest()
+  {
+    MITK_INFO << "=== IntegrationTest start ===";
+    AddNewData();
+    ExaminationPeriod();
+    SegmentationAndLesion();
+    InvalidData();
+    MITK_INFO << "=== IntegrationTest end ===";
+  }
+
+  void InferenceTest()
+  {
+    MITK_INFO << "=== InferenceTest start ===";
+    CombinedQueries();
+    InstanceExistences();
+    MITK_INFO << "=== InferenceTest end ===";
+  }
+
+  void DataStorageAccessTest()
+  {
+    MITK_INFO << "=== DataStorageAccessTest start ===";
+    DataStorageAccess();
+    MITK_INFO << "=== DataStorageAccessTest end ===";
+  }
+
+  void RemoveAndUnlinkTest()
+  {
+    MITK_INFO << "=== RemoveAndUnlinkTest start ===";
+    CPRemoveAndUnlink();
+    LesionRemoveAndUnlink();
+    RemoveImagesAndSegmentation();
+    MITK_INFO << "=== RemoveAndUnlinkTest end ===";
+  }
+
+  //////////////////////////////////////////////////////////////////////////
+  // SPECIFIC TESTS
+  //////////////////////////////////////////////////////////////////////////
+  // IntegrationTest
+  void AddNewData()
+  {
+    MITK_INFO << "=== AddNewData";
+
+    // load data
+    mitk::SemanticRelationsIntegration semanticRelationsIntegration;
+
+    auto image = mitk::SemanticRelationsTestHelper::GetPatientOneCTImage();
+    m_DataStorage->Add(image);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", image.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", image->GetData() != nullptr);
+    semanticRelationsIntegration.AddImage(image);
+
+    // start test
+    auto allCaseIDs = mitk::RelationStorage::GetAllCaseIDs();
+    CPPUNIT_ASSERT_MESSAGE("CaseID not correctly stored", allCaseIDs.front() == "Patient1");
+    auto caseID = allCaseIDs.front();
+
+    // test control point
+    auto allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One control point should be stored", allControlPoints.size() == 1);
+
+    auto controlPointOfImage = mitk::SemanticRelationsInference::GetControlPointOfImage(image);
+    mitk::SemanticTypes::ControlPoint controlPointToCompare;
+    controlPointToCompare.date = boost::gregorian::date(2019, 01, 01);
+    CPPUNIT_ASSERT_MESSAGE("Control point not correctly stored", controlPointOfImage.date == controlPointToCompare.date);
+
+    // test information type
+    auto allInformationTypes = mitk::RelationStorage::GetAllInformationTypesOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One information type should be stored", allInformationTypes.size() == 1);
+
+    auto informationType = mitk::SemanticRelationsInference::GetInformationTypeOfImage(image);
+    CPPUNIT_ASSERT_MESSAGE("Information type not correctly stored", informationType == "CT");
+
+    semanticRelationsIntegration.SetInformationType(image, "MR");
+    informationType = mitk::SemanticRelationsInference::GetInformationTypeOfImage(image);
+    CPPUNIT_ASSERT_MESSAGE("Information type not correctly stored", informationType == "MR");
+  }
+
+  void ExaminationPeriod()
+  {
+    MITK_INFO << "=== ExaminationPeriod";
+
+    // load data
+    mitk::SemanticRelationsIntegration semanticRelationsIntegration;
+
+    auto MRImage = mitk::SemanticRelationsTestHelper::GetPatientOneMRImage();
+    m_DataStorage->Add(MRImage);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", MRImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", MRImage->GetData() != nullptr);
+    semanticRelationsIntegration.AddImage(MRImage);
+
+    // start test
+    auto allCaseIDs = mitk::RelationStorage::GetAllCaseIDs();
+    CPPUNIT_ASSERT_MESSAGE("One CaseID should be stored", allCaseIDs.size() == 1);
+    auto caseID = allCaseIDs.front();
+
+    auto allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One control point should be stored", allControlPoints.size() == 1);
+
+    auto controlPointOfImage = mitk::SemanticRelationsInference::GetControlPointOfImage(MRImage);
+    mitk::SemanticTypes::ControlPoint controlPoint;
+    controlPoint.date = boost::gregorian::date(2019, 01, 01);
+    CPPUNIT_ASSERT_MESSAGE("Control point not correctly stored", controlPointOfImage.date == controlPoint.date);
+
+    auto examinationPeriod = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One examination period should be stored", examinationPeriod.size() == 1);
+
+    auto allImageIDs = mitk::RelationStorage::GetAllImageIDsOfControlPoint(caseID, controlPointOfImage);
+    CPPUNIT_ASSERT_MESSAGE("Two images should reference the same control point", allImageIDs.size() == 2);
+
+    // add additional control point to the same examination period
+    // load data
+    auto CTImage = mitk::SemanticRelationsTestHelper::GetPatientOneOtherCTImage();
+    m_DataStorage->Add(CTImage);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", CTImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", CTImage->GetData() != nullptr);
+    semanticRelationsIntegration.AddImage(CTImage);
+
+    // start test
+    allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Two control points should be stored", allControlPoints.size() == 2);
+
+    examinationPeriod = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One examination period should be stored", examinationPeriod.size() == 1);
+
+    // modify control point to create new examination period
+    // current control point is 2019, 01, 31
+    // new control point should exceed threshold (30 days) and create new examination period
+    // new control point is 2019, 02, 01
+    controlPoint.UID = mitk::UIDGeneratorBoost::GenerateUID();
+    controlPoint.date = boost::gregorian::date(2019, 02, 01);
+    semanticRelationsIntegration.UnlinkImageFromControlPoint(CTImage);
+    semanticRelationsIntegration.SetControlPointOfImage(CTImage, controlPoint);
+
+    allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Two control points should be stored", allControlPoints.size() == 2);
+
+    examinationPeriod = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Two examination periods should be stored", examinationPeriod.size() == 2);
+  }
+
+  void SegmentationAndLesion()
+  {
+    MITK_INFO << "=== SegmentationAndLesion";
+
+    // load data
+    mitk::SemanticRelationsIntegration semanticRelationsIntegration;
+
+    // Patient2
+    auto image = mitk::SemanticRelationsTestHelper::GetPatientTwoPETImage();
+    m_DataStorage->Add(image);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", image.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", image->GetData() != nullptr);
+    semanticRelationsIntegration.AddImage(image);
+
+    auto segmentation = mitk::SemanticRelationsTestHelper::GetPatientTwoSegmentation();
+    m_DataStorage->Add(segmentation, image);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid segmentation data node", segmentation.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Segmentation data is empty", segmentation->GetData() != nullptr);
+    semanticRelationsIntegration.AddSegmentation(segmentation, image);
+
+    // start test
+    auto allCaseIDs = mitk::RelationStorage::GetAllCaseIDs();
+    CPPUNIT_ASSERT_MESSAGE("Two CaseIDs should be stored", allCaseIDs.size() == 2);
+
+    // test lesion (add and link)
+    auto lesion = mitk::GenerateNewLesion();
+    semanticRelationsIntegration.AddLesionAndLinkSegmentation(segmentation, lesion);
+
+    auto representedLesion = mitk::SemanticRelationsInference::GetLesionOfSegmentation(segmentation);
+    CPPUNIT_ASSERT_MESSAGE("Represented lesion should be the only stored lesion", lesion.UID == representedLesion.UID);
+  }
+
+  void InvalidData()
+  {
+    MITK_INFO << "=== InvalidData";
+
+    // TEST INVALID CASE ID
+    std::string caseID = "invalidID";
+    auto allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("No lesion should be stored, given a non-existing CaseID", allLesions.size() == 0);
+
+    auto allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("No control point should be stored, given a non-existing CaseID", allControlPoints.size() == 0);
+
+    auto allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("No examination periods should be stored, given a non-existing CaseID", allExaminationPeriods.size() == 0);
+
+    auto allInformationTypes = mitk::RelationStorage::GetAllInformationTypesOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("No information type should be stored, given a non-existing CaseID", allInformationTypes.size() == 0);
+
+    auto allImageIDsOfCase = mitk::RelationStorage::GetAllImageIDsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("No image ID should be stored, given a non-existing CaseID", allControlPoints.size() == 0);
+
+    // TEST INVALID DATE
+    mitk::DataNode::Pointer invalidDateImage = mitk::SemanticRelationsTestHelper::GetInvalidDate();
+    m_DataStorage->Add(invalidDateImage);
+
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", invalidDateImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", invalidDateImage->GetData() != nullptr);
+
+    mitk::SemanticRelationsIntegration semanticRelationsIntegration;
+    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: AddImage",
+      semanticRelationsIntegration.AddImage(invalidDateImage),
+      mitk::SemanticRelationException);
+
+    auto controlPointOfImage = mitk::SemanticRelationsInference::GetControlPointOfImage(invalidDateImage);
+    CPPUNIT_ASSERT_MESSAGE("No control point should be stored for an invalid DICOM date", controlPointOfImage.UID.empty());
+
+    // set invalid date format for current image
+    // 0x0008, 0x0022 (AcquisitionDate), should be 20180101
+    invalidDateImage->GetData()->SetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x0022).c_str(),
+      mitk::StringProperty::New("201811"));
+    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: GenerateControlPoint",
+      mitk::GenerateControlPoint(invalidDateImage),
+      mitk::SemanticRelationException);
+
+    // set valid date format for current image and add image again (only control point should be updated)
+    // 0x0008, 0x0022 (AcquisitionDate), should be 20180101
+    invalidDateImage->GetData()->SetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x0022).c_str(),
+      mitk::StringProperty::New("20180101"));
+    semanticRelationsIntegration.AddImage(invalidDateImage);
+
+    controlPointOfImage = mitk::SemanticRelationsInference::GetControlPointOfImage(invalidDateImage);
+    mitk::SemanticTypes::ControlPoint controlPointToCompare;
+    controlPointToCompare.date = boost::gregorian::date(2018, 01, 01);
+    CPPUNIT_ASSERT_MESSAGE("Control point not correctly stored", controlPointOfImage.date == controlPointToCompare.date);
+
+    // TEST INVALID MODALITY
+    mitk::DataNode::Pointer invalidModalityImage = mitk::SemanticRelationsTestHelper::GetInvalidModality();
+    m_DataStorage->Add(invalidModalityImage);
+
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", invalidModalityImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", invalidModalityImage->GetData() != nullptr);
+
+    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: AddImage",
+      semanticRelationsIntegration.AddImage(invalidModalityImage),
+      mitk::SemanticRelationException);
+
+    auto informationTypeOfImage = mitk::SemanticRelationsInference::GetInformationTypeOfImage(invalidModalityImage);
+    CPPUNIT_ASSERT_MESSAGE("No information type should be stored for an invalid DICOM date", informationTypeOfImage.empty());
+
+    // set valid modality for current image and add image again
+    // 0x0008, 0x0060 (Modality), should be CT
+    invalidModalityImage->GetData()->SetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x0060).c_str(),
+      mitk::StringProperty::New("CT"));
+    semanticRelationsIntegration.AddImage(invalidModalityImage);
+
+    auto informationType = mitk::SemanticRelationsInference::GetInformationTypeOfImage(invalidModalityImage);
+    CPPUNIT_ASSERT_MESSAGE("Information type not correctly stored", informationType == "CT");
+
+    // TEST INVALID ID
+    mitk::DataNode::Pointer invalidIDImage = mitk::SemanticRelationsTestHelper::GetInvalidID();
+    m_DataStorage->Add(invalidIDImage);
+
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", invalidModalityImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", invalidModalityImage->GetData() != nullptr);
+
+    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: AddImage",
+      semanticRelationsIntegration.AddImage(invalidIDImage),
+      mitk::SemanticRelationException);
+
+    // set valid ID for current image and add image again
+    // 0x0020, 0x000e (SeriesInstanceUID)
+    auto generatedUID = mitk::UIDGeneratorBoost::GenerateUID();
+    invalidIDImage->GetData()->SetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0020, 0x000e).c_str(),
+      mitk::StringProperty::New(generatedUID));
+    semanticRelationsIntegration.AddImage(invalidIDImage);
+
+    auto IDFromNode = mitk::GetIDFromDataNode(invalidIDImage);
+    CPPUNIT_ASSERT_MESSAGE("ID not correctly stored", IDFromNode == generatedUID);
+
+    // TEST INVALID CASE ID
+    mitk::DataNode::Pointer invalidCaseIDImage = mitk::SemanticRelationsTestHelper::GetInvalidCaseID();
+    m_DataStorage->Add(invalidCaseIDImage);
+
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", invalidModalityImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", invalidModalityImage->GetData() != nullptr);
+
+    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: AddImage",
+      semanticRelationsIntegration.AddImage(invalidCaseIDImage),
+      mitk::SemanticRelationException);
+
+    // set valid case ID for current image and add image again
+    // 0x0010, 0x0010 (PatientName)
+    invalidCaseIDImage->GetData()->SetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0010, 0x0010).c_str(),
+      mitk::StringProperty::New("Patient7"));
+    semanticRelationsIntegration.AddImage(invalidCaseIDImage);
+
+    auto caseIDFromNode = mitk::GetCaseIDFromDataNode(invalidCaseIDImage);
+    CPPUNIT_ASSERT_MESSAGE("Case ID not correctly stored", caseIDFromNode == "Patient7");
+  }
+
+  // InferenceTest
+  void CombinedQueries()
+  {
+    MITK_INFO << "=== CombinedQueries";
+
+    // add image with segmentation and lesion
+    auto image = mitk::SemanticRelationsTestHelper::GetPatientTwoPETImage();
+    m_DataStorage->Add(image);
+
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", image.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", image->GetData() != nullptr);
+
+    auto segmentation = mitk::SemanticRelationsTestHelper::GetPatientTwoSegmentation();
+    m_DataStorage->Add(segmentation, image);
+
+    CPPUNIT_ASSERT_MESSAGE("Not a valid segmentation data node", segmentation.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Segmentation data is empty", segmentation->GetData() != nullptr);
+
+    mitk::SemanticRelationsIntegration semanticRelationsIntegration;
+    semanticRelationsIntegration.AddImage(image);
+    semanticRelationsIntegration.AddSegmentation(segmentation, image);
+
+    auto caseID = mitk::GetCaseIDFromDataNode(image);
+
+    auto lesion = mitk::GenerateNewLesion();
+    semanticRelationsIntegration.AddLesionAndLinkSegmentation(segmentation, lesion);
+
+    auto allLesionsOfImage = mitk::SemanticRelationsInference::GetAllLesionsOfImage(image);
+    CPPUNIT_ASSERT_MESSAGE("One lesion should be stored", allLesionsOfImage.size() == 1);
+
+    auto controlPoint = mitk::SemanticRelationsInference::GetControlPointOfImage(image);
+    auto allLesionsOfControlPoint = mitk::SemanticRelationsInference::GetAllLesionsOfControlPoint(caseID, controlPoint);
+    CPPUNIT_ASSERT_MESSAGE("Lesions should be the same", (allLesionsOfImage.size() == allLesionsOfControlPoint.size())
+      && (allLesionsOfImage.front().UID == allLesionsOfControlPoint.front().UID));
+
+    auto allImageIDsOfLesion = mitk::SemanticRelationsInference::GetAllImageIDsOfLesion(caseID, allLesionsOfControlPoint.front());
+    CPPUNIT_ASSERT_MESSAGE("Image IDs should be the same", (allImageIDsOfLesion.size() == 1)
+      && (allImageIDsOfLesion.front() == mitk::GetIDFromDataNode(image)));
+
+    auto allControlPointsOfLesion = mitk::SemanticRelationsInference::GetAllControlPointsOfLesion(caseID, allLesionsOfImage.front());
+    CPPUNIT_ASSERT_MESSAGE("Control points should be the same", (allControlPointsOfLesion.size() == 1)
+      && (allControlPointsOfLesion.front().date == controlPoint.date));
+
+    auto informationType = mitk::SemanticRelationsInference::GetInformationTypeOfImage(image);
+    auto allControlPointsOfInformationType = mitk::SemanticRelationsInference::GetAllControlPointsOfInformationType(caseID, informationType);
+    CPPUNIT_ASSERT_MESSAGE("Control points should be the same", (allControlPointsOfLesion.size() == 1)
+      && (allControlPointsOfLesion.front().date == controlPoint.date));
+
+    auto allInformationTypesOfControlPoint = mitk::SemanticRelationsInference::GetAllInformationTypesOfControlPoint(caseID, controlPoint);
+    CPPUNIT_ASSERT_MESSAGE("Information types should be the same", (allInformationTypesOfControlPoint.size() == 1)
+      && (allInformationTypesOfControlPoint.front() == informationType));
+  }
+
+  void InstanceExistences()
+  {
+    MITK_INFO << "=== InstanceExistences";
+
+    mitk::SemanticRelationsDataStorageAccess semanticRelationsDataStorageAccess(m_DataStorage);
+    auto allSegmentationsOfCase = semanticRelationsDataStorageAccess.GetAllSegmentationsOfCase("Patient2");
+    CPPUNIT_ASSERT_MESSAGE("One segmentation should be stored", allSegmentationsOfCase.size() == 1);
+
+    auto segmentation = allSegmentationsOfCase.front();
+    CPPUNIT_ASSERT_MESSAGE("Not a valid segmentation data node", segmentation.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Segmentation data is empty", segmentation->GetData() != nullptr);
+
+    bool valid = mitk::SemanticRelationsInference::IsRepresentingALesion(segmentation);
+    CPPUNIT_ASSERT_MESSAGE("Segmentation node should represent a lesion", valid);
+
+    auto caseID = "Patient2";
+    valid = mitk::SemanticRelationsInference::IsRepresentingALesion(caseID, mitk::GetIDFromDataNode(segmentation));
+    CPPUNIT_ASSERT_MESSAGE("Segmentation (via ID) should represent a lesion", valid);
+
+    auto allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One lesion should be stored", allLesions.size() == 1);
+
+    auto lesion = allLesions.front();
+    valid = mitk::SemanticRelationsInference::IsLesionPresent(lesion, segmentation);
+    CPPUNIT_ASSERT_MESSAGE("Lesion should be present on segmentation", valid);
+
+    auto allImagesOfCase = semanticRelationsDataStorageAccess.GetAllImagesOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One image should be stored", allImagesOfCase.size() == 1);
+
+    auto image = allImagesOfCase.front();
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", image.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", image->GetData() != nullptr);
+
+    valid = mitk::SemanticRelationsInference::IsLesionPresent(lesion, image);
+    CPPUNIT_ASSERT_MESSAGE("Lesion should be present on image", valid);
+
+    valid = mitk::SemanticRelationsInference::IsLesionPresentOnImage(caseID, lesion, mitk::GetIDFromDataNode(image));
+    CPPUNIT_ASSERT_MESSAGE("Lesion should be present on segmentation", valid);
+
+    valid = mitk::SemanticRelationsInference::IsLesionPresentOnSegmentation(caseID, lesion, mitk::GetIDFromDataNode(segmentation));
+    CPPUNIT_ASSERT_MESSAGE("Lesion should be present on image", valid);
+
+    auto controlPoint = mitk::SemanticRelationsInference::GetControlPointOfImage(image);
+    valid = mitk::SemanticRelationsInference::IsLesionPresentAtControlPoint(caseID, lesion, controlPoint);
+    CPPUNIT_ASSERT_MESSAGE("Lesion should be present at control point", valid);
+
+    controlPoint.date = boost::gregorian::date(2019, 01, 01);
+    valid = mitk::SemanticRelationsInference::IsLesionPresentAtControlPoint(caseID, lesion, controlPoint);
+    CPPUNIT_ASSERT_MESSAGE("No lesion should be present at control point", !valid);
+
+    valid = mitk::SemanticRelationsInference::InstanceExists(image);
+    CPPUNIT_ASSERT_MESSAGE("Image should exist", valid);
+
+    valid = mitk::SemanticRelationsInference::InstanceExists(segmentation);
+    CPPUNIT_ASSERT_MESSAGE("Segmentation should exist", valid);
+
+    valid = mitk::SemanticRelationsInference::InstanceExists(caseID, lesion);
+    CPPUNIT_ASSERT_MESSAGE("Lesion should exist", valid);
+
+    auto emptyLesion = mitk::GenerateNewLesion("ExampleLesionClass");
+    valid = mitk::SemanticRelationsInference::InstanceExists(caseID, emptyLesion);
+    CPPUNIT_ASSERT_MESSAGE("Lesion should not exist", !valid);
+
+    auto newControlPoint = mitk::SemanticTypes::ControlPoint();
+    valid = mitk::SemanticRelationsInference::InstanceExists(caseID, newControlPoint);
+    CPPUNIT_ASSERT_MESSAGE("Control point should not exist for this case", !valid);
+
+    valid = mitk::SemanticRelationsInference::InstanceExists(caseID, controlPoint);
+    CPPUNIT_ASSERT_MESSAGE("Control point should exist for this case", valid);
+
+    auto allExaminationPeriod = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One examination period should be stored", allExaminationPeriod.size() == 1);
+    auto examinationPeriod = allExaminationPeriod.front();
+
+    valid = mitk::SemanticRelationsInference::InstanceExists(caseID, examinationPeriod);
+    CPPUNIT_ASSERT_MESSAGE("Examination period should exist for this case", valid);
+
+    auto informationType = mitk::SemanticRelationsInference::GetInformationTypeOfImage(image);
+    valid = mitk::SemanticRelationsInference::InstanceExists(caseID, informationType);
+    CPPUNIT_ASSERT_MESSAGE("Control point should exist for this case", valid);
+
+    valid = mitk::SemanticRelationsInference::InstanceExists(caseID, "CT");
+    CPPUNIT_ASSERT_MESSAGE("Control point should not exist for this case", !valid);
+
+    valid = mitk::SemanticRelationsInference::SpecificImageExists(caseID, lesion, informationType);
+    CPPUNIT_ASSERT_MESSAGE("Specific image should exist for this case", valid);
+
+    valid = mitk::SemanticRelationsInference::SpecificImageExists(caseID, lesion, controlPoint);
+    CPPUNIT_ASSERT_MESSAGE("Specific image should exist for this case", valid);
+
+    valid = mitk::SemanticRelationsInference::SpecificImageExists(caseID, informationType, controlPoint);
+    CPPUNIT_ASSERT_MESSAGE("Specific image should exist for this case", valid);
+  }
+
+  // DataStorageAccessTest
+  void DataStorageAccess()
+  {
+    MITK_INFO << "=== DataStorageAccess";
+
+    // load data
+    mitk::SemanticRelationsIntegration semanticRelationsIntegration;
+
+    // Patient1
+    auto CTImage = mitk::SemanticRelationsTestHelper::GetPatientOneCTImage();
+    m_DataStorage->Add(CTImage);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", CTImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", CTImage->GetData() != nullptr);
+    semanticRelationsIntegration.AddImage(CTImage);
+
+    auto MRImage = mitk::SemanticRelationsTestHelper::GetPatientOneMRImage();
+    m_DataStorage->Add(MRImage);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", MRImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", MRImage->GetData() != nullptr);
+    semanticRelationsIntegration.AddImage(MRImage);
+
+    auto otherCTImage = mitk::SemanticRelationsTestHelper::GetPatientOneOtherCTImage();
+    m_DataStorage->Add(otherCTImage);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", otherCTImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", otherCTImage->GetData() != nullptr);
+    semanticRelationsIntegration.AddImage(otherCTImage);
+
+    // Patient2
+    auto PETImage = mitk::SemanticRelationsTestHelper::GetPatientTwoPETImage();
+    m_DataStorage->Add(PETImage);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", PETImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", PETImage->GetData() != nullptr);
+    semanticRelationsIntegration.AddImage(PETImage);
+
+    auto PETSegmentation = mitk::SemanticRelationsTestHelper::GetPatientTwoSegmentation();
+    m_DataStorage->Add(PETSegmentation, PETImage);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid segmentation data node", PETSegmentation.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Segmentation data is empty", PETSegmentation->GetData() != nullptr);
+    semanticRelationsIntegration.AddSegmentation(PETSegmentation, PETImage);
+
+    auto lesion = mitk::GenerateNewLesion();
+    semanticRelationsIntegration.AddLesionAndLinkSegmentation(PETSegmentation, lesion);
+
+    // start test
+    mitk::SemanticRelationsDataStorageAccess semanticRelationsDataStorageAccess(m_DataStorage);
+
+    auto caseID = "Patient1";
+    auto allSegmentationsOfCase = semanticRelationsDataStorageAccess.GetAllSegmentationsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("No segmentation should be stored", allSegmentationsOfCase.size() == 0);
+
+    auto allImagesOfCase = semanticRelationsDataStorageAccess.GetAllImagesOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Three images should be stored", allImagesOfCase.size() == 3);
+
+    auto allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("No lesion should be stored", allLesions.size() == 0);
+
+    auto emptyLesion = mitk::GenerateNewLesion("ExampleLesionClass");
+    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: GetAllSegmentationsOfLesion",
+      semanticRelationsDataStorageAccess.GetAllSegmentationsOfLesion(caseID, emptyLesion),
+      mitk::SemanticRelationException);
+
+    caseID = "Patient2";
+    allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One lesion should be stored", allLesions.size() == 1);
+
+    lesion = allLesions.front();
+    auto allSegmentationsOfLesion = semanticRelationsDataStorageAccess.GetAllSegmentationsOfLesion(caseID, lesion);
+    CPPUNIT_ASSERT_MESSAGE("One segmentation should be stored", allSegmentationsOfLesion.size() == 1);
+
+    auto allImagesOfLesion = semanticRelationsDataStorageAccess.GetAllImagesOfLesion(caseID, lesion);
+    CPPUNIT_ASSERT_MESSAGE("One image should be stored", allImagesOfLesion.size() == 1);
+
+    auto allControlPointsOfLesion = mitk::SemanticRelationsInference::GetAllControlPointsOfLesion(caseID, lesion);
+    CPPUNIT_ASSERT_MESSAGE("One control point should be stored", allControlPointsOfLesion.size() == 1);
+    auto controlPoint = allControlPointsOfLesion.front();
+
+    auto allSpecificImages = semanticRelationsDataStorageAccess.GetAllSpecificImages(caseID, controlPoint, "PT");
+    CPPUNIT_ASSERT_MESSAGE("One image should be stored", allSpecificImages.size() == 1);
+
+    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: GetAllSpecificImages",
+      semanticRelationsDataStorageAccess.GetAllSpecificImages(caseID, controlPoint, "CT"),
+      mitk::SemanticRelationException);
+
+    auto allSpecificSegmentations = semanticRelationsDataStorageAccess.GetAllSpecificSegmentations(caseID, controlPoint, "PT");
+    CPPUNIT_ASSERT_MESSAGE("One segmentation should be stored", allSpecificSegmentations.size() == 1);
+
+    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: GetAllSpecificSegmentations",
+      semanticRelationsDataStorageAccess.GetAllSpecificSegmentations(caseID, controlPoint, "MR"),
+      mitk::SemanticRelationException);
+  }
+
+  // RemoveAndUnlinkTest
+  void CPRemoveAndUnlink()
+  {
+    MITK_INFO << "=== RemoveAndUnlink";
+
+    // load data
+    mitk::SemanticRelationsIntegration semanticRelationsIntegration;
+
+    auto CTImage = mitk::SemanticRelationsTestHelper::GetPatientThreeCTImage();
+    m_DataStorage->Add(CTImage);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", CTImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", CTImage->GetData() != nullptr);
+    semanticRelationsIntegration.AddImage(CTImage);
+
+    auto MRImage = mitk::SemanticRelationsTestHelper::GetPatientThreeMRImage();
+    m_DataStorage->Add(MRImage);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", MRImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", MRImage->GetData() != nullptr);
+    semanticRelationsIntegration.AddImage(MRImage);
+
+    // start test
+    auto allCaseIDs = mitk::RelationStorage::GetAllCaseIDs();
+    CPPUNIT_ASSERT_MESSAGE("One CaseID should be stored", allCaseIDs.size() == 1);
+
+    auto caseID = allCaseIDs.front();
+    CPPUNIT_ASSERT_MESSAGE("CaseID should be Patient3", caseID == "Patient3");
+
+    auto allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One examination period should be sored", allExaminationPeriods.size() == 1);
+
+    auto allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Two control points should be stored", allControlPoints.size() == 2);
+
+    // control points
+    auto CTControlPoint = mitk::SemanticRelationsInference::GetControlPointOfImage(CTImage);
+    semanticRelationsIntegration.UnlinkImageFromControlPoint(CTImage);
+
+    allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One examination period should be stored", allExaminationPeriods.size() == 1);
+
+    allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One control point should be stored since one has been removed", allControlPoints.size() == 1);
+
+    CTControlPoint = mitk::SemanticRelationsInference::GetControlPointOfImage(CTImage);
+    CPPUNIT_ASSERT_MESSAGE("Control point should be removed", CTControlPoint.UID.empty());
+
+    CTControlPoint = mitk::GenerateControlPoint(CTImage);
+    semanticRelationsIntegration.SetControlPointOfImage(CTImage, CTControlPoint);
+
+    allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One examination period should be sored", allExaminationPeriods.size() == 1);
+
+    allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Two control points should be stored", allControlPoints.size() == 2);
+
+    mitk::SemanticTypes::ControlPoint newCTControlPoint;
+    newCTControlPoint.UID = mitk::UIDGeneratorBoost::GenerateUID();
+    newCTControlPoint.date = boost::gregorian::date(2019, 03, 01);
+    semanticRelationsIntegration.SetControlPointOfImage(CTImage, newCTControlPoint);
+
+    allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One examination period should be sored", allExaminationPeriods.size() == 1);
+
+    allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Two control points should be stored", allControlPoints.size() == 2);
+
+    newCTControlPoint.UID = mitk::UIDGeneratorBoost::GenerateUID();
+    newCTControlPoint.date = boost::gregorian::date(2019, 01, 01);
+    semanticRelationsIntegration.SetControlPointOfImage(CTImage, newCTControlPoint);
+
+    allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Two examination periods should be stored", allExaminationPeriods.size() == 2);
+
+    allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Two control points should be stored", allControlPoints.size() == 2);
+  }
+
+  void LesionRemoveAndUnlink()
+  {
+    MITK_INFO << "=== LesionRemoveAndUnlink";
+
+    // load data
+    mitk::SemanticRelationsIntegration semanticRelationsIntegration;
+    mitk::SemanticRelationsDataStorageAccess semanticRelationsDataStorageAccess(m_DataStorage);
+
+    auto allCaseIDs = mitk::RelationStorage::GetAllCaseIDs();
+    CPPUNIT_ASSERT_MESSAGE("One CaseID should be stored", allCaseIDs.size() == 1);
+    auto caseID = allCaseIDs.front();
+
+    auto allImages = semanticRelationsDataStorageAccess.GetAllImagesOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Two images should be stored", allImages.size() == 2);
+
+    auto allCTImageIDs = mitk::RelationStorage::GetAllImageIDsOfInformationType(caseID, "CT");
+    CPPUNIT_ASSERT_MESSAGE("One image should be stored", allCTImageIDs.size() == 1);
+
+    auto allMRImageIDs = mitk::RelationStorage::GetAllImageIDsOfInformationType(caseID, "MR");
+    CPPUNIT_ASSERT_MESSAGE("One image should be stored", allMRImageIDs.size() == 1);
+
+    mitk::DataNode::Pointer CTImage;
+    mitk::DataNode::Pointer MRImage;
+    for (const auto& image : allImages)
+    {
+      auto imageID = mitk::GetIDFromDataNode(image);
+      if (imageID == allCTImageIDs.front())
+      {
+        CTImage = image;
+      }
+      else if (imageID == allMRImageIDs.front())
+      {
+        MRImage = image;
+      }
+    }
+
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", CTImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", CTImage->GetData() != nullptr);
+
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", MRImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", MRImage->GetData() != nullptr);
+
+    auto CTSegmentation = mitk::SemanticRelationsTestHelper::GetPatientThreeCTSegmentation();
+    m_DataStorage->Add(CTSegmentation, CTImage);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid segmentation data node", CTSegmentation.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Segmentation data is empty", CTSegmentation->GetData() != nullptr);
+    semanticRelationsIntegration.AddSegmentation(CTSegmentation, CTImage);
+
+    auto MRSegmentation = mitk::SemanticRelationsTestHelper::GetPatientThreeMRSegmentation();
+    m_DataStorage->Add(MRSegmentation, MRImage);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid segmentation data node", MRSegmentation.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Segmentation data is empty", MRSegmentation->GetData() != nullptr);
+    semanticRelationsIntegration.AddSegmentation(MRSegmentation, MRImage);
+
+    auto newLesion = mitk::GenerateNewLesion();
+    semanticRelationsIntegration.AddLesionAndLinkSegmentation(CTSegmentation, newLesion);
+    newLesion = mitk::GenerateNewLesion();
+    semanticRelationsIntegration.AddLesionAndLinkSegmentation(MRSegmentation, newLesion);
+
+    // start test
+    auto allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Two lesions should be stored", allLesions.size() == 2);
+
+    auto MRLesion = mitk::SemanticRelationsInference::GetLesionOfSegmentation(MRSegmentation);
+    semanticRelationsIntegration.UnlinkSegmentationFromLesion(MRSegmentation);
+
+    allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Two lesions should be stored", allLesions.size() == 2);
+
+    auto emptyLesion = mitk::SemanticRelationsInference::GetLesionOfSegmentation(MRSegmentation);
+    CPPUNIT_ASSERT_MESSAGE("Lesion should be removed", emptyLesion.UID.empty());
+
+    semanticRelationsIntegration.LinkSegmentationToLesion(MRSegmentation, MRLesion);
+    allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Two lesions should be stored", allLesions.size() == 2);
+
+    auto CTLesion = mitk::SemanticRelationsInference::GetLesionOfSegmentation(CTSegmentation);
+    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: RemoveLesion",
+      semanticRelationsIntegration.RemoveLesion(caseID, CTLesion),
+      mitk::SemanticRelationException);
+
+    semanticRelationsIntegration.UnlinkSegmentationFromLesion(CTSegmentation);
+    semanticRelationsIntegration.RemoveLesion(caseID, CTLesion);
+
+    allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One lesions should be stored since one has been removed", allLesions.size() == 1);
+
+    CTLesion = mitk::SemanticRelationsInference::GetLesionOfSegmentation(CTSegmentation);
+    CPPUNIT_ASSERT_MESSAGE("Lesion should be removed", CTLesion.UID.empty());
+  }
+
+  void RemoveImagesAndSegmentation()
+  {
+    MITK_INFO << "=== RemoveImagesAndSegmentation";
+
+    // load data
+    mitk::SemanticRelationsIntegration semanticRelationsIntegration;
+    mitk::SemanticRelationsDataStorageAccess semanticRelationsDataStorageAccess(m_DataStorage);
+
+    auto allCaseIDs = mitk::RelationStorage::GetAllCaseIDs();
+    CPPUNIT_ASSERT_MESSAGE("One CaseID should be stored", allCaseIDs.size() == 1);
+    auto caseID = allCaseIDs.front();
+
+    auto allImages = semanticRelationsDataStorageAccess.GetAllImagesOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Two images should be stored", allImages.size() == 2);
+
+    auto allSegmentations = semanticRelationsDataStorageAccess.GetAllSegmentationsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Two segmentations should be stored", allSegmentations.size() == 2);
+
+    for (const auto& image : allImages)
+    {
+      semanticRelationsIntegration.RemoveImage(image);
+    }
+
+    for (const auto& segmentation : allSegmentations)
+    {
+      semanticRelationsIntegration.RemoveSegmentation(segmentation);
+    }
+
+    allImages = semanticRelationsDataStorageAccess.GetAllImagesOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("No images should be stored", allImages.size() == 0);
+
+    allSegmentations = semanticRelationsDataStorageAccess.GetAllSegmentationsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("No segmentations should be stored", allSegmentations.size() == 0);
+
+    auto allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("No control point should be stored", allControlPoints.size() == 0);
+
+    auto allInformationTypes = mitk::RelationStorage::GetAllInformationTypesOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("No information type should be stored", allInformationTypes.size() == 0);
+
+    auto allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One lesions should be stored", allLesions.size() == 1);
+  }
+  
+};
+
+MITK_TEST_SUITE_REGISTRATION(mitkSemanticRelations)
diff --git a/Modules/SemanticRelations/Test/mitkSemanticRelationsTestHelper.cpp b/Modules/SemanticRelations/Test/mitkSemanticRelationsTestHelper.cpp
new file mode 100644
index 0000000000..ad47a94f29
--- /dev/null
+++ b/Modules/SemanticRelations/Test/mitkSemanticRelationsTestHelper.cpp
@@ -0,0 +1,335 @@
+/*===================================================================
+
+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 "mitkSemanticRelationsTestHelper.h"
+
+// mitk semantic relations
+#include "mitkDICOMHelper.h"
+#include "mitkRelationStorage.h"
+#include "mitkUIDGeneratorBoost.h"
+
+// mitk core
+#include <mitkImage.h>
+#include <mitkIPersistenceService.h>
+#include <mitkTemporoSpatialStringProperty.h>
+
+// mitk multilabel
+#include <mitkLabelSetImage.h>
+
+mitk::DataNode::Pointer mitk::SemanticRelationsTestHelper::GetPatientOneCTImage()
+{
+  // create new empty image
+  Image::Pointer image = Image::New();
+
+  // set properties of image (base data)
+  image->SetProperty(GetCaseIDDICOMProperty().c_str(),
+    StringProperty::New("Patient1"));
+  image->SetProperty(GetNodeIDDICOMProperty().c_str(),
+    StringProperty::New(UIDGeneratorBoost::GenerateUID()));
+  image->SetProperty(GetDateDICOMProperty().c_str(),
+    StringProperty::New("20190101"));
+  image->SetProperty(GetModalityDICOMProperty().c_str(),
+    StringProperty::New("CT"));
+
+  // create new data node and add image as base data
+  DataNode::Pointer dataNode = DataNode::New();
+  dataNode->SetData(image);
+
+  return dataNode;
+}
+
+mitk::DataNode::Pointer mitk::SemanticRelationsTestHelper::GetPatientOneMRImage()
+{
+  // create new empty image
+  Image::Pointer image = Image::New();
+
+  // set properties of image (base data)
+  image->SetProperty(GetCaseIDDICOMProperty().c_str(),
+    StringProperty::New("Patient1"));
+  image->SetProperty(GetNodeIDDICOMProperty().c_str(),
+    StringProperty::New(UIDGeneratorBoost::GenerateUID()));
+  image->SetProperty(GetDateDICOMProperty().c_str(),
+    StringProperty::New("20190101"));
+  image->SetProperty(GetModalityDICOMProperty().c_str(),
+    StringProperty::New("MR"));
+
+  // create new data node and add image as base data
+  DataNode::Pointer dataNode = DataNode::New();
+  dataNode->SetData(image);
+
+  return dataNode;
+}
+
+mitk::DataNode::Pointer mitk::SemanticRelationsTestHelper::GetPatientOneOtherCTImage()
+{
+  // create new empty image
+  Image::Pointer image = Image::New();
+
+  // set properties of image (base data)
+  image->SetProperty(GetCaseIDDICOMProperty().c_str(),
+    StringProperty::New("Patient1"));
+  image->SetProperty(GetNodeIDDICOMProperty().c_str(),
+    StringProperty::New(UIDGeneratorBoost::GenerateUID()));
+  image->SetProperty(GetDateDICOMProperty().c_str(),
+    StringProperty::New("20190131"));
+  image->SetProperty(GetModalityDICOMProperty().c_str(),
+    StringProperty::New("CT"));
+
+  // create new data node and add image as base data
+  DataNode::Pointer dataNode = DataNode::New();
+  dataNode->SetData(image);
+
+  return dataNode;
+}
+
+mitk::DataNode::Pointer mitk::SemanticRelationsTestHelper::GetPatientTwoPETImage()
+{
+  // create new empty image
+  Image::Pointer image = Image::New();
+
+  // set properties of image (base data)
+  image->SetProperty(GetCaseIDDICOMProperty().c_str(),
+    StringProperty::New("Patient2"));
+  image->SetProperty(GetNodeIDDICOMProperty().c_str(),
+    StringProperty::New(UIDGeneratorBoost::GenerateUID()));
+  image->SetProperty(GetDateDICOMProperty().c_str(),
+    StringProperty::New("20180101"));
+  image->SetProperty(GetModalityDICOMProperty().c_str(),
+    StringProperty::New("PT"));
+
+  // create new data node and add image as base data
+  DataNode::Pointer dataNode = DataNode::New();
+  dataNode->SetData(image);
+
+  return dataNode;
+}
+
+mitk::DataNode::Pointer mitk::SemanticRelationsTestHelper::GetPatientTwoSegmentation()
+{
+  // create new empty segmentation
+  LabelSetImage::Pointer segmentation = LabelSetImage::New();
+
+  // set properties of segmentation (base data)
+  segmentation->SetProperty(GetCaseIDDICOMProperty().c_str(),
+    TemporoSpatialStringProperty::New("Patient2"));
+  segmentation->SetProperty(GetNodeIDDICOMProperty().c_str(),
+    TemporoSpatialStringProperty::New(UIDGeneratorBoost::GenerateUID()));
+  segmentation->SetProperty(GetDateDICOMProperty().c_str(),
+    TemporoSpatialStringProperty::New("20180101"));
+  // segmentation modality is 'SEG'
+
+  // create new data node and add segmentation as base data
+  DataNode::Pointer dataNode = DataNode::New();
+  dataNode->SetData(segmentation);
+
+  return dataNode;
+}
+
+mitk::DataNode::Pointer mitk::SemanticRelationsTestHelper::GetPatientThreeCTImage()
+{
+  // create new empty image
+  Image::Pointer image = Image::New();
+
+  // set properties of image (base data)
+  image->SetProperty(GetCaseIDDICOMProperty().c_str(),
+    StringProperty::New("Patient3"));
+  image->SetProperty(GetNodeIDDICOMProperty().c_str(),
+    StringProperty::New(UIDGeneratorBoost::GenerateUID()));
+  image->SetProperty(GetDateDICOMProperty().c_str(),
+    StringProperty::New("20190201"));
+  image->SetProperty(GetModalityDICOMProperty().c_str(),
+    StringProperty::New("CT"));
+
+  // create new data node and add image as base data
+  DataNode::Pointer dataNode = DataNode::New();
+  dataNode->SetData(image);
+
+  return dataNode;
+}
+
+mitk::DataNode::Pointer mitk::SemanticRelationsTestHelper::GetPatientThreeCTSegmentation()
+{
+  // create new empty segmentation
+  LabelSetImage::Pointer segmentation = LabelSetImage::New();
+
+  // set properties of segmentation (base data)
+  segmentation->SetProperty(GetCaseIDDICOMProperty().c_str(),
+    TemporoSpatialStringProperty::New("Patient3"));
+  segmentation->SetProperty(GetNodeIDDICOMProperty().c_str(),
+    TemporoSpatialStringProperty::New(UIDGeneratorBoost::GenerateUID()));
+  segmentation->SetProperty(GetDateDICOMProperty().c_str(),
+    TemporoSpatialStringProperty::New("20190201"));
+  // segmentation modality is 'SEG'
+
+  // create new data node and add segmentation as base data
+  DataNode::Pointer dataNode = DataNode::New();
+  dataNode->SetData(segmentation);
+
+  return dataNode;
+}
+
+mitk::DataNode::Pointer mitk::SemanticRelationsTestHelper::GetPatientThreeMRImage()
+{
+  // create new empty image
+  Image::Pointer image = Image::New();
+
+  // set properties of image (base data)
+  image->SetProperty(GetCaseIDDICOMProperty().c_str(),
+    StringProperty::New("Patient3"));
+  image->SetProperty(GetNodeIDDICOMProperty().c_str(),
+    StringProperty::New(UIDGeneratorBoost::GenerateUID()));
+  image->SetProperty(GetDateDICOMProperty().c_str(),
+    StringProperty::New("20190215"));
+  image->SetProperty(GetModalityDICOMProperty().c_str(),
+    StringProperty::New("MR"));
+
+  // create new data node and add image as base data
+  DataNode::Pointer dataNode = DataNode::New();
+  dataNode->SetData(image);
+
+  return dataNode;
+}
+
+mitk::DataNode::Pointer mitk::SemanticRelationsTestHelper::GetPatientThreeMRSegmentation()
+{
+  // create new empty segmentation
+  LabelSetImage::Pointer segmentation = LabelSetImage::New();
+
+  // set properties of segmentation (base data)
+  segmentation->SetProperty(GetCaseIDDICOMProperty().c_str(),
+    TemporoSpatialStringProperty::New("Patient3"));
+  segmentation->SetProperty(GetNodeIDDICOMProperty().c_str(),
+    TemporoSpatialStringProperty::New(UIDGeneratorBoost::GenerateUID()));
+  segmentation->SetProperty(GetDateDICOMProperty().c_str(),
+    TemporoSpatialStringProperty::New("20190215"));
+  // segmentation modality is 'SEG'
+
+  // create new data node and add segmentation as base data
+  DataNode::Pointer dataNode = DataNode::New();
+  dataNode->SetData(segmentation);
+
+  return dataNode;
+}
+
+mitk::DataNode::Pointer mitk::SemanticRelationsTestHelper::GetInvalidDate()
+{
+  // create new empty image
+  Image::Pointer image = Image::New();
+
+  // set properties of image (base data)
+  image->SetProperty(GetCaseIDDICOMProperty().c_str(),
+    StringProperty::New("Patient4"));
+  image->SetProperty(GetNodeIDDICOMProperty().c_str(),
+    StringProperty::New(UIDGeneratorBoost::GenerateUID()));
+
+  // no DICOM information for Date
+
+  image->SetProperty(GetModalityDICOMProperty().c_str(),
+    StringProperty::New("CT"));
+
+  // create new data node and add image as base data
+  DataNode::Pointer dataNode = DataNode::New();
+  dataNode->SetData(image);
+
+  return dataNode;
+}
+
+mitk::DataNode::Pointer mitk::SemanticRelationsTestHelper::GetInvalidModality()
+{
+  // create new empty image
+  Image::Pointer image = Image::New();
+
+  // set properties of image (base data)
+  image->SetProperty(GetCaseIDDICOMProperty().c_str(),
+    StringProperty::New("Patient5"));
+  image->SetProperty(GetNodeIDDICOMProperty().c_str(),
+    StringProperty::New(UIDGeneratorBoost::GenerateUID()));
+  image->SetProperty(GetDateDICOMProperty().c_str(),
+    StringProperty::New("20180101"));
+
+  // no DICOM information for Modality
+
+  // create new data node and add image as base data
+  DataNode::Pointer dataNode = DataNode::New();
+  dataNode->SetData(image);
+
+  return dataNode;
+}
+
+mitk::DataNode::Pointer mitk::SemanticRelationsTestHelper::GetInvalidID()
+{
+  // create new empty image
+  Image::Pointer image = Image::New();
+
+  // set properties of image (base data)
+  image->SetProperty(GetCaseIDDICOMProperty().c_str(),
+    StringProperty::New("Patient6"));
+
+  // no DICOM information for NodeID
+
+  image->SetProperty(GetDateDICOMProperty().c_str(),
+    StringProperty::New("20180101"));
+  image->SetProperty(GetModalityDICOMProperty().c_str(),
+    StringProperty::New("CT"));
+
+  // create new data node and add image as base data
+  DataNode::Pointer dataNode = DataNode::New();
+  dataNode->SetData(image);
+
+  return dataNode;
+}
+
+mitk::DataNode::Pointer mitk::SemanticRelationsTestHelper::GetInvalidCaseID()
+{
+  // create new empty image
+  Image::Pointer image = Image::New();
+
+  // set properties of image (base data)
+  // no DICOM information for CaseID
+
+  image->SetProperty(GetNodeIDDICOMProperty().c_str(),
+    StringProperty::New(UIDGeneratorBoost::GenerateUID()));
+  image->SetProperty(GetDateDICOMProperty().c_str(),
+    StringProperty::New("20180101"));
+  image->SetProperty(GetModalityDICOMProperty().c_str(),
+    StringProperty::New("CT"));
+
+  // create new data node and add image as base data
+  DataNode::Pointer dataNode = DataNode::New();
+  dataNode->SetData(image);
+
+  return dataNode;
+}
+
+void mitk::SemanticRelationsTestHelper::ClearRelationStorage()
+{
+  // access the storage
+  PERSISTENCE_GET_SERVICE_MACRO
+    if (nullptr == persistenceService)
+    {
+      MITK_DEBUG << "Persistence service could not be loaded";
+      return;
+    }
+
+  auto allCaseIDs = mitk::RelationStorage::GetAllCaseIDs();
+  for (auto& caseID : allCaseIDs)
+  {
+    persistenceService->RemovePropertyList(caseID);
+  }
+
+  std::string listIdentifier("caseIDs");
+  persistenceService->RemovePropertyList(listIdentifier);
+}
diff --git a/Modules/SemanticRelations/Test/mitkSemanticRelationsTestHelper.h b/Modules/SemanticRelations/Test/mitkSemanticRelationsTestHelper.h
new file mode 100644
index 0000000000..628b087f64
--- /dev/null
+++ b/Modules/SemanticRelations/Test/mitkSemanticRelationsTestHelper.h
@@ -0,0 +1,71 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+// mitk core
+#include <mitkDataNode.h>
+
+namespace mitk
+{
+  namespace SemanticRelationsTestHelper
+  {
+    //////////////////////////////////////////////////////////////////////////
+    // VALID DATA NODES
+    //////////////////////////////////////////////////////////////////////////
+    DataNode::Pointer GetPatientOneCTImage();
+
+    DataNode::Pointer GetPatientOneMRImage();
+
+    DataNode::Pointer GetPatientOneOtherCTImage();
+
+    DataNode::Pointer GetPatientTwoPETImage();
+
+    DataNode::Pointer GetPatientTwoSegmentation();
+
+    DataNode::Pointer GetPatientThreeCTImage();
+
+    DataNode::Pointer GetPatientThreeCTSegmentation();
+
+    DataNode::Pointer GetPatientThreeMRImage();
+
+    DataNode::Pointer GetPatientThreeMRSegmentation();
+
+    //////////////////////////////////////////////////////////////////////////
+    // INVALID DATA NODES
+    //////////////////////////////////////////////////////////////////////////
+    /**
+    * @brief Date is 0x0008, 0x0022 (AcquisitionDate)
+    */
+    DataNode::Pointer GetInvalidDate();
+    /**
+    * @brief Modality is 0x0008, 0x0060(Modality)
+    */
+    DataNode::Pointer GetInvalidModality();
+    /**
+    * @brief ID is 0x0020, 0x000e (SeriesInstanceUID)
+    */
+    DataNode::Pointer GetInvalidID();
+    /**
+    * @brief CaseID is 0x0010, 0x0010 (PatientName)
+    */
+    DataNode::Pointer GetInvalidCaseID();
+
+    //////////////////////////////////////////////////////////////////////////
+    // AUXILIARY FUNCTIONS
+    //////////////////////////////////////////////////////////////////////////
+    void ClearRelationStorage();
+
+  } // end SemanticRelationsTestHelper
+} // end mitk
diff --git a/Modules/SemanticRelations/Testing/files.cmake b/Modules/SemanticRelations/Testing/files.cmake
deleted file mode 100644
index 17436cc16b..0000000000
--- a/Modules/SemanticRelations/Testing/files.cmake
+++ /dev/null
@@ -1,3 +0,0 @@
-set(MODULE_TESTS
-    mitkSemanticRelationsTest.cpp
-)
diff --git a/Modules/SemanticRelations/Testing/mitkSemanticRelationsTest.cpp b/Modules/SemanticRelations/Testing/mitkSemanticRelationsTest.cpp
deleted file mode 100644
index ad477ed635..0000000000
--- a/Modules/SemanticRelations/Testing/mitkSemanticRelationsTest.cpp
+++ /dev/null
@@ -1,419 +0,0 @@
-/*===================================================================
-
-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 "mitkSemanticRelations.h"
-#include "mitkSemanticRelationException.h"
-
-// mitk core
-#include <mitkIOUtil.h>
-#include <mitkStandaloneDataStorage.h>
-#include <mitkPreferenceListReaderOptionsFunctor.h>
-#include <mitkPropertyNameHelper.h>
-#include <mitkTestFixture.h>
-#include <mitkTestingMacros.h>
-
-// mitk persistence
-#include <mitkPersistenceService.h>
-
-// mitk multilabel
-#include <mitkLabelSetImage.h>
-
-class mitkSemanticRelationsTestSuite : public mitk::TestFixture
-{
-  CPPUNIT_TEST_SUITE(mitkSemanticRelationsTestSuite);
-  MITK_TEST(CombinedTest);
-  CPPUNIT_TEST_SUITE_END();
-
-private:
-
-  mitk::DataStorage::Pointer m_DataStorage;
-  std::vector<mitk::BaseData::Pointer> m_BaseData;
-  mitk::PreferenceListReaderOptionsFunctor m_Functor;
-
-public:
-
-  void setUp() override
-  {
-    mitk::PersistenceService::LoadModule();
-
-    m_DataStorage = mitk::StandaloneDataStorage::New();
-
-    mitk::PreferenceListReaderOptionsFunctor::ListType preference = { "MITK DICOM Reader v2 (classic config)" };
-    mitk::PreferenceListReaderOptionsFunctor::ListType emptyList = {};
-
-    m_Functor = mitk::PreferenceListReaderOptionsFunctor(preference, emptyList);
-  }
-
-  void tearDown() override
-  {
-  }
-
-  void CombinedTest()
-  {
-    TestAddNewData();
-    ExtendControlPoint();
-    AddAndRemoveInformationType();
-    SegmentationAndLesion();
-    InvalidData();
-    CombinedQuery();
-    RemoveAndUnlink();
-    Exceptions();
-    Overwrite();
-  }
-
-  void TestAddNewData()
-  {
-    MITK_INFO << "TestAddNewData";
-    std::string testDataFilePath = GetTestDataFilePath("SemanticRelation/TCGA-VP-A87D/CT Pelvis/Abd/000000.dcm");
-    m_BaseData = mitk::IOUtil::Load(testDataFilePath, &m_Functor);
-    mitk::BaseData::Pointer imageData = m_BaseData.front();
-    mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
-    dataNode->SetData(imageData);
-    m_DataStorage->Add(dataNode);
-
-    CPPUNIT_ASSERT_MESSAGE("Not a valid data node", dataNode.IsNotNull());
-    CPPUNIT_ASSERT_MESSAGE("Image data is empty", dataNode->GetData() != nullptr);
-
-    mitk::SemanticRelations semanticRelations(m_DataStorage);
-    SemanticRelationsTestHelper::AddImageInstance(dataNode, semanticRelations);
-
-    std::vector<SemanticTypes::CaseID> allCaseIDs = semanticRelations.GetAllCaseIDs();
-    CPPUNIT_ASSERT_MESSAGE("CaseID not correctly stored", allCaseIDs.front() == "TCGA-VP-A87D");
-
-    SemanticTypes::ControlPoint controlPointOfData = semanticRelations.GetControlPointOfData(dataNode);
-    SemanticTypes::Date startDate; startDate.year = 1992; startDate.month = 12; startDate.day = 24;
-    SemanticTypes::Date endDate; endDate.year = 1992; endDate.month = 12; endDate.day = 24;
-    CPPUNIT_ASSERT_MESSAGE("Control point not correctly stored", controlPointOfData.startPoint == startDate && controlPointOfData.endPoint == endDate);
-  }
-
-  void ExtendControlPoint()
-  {
-    MITK_INFO << "ExtendControlPoint";
-    std::string testDataFilePath = GetTestDataFilePath("SemanticRelation/TCGA-VP-A87D/CT Pelvis/Abd Pel/000000.dcm");
-    m_BaseData = mitk::IOUtil::Load(testDataFilePath, &m_Functor);
-    mitk::BaseData::Pointer imageData = m_BaseData.front();
-    mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
-    dataNode->SetData(imageData);
-    m_DataStorage->Add(dataNode);
-
-    CPPUNIT_ASSERT_MESSAGE("Not a valid data node", dataNode.IsNotNull());
-    CPPUNIT_ASSERT_MESSAGE("Image data is empty", dataNode->GetData() != nullptr);
-
-    mitk::SemanticRelations semanticRelations(m_DataStorage);
-    SemanticRelationsTestHelper::AddImageInstance(dataNode, semanticRelations);
-
-    std::vector<SemanticTypes::CaseID> allCaseIDs = semanticRelations.GetAllCaseIDs();
-    CPPUNIT_ASSERT_MESSAGE("Only one CaseID should be stored", allCaseIDs.size() == 1);
-
-    std::vector<SemanticTypes::ControlPoint> allControlPoints = semanticRelations.GetAllControlPointsOfCase(allCaseIDs.front());
-    CPPUNIT_ASSERT_MESSAGE("Only one control point should be stored", allControlPoints.size() == 1);
-
-    SemanticTypes::ControlPoint controlPointOfData = semanticRelations.GetControlPointOfData(dataNode);
-    SemanticTypes::Date startDate; startDate.year = 1992; startDate.month = 12; startDate.day = 10;
-    SemanticTypes::Date endDate; endDate.year = 1992; endDate.month = 12; endDate.day = 24;
-    CPPUNIT_ASSERT_MESSAGE("Control point not correctly extended", controlPointOfData.startPoint == startDate && controlPointOfData.endPoint == endDate);
-
-    std::vector<mitk::DataNode::Pointer> allData = semanticRelations.GetAllDataOfControlPoint(allCaseIDs.front(), controlPointOfData);
-    CPPUNIT_ASSERT_MESSAGE("Two images should reference the control point", allData.size() == 2);
-  }
-
-  void AddAndRemoveInformationType()
-  {
-    MITK_INFO << "AddAndRemoveInformationType";
-    // load previously stored image
-    std::string testDataFilePath = GetTestDataFilePath("SemanticRelation/TCGA-VP-A87D/CT Pelvis/Abd Pel/000000.dcm");
-    m_BaseData = mitk::IOUtil::Load(testDataFilePath, &m_Functor);
-    mitk::BaseData::Pointer imageData = m_BaseData.front();
-    mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
-    dataNode->SetData(imageData);
-
-    CPPUNIT_ASSERT_MESSAGE("Not a valid data node", dataNode.IsNotNull());
-    CPPUNIT_ASSERT_MESSAGE("Image data is empty", dataNode->GetData() != nullptr);
-
-    mitk::SemanticRelations semanticRelations(m_DataStorage);
-
-    semanticRelations.AddInformationTypeToImage(dataNode, "CT");
-
-    std::vector<SemanticTypes::CaseID> allCaseIDs = semanticRelations.GetAllCaseIDs();
-    std::vector<SemanticTypes::InformationType> allInformationTypes = semanticRelations.GetAllInformationTypesOfCase(allCaseIDs.front());
-    CPPUNIT_ASSERT_MESSAGE("One information type should be stored", allInformationTypes.size() == 1);
-
-    SemanticTypes::InformationType informationType = semanticRelations.GetInformationTypeOfImage(dataNode);
-    CPPUNIT_ASSERT_MESSAGE("Information type should be equal to 'CT'", informationType == "CT");
-
-    semanticRelations.RemoveInformationTypeFromImage(dataNode, "CT");
-
-    allInformationTypes = semanticRelations.GetAllInformationTypesOfCase(allCaseIDs.front());
-    CPPUNIT_ASSERT_MESSAGE("No information type should be stored", allInformationTypes.size() == 0);
-  }
-
-  void SegmentationAndLesion()
-  {
-    MITK_INFO << "SegmentationAndLesion";
-    std::string testDataFilePath = GetTestDataFilePath("SemanticRelation/TCGA-VP-A87D/TUMOR PET RES/PET/000000.dcm");
-    m_BaseData = mitk::IOUtil::Load(testDataFilePath, &m_Functor);
-    mitk::BaseData::Pointer imageData = m_BaseData.front();
-    mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
-    dataNode->SetData(imageData);
-
-    CPPUNIT_ASSERT_MESSAGE("Not a valid data node", dataNode.IsNotNull());
-    CPPUNIT_ASSERT_MESSAGE("Image data is empty", dataNode->GetData() != nullptr);
-
-    mitk::LabelSetImage::Pointer segmentationImage = mitk::LabelSetImage::New();
-    
-    // workaround: manually set the PatientName tag: use the tag from the real DICOM image
-    mitk::PropertyList::Pointer segmentationPropertyList = mitk::PropertyList::New();
-    segmentationPropertyList->SetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0010, 0x0010).c_str(),
-                                          imageData->GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0010, 0x0010).c_str()));
-
-    // workaround: manually set the SeriesInstanceUID tag: use the tag from the real DICOM image and modify it to have different identifiers
-    std::string seriesInstanceUID = imageData->GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0020, 0x000e).c_str())->GetValueAsString() + "_S";
-    segmentationPropertyList->SetStringProperty(mitk::GeneratePropertyNameForDICOMTag(0x0020, 0x000e).c_str(), seriesInstanceUID.c_str());
-
-    segmentationImage->SetPropertyList(segmentationPropertyList);
-    mitk::DataNode::Pointer segmentationNode = mitk::DataNode::New();
-    segmentationNode->SetData(segmentationImage);
-    m_DataStorage->Add(segmentationNode, dataNode);
-
-    mitk::SemanticRelations semanticRelations(m_DataStorage);
-    SemanticRelationsTestHelper::AddSegmentationInstance(segmentationNode, dataNode, semanticRelations);
-
-    std::vector<SemanticTypes::CaseID> allCaseIDs = semanticRelations.GetAllCaseIDs();
-    CPPUNIT_ASSERT_MESSAGE("Only one CaseID should be stored", allCaseIDs.size() == 1);
-
-    std::vector<SemanticTypes::Lesion> allLesions = semanticRelations.GetAllLesionsInImage(dataNode);
-    CPPUNIT_ASSERT_MESSAGE("One lesion should be stored", allLesions.size() == 1);
-
-    SemanticTypes::Lesion representedLesion = semanticRelations.GetRepresentedLesion(segmentationNode);
-    CPPUNIT_ASSERT_MESSAGE("Represented lesion should be the only stored lesion", allLesions.front().UID == representedLesion.UID);
-  }
-
-  void InvalidData()
-  {
-    MITK_INFO << "InvalidData";
-    mitk::SemanticRelations semanticRelations(m_DataStorage);
-    std::vector<SemanticTypes::ControlPoint> allControlPoints = semanticRelations.GetAllControlPointsOfCase("noID");
-    CPPUNIT_ASSERT_MESSAGE("No control point should be stored, given a non-existing CaseID", allControlPoints.size() == 0);
-
-    // load new image but do not create any semantic relation
-    std::string testDataFilePath = GetTestDataFilePath("SemanticRelation/TCGA-VP-A87D/CT Abdomen/non-contrast/000000.dcm");
-    m_BaseData = mitk::IOUtil::Load(testDataFilePath, &m_Functor);
-    mitk::BaseData::Pointer imageData = m_BaseData.front();
-    mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
-    dataNode->SetData(imageData);
-
-    SemanticTypes::ControlPoint controlPoint = semanticRelations.GetControlPointOfData(dataNode);
-    CPPUNIT_ASSERT_MESSAGE("No control point should be stored for an image that is not stored", controlPoint.UID.empty());
-
-    // TODO: use invalid DICOM data (no tag - leads to empty case ID or empty node ID)
-  }
-
-  void CombinedQuery()
-  {
-    MITK_INFO << "CombinedQuery";
-    // load new image with a different time point
-    std::string testDataFilePath = GetTestDataFilePath("SemanticRelation/TCGA-VP-A87D/CT abd and Pelvis/CAP/000000.dcm");
-    m_BaseData = mitk::IOUtil::Load(testDataFilePath, &m_Functor);
-    mitk::BaseData::Pointer imageData = m_BaseData.front();
-    mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
-    dataNode->SetData(imageData);
-    m_DataStorage->Add(dataNode);
-
-    CPPUNIT_ASSERT_MESSAGE("Not a valid data node", dataNode.IsNotNull());
-    CPPUNIT_ASSERT_MESSAGE("Image data is empty", dataNode->GetData() != nullptr);
-
-    mitk::SemanticRelations semanticRelations(m_DataStorage);
-
-    SemanticRelationsTestHelper::AddImageInstance(dataNode, semanticRelations);
-
-    std::vector<SemanticTypes::CaseID> allCaseIDs = semanticRelations.GetAllCaseIDs();
-    CPPUNIT_ASSERT_MESSAGE("Only one CaseID should be stored", allCaseIDs.size() == 1);
-
-    std::vector<SemanticTypes::ControlPoint> allControlPoints = semanticRelations.GetAllControlPointsOfCase(allCaseIDs.front());
-    CPPUNIT_ASSERT_MESSAGE("Two different control points should be stored", allControlPoints.size() == 2);
-
-    semanticRelations.AddInformationTypeToImage(dataNode, "CT");
-    std::vector<SemanticTypes::InformationType> allInformationTypes = semanticRelations.GetAllInformationTypesOfCase(allCaseIDs.front());
-    CPPUNIT_ASSERT_MESSAGE("One information type should be stored", allInformationTypes.size() == 1);
-
-    std::vector<SemanticTypes::ControlPoint> filteredControlPoints = semanticRelations.GetAllControlPointsOfCase(allCaseIDs.front(), allInformationTypes.front());
-    allInformationTypes = semanticRelations.GetAllInformationTypesOfCase(allCaseIDs.front(), allControlPoints.back());
-    CPPUNIT_ASSERT_MESSAGE("Only one control points should match", filteredControlPoints.size() == 1);
-    CPPUNIT_ASSERT_MESSAGE("Only one information type should match", allInformationTypes.size() == 1);
-
-    filteredControlPoints = semanticRelations.GetAllControlPointsOfCase(allCaseIDs.front(), "MR");
-    allInformationTypes = semanticRelations.GetAllInformationTypesOfCase(allCaseIDs.front(), allControlPoints.front());
-    CPPUNIT_ASSERT_MESSAGE("No control point should match", filteredControlPoints.size() == 0);
-    CPPUNIT_ASSERT_MESSAGE("No information type should match", allInformationTypes.size() == 0);
-
-    std::vector<SemanticTypes::Lesion> allLesions = semanticRelations.GetAllLesionsOfCase(allCaseIDs.front());
-    CPPUNIT_ASSERT_MESSAGE("One lesion should be stored", allLesions.size() == 1);
-
-    std::vector<SemanticTypes::Lesion> filteredLesions = semanticRelations.GetAllLesionsOfCase(allCaseIDs.front(), allControlPoints.front());
-    CPPUNIT_ASSERT_MESSAGE("No lesion should match", filteredLesions.size() == 0);
-  }
-
-  void RemoveAndUnlink()
-  {
-    MITK_INFO << "RemoveAndUnlink";
-    /************************************************************************/
-    /* unlink and remove control point                                      */
-    /************************************************************************/
-    // load already stored image with its own single control point
-    std::string testDataFilePath = GetTestDataFilePath("SemanticRelation/TCGA-VP-A87D/CT abd and Pelvis/CAP/000000.dcm");
-    m_BaseData = mitk::IOUtil::Load(testDataFilePath, &m_Functor);
-    mitk::BaseData::Pointer imageData = m_BaseData.front();
-    mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
-    dataNode->SetData(imageData);
-
-    CPPUNIT_ASSERT_MESSAGE("Not a valid data node", dataNode.IsNotNull());
-    CPPUNIT_ASSERT_MESSAGE("Image data is empty", dataNode->GetData() != nullptr);
-
-    mitk::SemanticRelations semanticRelations(m_DataStorage);
-
-    SemanticTypes::ControlPoint singleControlPoint = semanticRelations.GetControlPointOfData(dataNode);
-    semanticRelations.UnlinkDataFromControlPoint(dataNode, singleControlPoint);
-
-    std::vector<SemanticTypes::CaseID> allCaseIDs = semanticRelations.GetAllCaseIDs();
-    CPPUNIT_ASSERT_MESSAGE("Only one CaseID should be stored", allCaseIDs.size() == 1);
-
-    std::vector<SemanticTypes::ControlPoint> allControlPoints = semanticRelations.GetAllControlPointsOfCase(allCaseIDs.front());
-    CPPUNIT_ASSERT_MESSAGE("Only one control point should be stored since one has been removed", allControlPoints.size() == 1);
-
-    singleControlPoint = semanticRelations.GetControlPointOfData(dataNode);
-    CPPUNIT_ASSERT_MESSAGE("Control point property not correctly reset", singleControlPoint.startPoint == SemanticTypes::ControlPoint().startPoint && singleControlPoint.endPoint == SemanticTypes::ControlPoint().endPoint);
-
-    // load already stored image which extended a previously existing control point
-    testDataFilePath = GetTestDataFilePath("SemanticRelation/TCGA-VP-A87D/CT Pelvis/Abd Pel/000000.dcm");
-    m_BaseData = mitk::IOUtil::Load(testDataFilePath, &m_Functor);
-    imageData = m_BaseData.front();
-    dataNode = mitk::DataNode::New();
-    dataNode->SetData(imageData);
-
-    CPPUNIT_ASSERT_MESSAGE("Not a valid data node", dataNode.IsNotNull());
-    CPPUNIT_ASSERT_MESSAGE("Image data is empty", dataNode->GetData() != nullptr);
-
-    SemanticTypes::ControlPoint extendedControlpoint = semanticRelations.GetControlPointOfData(dataNode);
-    semanticRelations.UnlinkDataFromControlPoint(dataNode, extendedControlpoint);
-
-    allControlPoints = semanticRelations.GetAllControlPointsOfCase(allCaseIDs.front());
-    CPPUNIT_ASSERT_MESSAGE("Still one control point should be stored since none has been removed", allControlPoints.size() == 1);
-
-    extendedControlpoint = allControlPoints.front();
-    SemanticTypes::Date startDate; startDate.year = 1992; startDate.month = 12; startDate.day = 24;
-    SemanticTypes::Date endDate; endDate.year = 1992; endDate.month = 12; endDate.day = 24;
-    CPPUNIT_ASSERT_MESSAGE("Control point not correctly computed", extendedControlpoint.startPoint == startDate && extendedControlpoint.endPoint == endDate);
-  }
-
-  void Exceptions()
-  {
-    MITK_INFO << "Exceptions";
-    /************************************************************************/
-    /* remove lesion                                                        */
-    /************************************************************************/
-    std::string testDataFilePath = GetTestDataFilePath("SemanticRelation/TCGA-VP-A87D/TUMOR PET RES/PET/000000.dcm");
-    m_BaseData = mitk::IOUtil::Load(testDataFilePath, &m_Functor);
-    mitk::BaseData::Pointer imageData = m_BaseData.front();
-
-    mitk::SemanticRelations semanticRelations(m_DataStorage);
-
-    mitk::LabelSetImage::Pointer segmentationImage = mitk::LabelSetImage::New();
-
-    // workaround: manually set the PatientName tag: use the tag from the real DICOM image
-    mitk::PropertyList::Pointer segmentationPropertyList = mitk::PropertyList::New();
-    segmentationPropertyList->SetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0010, 0x0010).c_str(),
-      imageData->GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0010, 0x0010).c_str()));
-
-    // workaround: manually set the SeriesInstanceUID tag: use the tag from the real DICOM image and modify it to have different identifiers
-    std::string seriesInstanceUID = imageData->GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0020, 0x000e).c_str())->GetValueAsString() + "_S";
-    segmentationPropertyList->SetStringProperty(mitk::GeneratePropertyNameForDICOMTag(0x0020, 0x000e).c_str(), seriesInstanceUID.c_str());
-
-    segmentationImage->SetPropertyList(segmentationPropertyList);
-    mitk::DataNode::Pointer segmentationNode = mitk::DataNode::New();
-    segmentationNode->SetData(segmentationImage);
-
-    std::vector<SemanticTypes::CaseID> allCaseIDs = semanticRelations.GetAllCaseIDs();
-    CPPUNIT_ASSERT_MESSAGE("Only one CaseID should be stored", allCaseIDs.size() == 1);
-
-    std::vector<SemanticTypes::Lesion> allLesions = semanticRelations.GetAllLesionsOfCase(allCaseIDs.front());
-    CPPUNIT_ASSERT_MESSAGE("One lesion should be stored", allLesions.size() == 1);
-
-    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: Remove lesion instance", semanticRelations.RemoveLesion(allCaseIDs.front(), allLesions.front()), mitk::SemanticRelationException);
-    // test adding a lesion instance that already exists
-    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: Add lesion instance", semanticRelations.AddLesion(allCaseIDs.front(), allLesions.front()), mitk::SemanticRelationException);
-
-    // use the test helper to remove the segmentation instance from the storage so that the referenced lesion instance can be removed (should not throw an exception)
-    SemanticRelationsTestHelper::RemoveSegmentationInstance(segmentationNode, semanticRelations);
-    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Semantic relation exception thrown: Remove lesion instance", semanticRelations.RemoveLesion(allCaseIDs.front(), allLesions.front()));
-    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Semantic relation exception not thrown: Add lesion instance", semanticRelations.AddLesion(allCaseIDs.front(), allLesions.front()));
-
-    // test invalid lesion, control point UID, information type
-    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: Get segmentations of lesion", semanticRelations.GetAllSegmentationsOfLesion(allCaseIDs.front(), SemanticTypes::Lesion()), mitk::SemanticRelationException);
-    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: Get data of control point", semanticRelations.GetAllDataOfControlPoint(allCaseIDs.front(), SemanticTypes::ControlPoint()), mitk::SemanticRelationException);
-    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: Get data of information type", semanticRelations.GetAllDataOfInformationType(allCaseIDs.front(), SemanticTypes::InformationType()), mitk::SemanticRelationException);
-
-    // test overwriting a lesion instance that does not exist
-    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: Add lesion instance", semanticRelations.OverwriteLesion(allCaseIDs.front(), SemanticTypes::Lesion()), mitk::SemanticRelationException);
-  }
-
-  void Overwrite()
-  {
-    MITK_INFO << "Overwrite";
-    mitk::SemanticRelations semanticRelations(m_DataStorage);
-
-    std::vector<SemanticTypes::CaseID> allCaseIDs = semanticRelations.GetAllCaseIDs();
-    CPPUNIT_ASSERT_MESSAGE("Only one CaseID should be stored", allCaseIDs.size() == 1);
-
-    std::vector<SemanticTypes::Lesion> allLesions = semanticRelations.GetAllLesionsOfCase(allCaseIDs.front());
-    CPPUNIT_ASSERT_MESSAGE("One lesion should be stored", allLesions.size() == 1);
-
-    SemanticTypes::Lesion overwritingLesion = allLesions.front();
-    SemanticTypes::LesionClass overwritingLesionClass = overwritingLesion.lesionClass;
-
-    CPPUNIT_ASSERT_MESSAGE("Only lesion should not have a lesion class", overwritingLesionClass.classType == "");
-
-    overwritingLesionClass.classType = "unspecified lesion class";
-    overwritingLesion.lesionClass = overwritingLesionClass;
-    semanticRelations.OverwriteLesion(allCaseIDs.front(), overwritingLesion);
-
-    CPPUNIT_ASSERT_MESSAGE("Only lesion should have an unspecified lesion class", overwritingLesionClass.classType == "unspecified lesion class");
-
-    // load an already stored image which extends a previously existing control point (was unlinked before)
-    std::string testDataFilePath = GetTestDataFilePath("SemanticRelation/TCGA-VP-A87D/CT Pelvis/Abd Pel/000000.dcm");
-    m_BaseData = mitk::IOUtil::Load(testDataFilePath, &m_Functor);
-    mitk::BaseData::Pointer imageData = m_BaseData.front();
-    mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
-    dataNode->SetData(imageData);
-
-    std::vector<SemanticTypes::ControlPoint> allControlPoints = semanticRelations.GetAllControlPointsOfCase(allCaseIDs.front());
-    CPPUNIT_ASSERT_MESSAGE("Only one control point should be stored", allControlPoints.size() == 1);
-
-    SemanticTypes::ControlPoint extendedControlPoint = ControlPointManager::ExtendClosestControlPoint(dataNode, allControlPoints);
-    CPPUNIT_ASSERT_MESSAGE("Extended control point should not be empty", extendedControlPoint.UID != "");
-
-    semanticRelations.OverwriteControlPointAndLinkData(dataNode, extendedControlPoint);
-
-    SemanticTypes::ControlPoint controlPointOfData = semanticRelations.GetControlPointOfData(dataNode);
-    SemanticTypes::Date startDate; startDate.year = 1992; startDate.month = 12; startDate.day = 10;
-    SemanticTypes::Date endDate; endDate.year = 1992; endDate.month = 12; endDate.day = 24;
-    CPPUNIT_ASSERT_MESSAGE("Control point not correctly extended", controlPointOfData.startPoint == startDate && controlPointOfData.endPoint == endDate);
-
-    std::vector<mitk::DataNode::Pointer> allData = semanticRelations.GetAllDataOfControlPoint(allCaseIDs.front(), controlPointOfData);
-    CPPUNIT_ASSERT_MESSAGE("Two images should reference the control point", allData.size() == 2);
-  }
-};
-
-MITK_TEST_SUITE_REGISTRATION(mitkSemanticRelations)
diff --git a/Modules/SemanticRelations/include/mitkDICOMHelper.h b/Modules/SemanticRelations/include/mitkDICOMHelper.h
index 082ad69e0f..9f99908c0c 100644
--- a/Modules/SemanticRelations/include/mitkDICOMHelper.h
+++ b/Modules/SemanticRelations/include/mitkDICOMHelper.h
@@ -1,110 +1,130 @@
 /*===================================================================
 
 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 MITKDICOMHELPER_H
 #define MITKDICOMHELPER_H
 
 #include <MitkSemanticRelationsExports.h>
 
 // semantic relations module
 #include "mitkSemanticTypes.h"
 
 // mitk core
 #include <mitkDataNode.h>
 #include <mitkDICOMTagPath.h>
 
 // c++
 #include <string>
 
 /*
 * @brief Provides helper functions to convert DICOM Tag information.
 *
 *   In order to identify the patient of an image or segmentation or to set the control point of DICOM data,
 *   these functions are used to retrieve the DICOM tags from the given data nodes and convert them into semantic types
 *   that can be used by the SemanticRelations class.
 */
 namespace mitk
 {
+  /**
+  * @brief Creates a property name for a DICOM tag.
+  *        The tag is "0x0010, 0x0010" (PatientName)
+  */
+  MITKSEMANTICRELATIONS_EXPORT std::string GetCaseIDDICOMProperty();
+  /**
+  * @brief Creates a property name for a DICOM tag.
+  *        The tag is "0x0020, 0x000e" (SeriesInstanceUID)
+  */
+  MITKSEMANTICRELATIONS_EXPORT std::string GetNodeIDDICOMProperty();
+  /**
+  * @brief Creates a property name for a DICOM tag.
+  *        The tag is "0x0008, 0x0022" (AcquisitionDate)
+  */
+  MITKSEMANTICRELATIONS_EXPORT std::string GetDateDICOMProperty();
+  /**
+  * @brief Creates a property name for a DICOM tag.
+  *        The tag is "0x0008, 0x0060" (Modality)
+  */
+  MITKSEMANTICRELATIONS_EXPORT std::string GetModalityDICOMProperty();
   /*
   * @brief  Extracts a specific DICOM tag from the node's base data
   *         and returns the tag as a string. This tag string is used as an identifier for the patient (case).
   *
   * @pre    The given data node or the node's base data has to be valid (!nullptr).
   * @pre    The node's base data has to have the specific DICOM Tag property set.
   * @throw  mitk::Exception if the given data node, the node's base data or the extracted DICOM tag are invalid (==nullptr).
   *
   * @par dataNode   The data node, of which the DICOM tag should be extracted.
   *
   * @return         The extracted DICOM tag as string.
   *                 An empty string, if the DICOM tag can not be extracted (i.e. the data node or
   *                 the underlying base data is invalid or the DICOM tag does not exist for the given data node).
   */
   MITKSEMANTICRELATIONS_EXPORT SemanticTypes::CaseID GetCaseIDFromDataNode(const mitk::DataNode* dataNode);
   /*
   * @brief Extracts a specific DICOM tag (currently "0x0020, 0x000e": SeriesInstanceUID) from the node's base data
   *        and returns the tag as a string. This tag string is used as an identifier for the image instance.
   *
   * @pre    The given data node or the node's base data has to be valid (!nullptr).
   * @pre    The node's base data has to have the "0x0020, 0x000e" DICOM Tag property set.
   * @throw  mitk::Exception if the given data node, the node's base data or the extracted DICOM tag are invalid (==nullptr).
   *
   * @par dataNode   The data node, of which the DICOM tag should be extracted.
   *
   * @return         The extracted DICOM tag as string.
   *                 An empty string, if the DICOM tag can not be extracted (i.e. the data node or
   *                 the underlying base data is invalid or the DICOM tag does not exist for the given data node).
   */
   MITKSEMANTICRELATIONS_EXPORT SemanticTypes::ID GetIDFromDataNode(const mitk::DataNode* dataNode);
   /*
   * @brief Extracts a specific DICOM tag (currently "0x0008, 0x0022": AcquisitionDate) from the node's base data
   *        and returns the tag as a control point.
   *
   * @pre    The given data node or the node's base data has to be valid (!nullptr).
   * @pre    The node's base data has to have the "0x0008, 0x0022" DICOM Tag property set.
   * @throw  mitk::Exception if the given data node, the node's base data or the extracted DICOM tag are invalid (==nullptr).
   *
   * @par dataNode   The data node, of which the DICOM tag should be extracted.
   *
   * @return         The extracted DICOM tag as control point.
   *                 An empty control point, if the DICOM tag can not be extracted (i.e. the data node or
   *                 the underlying base data is invalid or the DICOM tag does not exist for the given data node).
   */
   MITKSEMANTICRELATIONS_EXPORT SemanticTypes::ControlPoint GetDICOMDateFromDataNode(const mitk::DataNode* dataNode);
   /**
   * @brief Extracts a specific DICOM tag from the node's base data and returns the tag as a information type (a string).
   *
   * @pre    The given data node or the node's base data has to be valid (!nullptr).
   * @pre    The node's base data has to have the "0x0008, 0x0060" DICOM Tag property set.
   * @throw  mitk::Exception if the given data node, the node's base data or the extracted DICOM tag are invalid (==nullptr).
   *
   * @par dataNode   The data node, of which the DICOM tag should be extracted.
   *
   * @return         The extracted DICOM tag as information type (a string).
   *                 An empty information type, if the DICOM tag can not be extracted (i.e. the data node or
   *                 the underlying base data is invalid or the DICOM tag does not exist for the given data node).
   */
   MITKSEMANTICRELATIONS_EXPORT SemanticTypes::InformationType GetDICOMModalityFromDataNode(const mitk::DataNode* dataNode);
   /*
   * @brief Removes leading and trailing whitespace from the given string.
   *
   * @par identifier   The value of a DICOM tag.
   *
   * @return           The trimmed DICOM tag
   */
   MITKSEMANTICRELATIONS_EXPORT std::string TrimDICOM(const std::string& identifier);
 } // namespace mitk
 
 #endif // MITKDICOMHELPER_H
diff --git a/Modules/SemanticRelations/include/mitkRelationStorage.h b/Modules/SemanticRelations/include/mitkRelationStorage.h
index 1ba900ea77..08f6aecc12 100644
--- a/Modules/SemanticRelations/include/mitkRelationStorage.h
+++ b/Modules/SemanticRelations/include/mitkRelationStorage.h
@@ -1,81 +1,82 @@
 /*===================================================================
 
 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 MITKRELATIONSTORAGE_H
 #define MITKRELATIONSTORAGE_H
 
 #include <MitkSemanticRelationsExports.h>
 
 // semantic relations module
 #include "mitkSemanticTypes.h"
 
 namespace mitk
 {
   namespace RelationStorage
   {
     MITKSEMANTICRELATIONS_EXPORT SemanticTypes::LesionVector GetAllLesionsOfCase(const SemanticTypes::CaseID& caseID);
     SemanticTypes::Lesion GetLesionOfSegmentation(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& segmentationID);
 
-    SemanticTypes::ControlPoint GetControlPointOfImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID);
     MITKSEMANTICRELATIONS_EXPORT SemanticTypes::ControlPointVector GetAllControlPointsOfCase(const SemanticTypes::CaseID& caseID);
+    SemanticTypes::ControlPoint GetControlPointOfImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID);
 
     MITKSEMANTICRELATIONS_EXPORT SemanticTypes::ExaminationPeriodVector GetAllExaminationPeriodsOfCase(const SemanticTypes::CaseID& caseID);
 
-    SemanticTypes::InformationType GetInformationTypeOfImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID);
     MITKSEMANTICRELATIONS_EXPORT SemanticTypes::InformationTypeVector GetAllInformationTypesOfCase(const SemanticTypes::CaseID& caseID);
+    SemanticTypes::InformationType GetInformationTypeOfImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID);
 
-    SemanticTypes::IDVector GetAllImageIDsOfCase(const SemanticTypes::CaseID& caseID);
-    SemanticTypes::IDVector GetAllImageIDsOfControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint);
-    SemanticTypes::IDVector GetAllImageIDsOfInformationType(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType);
-    SemanticTypes::IDVector GetAllSegmentationIDsOfCase(const SemanticTypes::CaseID& caseID);
-    SemanticTypes::IDVector GetAllSegmentationIDsOfImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID);
-    SemanticTypes::IDVector GetAllSegmentationIDsOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion);
+    MITKSEMANTICRELATIONS_EXPORT SemanticTypes::IDVector GetAllImageIDsOfCase(const SemanticTypes::CaseID& caseID);
+    MITKSEMANTICRELATIONS_EXPORT SemanticTypes::IDVector GetAllImageIDsOfControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint);
+    MITKSEMANTICRELATIONS_EXPORT SemanticTypes::IDVector GetAllImageIDsOfInformationType(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType);
+    MITKSEMANTICRELATIONS_EXPORT SemanticTypes::IDVector GetAllSegmentationIDsOfCase(const SemanticTypes::CaseID& caseID);
+    MITKSEMANTICRELATIONS_EXPORT SemanticTypes::IDVector GetAllSegmentationIDsOfImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID);
+    MITKSEMANTICRELATIONS_EXPORT SemanticTypes::IDVector GetAllSegmentationIDsOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion);
 
     SemanticTypes::ID GetImageIDOfSegmentation(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& segmentationID);
 
     MITKSEMANTICRELATIONS_EXPORT std::vector<SemanticTypes::CaseID> GetAllCaseIDs();
+    MITKSEMANTICRELATIONS_EXPORT bool InstanceExists(const SemanticTypes::CaseID& caseID);
 
     void AddCase(const SemanticTypes::CaseID& caseID);
     void AddImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID);
     void RemoveImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID);
     void AddSegmentation(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& segmentationID, const SemanticTypes::ID& parentID);
     void RemoveSegmentation(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& segmentationID);
 
     void AddLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion);
     void OverwriteLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion);
     void LinkSegmentationToLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& segmentationID, const SemanticTypes::Lesion& lesion);
     void UnlinkSegmentationFromLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& segmentationID);
     void RemoveLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion);
     void RemoveLesionClass(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& lesionClassID);
 
     void AddControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint);
     void LinkImageToControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID, const SemanticTypes::ControlPoint& controlPoint);
     void UnlinkImageFromControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID);
-    void RemoveControlPointFromCase(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint);
+    void RemoveControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint);
 
     void AddExaminationPeriod(const SemanticTypes::CaseID& caseID, const SemanticTypes::ExaminationPeriod& examinationPeriod);
     void AddControlPointToExaminationPeriod(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint, const SemanticTypes::ExaminationPeriod& examinationPeriod);
     void RemoveControlPointFromExaminationPeriod(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint, const SemanticTypes::ExaminationPeriod& examinationPeriod);
-    void RemoveExaminationPeriodFromCase(const SemanticTypes::CaseID& caseID, const SemanticTypes::ExaminationPeriod& examinationPeriod);
+    void RemoveExaminationPeriod(const SemanticTypes::CaseID& caseID, const SemanticTypes::ExaminationPeriod& examinationPeriod);
 
     void AddInformationTypeToImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID, const SemanticTypes::InformationType& informationType);
     void RemoveInformationTypeFromImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID);
-    void RemoveInformationTypeFromCase(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType);
+    void RemoveInformationType(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType);
 
   } // namespace RelationStorage
 } // namespace mitk
 
 #endif // MITKRELATIONSTORAGE_H
diff --git a/Modules/SemanticRelations/include/mitkSemanticRelationException.h b/Modules/SemanticRelations/include/mitkSemanticRelationException.h
index 4def6f9420..8ea55b2d3e 100644
--- a/Modules/SemanticRelations/include/mitkSemanticRelationException.h
+++ b/Modules/SemanticRelations/include/mitkSemanticRelationException.h
@@ -1,35 +1,35 @@
 /*===================================================================
 
 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 MITKSEMANTICRELATIONEXCEPTION_H
 #define MITKSEMANTICRELATIONEXCEPTION_H
 
 // mitk core
-#include <mitkException.h>
+#include <mitkExceptionMacro.h>
 
 namespace mitk
 {
   class SemanticRelationException : public Exception
   {
 
   public:
 
     mitkExceptionClassMacro(SemanticRelationException, Exception);
 
   };
 } // namespace mitk
 
 #endif // MITKSEMANTICRELATIONEXCEPTION_H
diff --git a/Modules/SemanticRelations/include/mitkSemanticRelationsInference.h b/Modules/SemanticRelations/include/mitkSemanticRelationsInference.h
index 1c21322699..fa9faeda4d 100644
--- a/Modules/SemanticRelations/include/mitkSemanticRelationsInference.h
+++ b/Modules/SemanticRelations/include/mitkSemanticRelationsInference.h
@@ -1,344 +1,292 @@
 /*===================================================================
 
 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 MITKSEMANTICRELATIONSINFERENCE_H
 #define MITKSEMANTICRELATIONSINFERENCE_H
 
 #include <MitkSemanticRelationsExports.h>
 
 // semantic relations module
 #include "mitkSemanticTypes.h"
 
 // mitk core
 #include <mitkDataNode.h>
 
 namespace mitk
 {
   /**
   * @brief  The API provides functions to query image relations and instances
   *         that are helpful during follow-up examination, like control-points (time period),
   *         types of the images or lesions that may be visible on multiple images.
   *
   *   The class is able to generate IDs from given data nodes using DICOM information.
   *   These IDs are used to identify the corresponding instances of a specific case.
   *   The case can also be directly identified by the given case ID.
   *
   *   In order for most functions to work the case ID has to be used as a parameter.
   *   If not, these functions do nothing.
   */
   namespace SemanticRelationsInference
   {
 
     /************************************************************************/
     /* functions to get instances / attributes                              */
     /************************************************************************/
     /**
     * @brief Return a vector of lesion classes that are currently available for the given case.
     *
     * @param caseID   The current case identifier is defined by the given string.
     * @return         A vector of lesion classes.
     */
     MITKSEMANTICRELATIONS_EXPORT SemanticTypes::LesionClassVector GetAllLesionClassesOfCase(const SemanticTypes::CaseID& caseID);
     /**
     * @brief  Return the lesion that is defined by the given segmentation.
     *
     * @pre    The given segmentation data node has to be valid (!nullptr).
     * @throw  SemanticRelationException, if the given segmentation is invalid (==nullptr).
     * @pre    The segmentation data node has to represent a lesion. If not, the retrieved lesion will be empty, which leads to an exception.
     * @throw  SemanticRelationException, if the segmentation does not represent an existing lesion (this can be checked via 'IsRepresentingALesion').
     *
     * @param segmentationNode   The segmentation identifier is extracted from the given data node.
     * @return                   The represented lesion.
     */
     MITKSEMANTICRELATIONS_EXPORT SemanticTypes::Lesion GetLesionOfSegmentation(const DataNode* segmentationNode);
     /**
     * @brief  Returns a vector of all lesions that are currently available for the current case and are connected to the given image (via a segmentation).
     *         If no lesions are stored for the current case, an empty vector is returned. If no segmentations are
     *         connected with the image node, no lesions for the specific image will be found and an empty vector is returned.
     *
     * @pre    The given image data node has to be valid (!nullptr).
     * @throw  SemanticRelationException, if the given image data node is invalid (==nullptr).
     *
     * @param imageNode    The current case identifier is extracted from the given data node, which contains DICOM information about the case.
     * @return             A vector of lesions.
     */
     MITKSEMANTICRELATIONS_EXPORT SemanticTypes::LesionVector GetAllLesionsOfImage(const DataNode* imageNode);
     /**
     * @brief  Returns a vector of all lesions that are valid for the given case, given a specific control point.
     *
     * @param caseID         The current case identifier is defined by the given string.
     * @param controlPoint   A specific control point which has to be available at a returned (found) lesion:
     *                       Only those lesions are returned for which the image of the associated segmentation is linked to the given control point.
     *                       If the control point instance does not exist, an empty vector is returned.
     * @return               A vector of control points.
     */
     MITKSEMANTICRELATIONS_EXPORT SemanticTypes::LesionVector GetAllLesionsOfControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint);
     /**
     * @brief  Check if the given segmentation refers to an existing lesion instance.
     *         This function can be used before calling 'GetRepresentedLesion' in order to avoid a possible exception.
     *
     * @param segmentationNode   The segmentation identifier is extracted from the given data node.
     * @return                   True, if the segmentation refers to an existing lesion; false otherwise.
     */
     MITKSEMANTICRELATIONS_EXPORT bool IsRepresentingALesion(const DataNode* segmentationNode);
     /**
     * @brief  Check if the segmentation identified by the given segmentation ID refers to an existing lesion instance.
     *         This function can be used before calling 'GetRepresentedLesion' in order to avoid a possible exception.
     *
     * @param caseID             The current case identifier is defined by the given string.
     * @param segmentationID     The segmentation node identifier is defined by the given string.
     * @return                   True, if the segmentation refers to an existing lesion; false otherwise.
     */
     MITKSEMANTICRELATIONS_EXPORT bool IsRepresentingALesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& segmentationID);
     /**
     * @brief Check if the given lesion is present on the given data node.
     *        The function receives the case- and the node-ID from the DICOM tags of the node itself.
     *        It uses node predicates to decide if the node is an image or a segmentation node.
     *
     * @param lesion      A lesion with a UID that identifies the corresponding lesion instance.
     * @param dataNode    A data node to check.
     * @return            True, if the lesion is present on the data node; false otherwise.
     */
     MITKSEMANTICRELATIONS_EXPORT bool IsLesionPresent(const SemanticTypes::Lesion& lesion, const DataNode* dataNode);
     /**
     * @brief Check if the given lesion is related to the image identified by the given image ID.
     *        Each lesion is represented by a segmentation which is connected to its parent image.
     *
     * @param caseID       The current case identifier is defined by the given string.
     * @param lesion       A lesion with a UID that identifies the corresponding lesion instance.
     * @param imageID      The image node identifier is defined by the given string.
     * @return              True, if the lesion is related to image identified by the given image ID; false otherwise.
     */
     MITKSEMANTICRELATIONS_EXPORT bool IsLesionPresentOnImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion, const SemanticTypes::ID& imageID);
     /**
     * @brief Check if the given lesion is present on the segmentation identified by the given segmentation ID.
     *
     * @param caseID             The current case identifier is defined by the given string.
     * @param lesion             A lesion with a UID that identifies the corresponding lesion instance.
     * @param segmentationID     The segmentation node identifier is defined by the given string.
     * @return                   True, if the lesion is present on the segmentation identified by the given segmentation ID; false otherwise.
     */
     MITKSEMANTICRELATIONS_EXPORT bool IsLesionPresentOnSegmentation(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion, const SemanticTypes::ID& segmentationID);
     /**
     * @brief Check if the given lesion is present at the given control point.
     *
     * @param caseID             The current case identifier is defined by the given string.
     * @param lesion             A lesion with a UID that identifies the corresponding lesion instance.
     * @param controlPoint       A control point with a UID that identifies the corresponding control point instance.
     * @return                   True, if the lesion is present at the given control point; false otherwise.
     */
     MITKSEMANTICRELATIONS_EXPORT bool IsLesionPresentAtControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion, const SemanticTypes::ControlPoint& controlPoint);
     /**
     * @brief Check if the given data node exists in the relation storage.
     *        The function receives the case- and the node-ID from the DICOM tags of the node itself.
     *        It uses node predicates to decide if the node is an image or a segmentation node and searches
     *        through the corresponding relations.
     *
     * @param dataNode    A data node to check.
     * @return            True, if the data node exists; false otherwise.
     */
     MITKSEMANTICRELATIONS_EXPORT bool InstanceExists(const DataNode* dataNode);
     /**
     * @brief  Check if the given lesion instance exists.
-    *         This function can be used before calling 'GetAllSegmentationsOfLesion' in order to avoid a possible exception.
     *         This function can be used before calling 'AddLesionInstance' in order to avoid a possible exception.
     *
     * @param caseID   The current case identifier is defined by the given string.
     * @param lesion   A lesion with a UID that identifies the corresponding lesion instance.
     * @return         True, if the lesion instance exists; false otherwise.
     */
     MITKSEMANTICRELATIONS_EXPORT bool InstanceExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion);
     /**
     * @brief  Return a vector of all image IDs that identify images that are related to the given lesion.
     *         Each lesion is represented by a segmentation which is connected to its parent image.
     *         If the lesion is not represented by any segmentation, an empty vector is returned.
     *
     * @pre    The UID of the lesion has to exist for a lesion instance.
     * @throw  SemanticRelationException, if UID of the lesion does not exist for a lesion instance (this can be checked via 'InstanceExists').
     *
     * @param caseID   The current case identifier is defined by the given string.
     * @param lesion   A lesion with a UID that identifies the corresponding lesion instance.
     * @return         A vector of IDs identifying images that identify images that are related to the given lesion.
     */
     MITKSEMANTICRELATIONS_EXPORT SemanticTypes::IDVector GetAllImageIDsOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion);
     /**
-    * @brief  Return a vector of all segmentation IDs that identify segmentations that define the given lesion.
-    *         These segmentations don't have to be linked to the same image.
-    *         If the lesion is not referred to by any segmentation, an empty vector is returned.
-    *
-    * @pre    The UID of the lesion has to exist for a lesion instance.
-    * @throw  SemanticRelationException, if UID of the lesion does not exist for a lesion instance (this can be checked via 'InstanceExists').
-    *
-    * @param caseID   The current case identifier is defined by the given string.
-    * @param lesion   A lesion with a UID that identifies the corresponding lesion instance.
-    * @return         A vector of IDs identifying segmentations that define the given lesion.
-    */
-    MITKSEMANTICRELATIONS_EXPORT SemanticTypes::IDVector GetAllSegmentationIDsOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion);
-    /**
     * @brief  Return the control point of a data node.
     *         If the data node is not linked to a control point or the data node refers to a non-existing control point,
     *         a control point with an empty UID is returned.
     *
     * @pre    The given image data node has to be valid (!nullptr).
     * @throw  SemanticRelationException, if the given image data node is invalid (==nullptr).
     *
     * @param dataNode   The current case identifier is extracted from the given data node, which contains DICOM information about the case.
     * @return           The control point of the given data node.
     */
     MITKSEMANTICRELATIONS_EXPORT SemanticTypes::ControlPoint GetControlPointOfImage(const DataNode* dataNode);
     /**
     * @brief Return a vector of all control points that are valid for the given case, given a specific lesion
     *
     * @param caseID           The current case identifier is defined by the given string.
     * @param lesion           A specific lesion which has to be available at a returned (found) control point:
     *                         Only those control points are returned for which an associated data has a segmentation that references the given lesion.
     *                         If the lesion does not exists, an empty vector is returned.
     * @return                 A vector of control points.
     */
     MITKSEMANTICRELATIONS_EXPORT SemanticTypes::ControlPointVector GetAllControlPointsOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion);
     /**
     * @brief Return a vector of all control points that are valid for the given case, given a specific information type.
     *
     * @param caseID           The current case identifier is defined by the given string.
     * @param informationType  A specific information type which has to be available at a returned (found) control point:
     *                         Only those control points are returned for which an associated data has the given information type.
     *                         If the information type instance does not exists, an empty vector is returned.
     * @return                 A vector of control points.
     */
     MITKSEMANTICRELATIONS_EXPORT SemanticTypes::ControlPointVector GetAllControlPointsOfInformationType(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType);
     /**
     * @brief  Check if the given control point instance exists.
-    *         This function can be used before calling 'GetAllDataOfControlPoint' in order to avoid a possible exception.
     *         This function can be used before adding, linking and unlinking control points to avoid a possible exception.
     *
     * @param caseID         The current case identifier is defined by the given string.
     * @param controlPoint   A control point with a UID that identifies the corresponding control point instance.
     * @return               True, if the control point instance exists; false otherwise.
     */
     MITKSEMANTICRELATIONS_EXPORT bool InstanceExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint);
     /**
-    * @brief  Return a vector of all examination periods nodes that are valid for the given case.
-    *
-    * @param caseID         The current case identifier is defined by the given string.
-    * @return               A vector of examination periods.
-    */
-    MITKSEMANTICRELATIONS_EXPORT SemanticTypes::ExaminationPeriodVector GetAllExaminationPeriodsOfCase(const SemanticTypes::CaseID& caseID);
-    /**
     * @brief  Check if the given examination period instance exists.
     *         This function can be used before calling 'AddExaminationPeriod' in order to avoid a possible exception.
     *
     * @param caseID               The current case identifier is defined by the given string.
     * @param examinationPeriod    An examination period with a UID that identifies the corresponding examination period instance.
     * @return                     True, if the examination period instance exists; false otherwise.
     */
     MITKSEMANTICRELATIONS_EXPORT bool InstanceExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::ExaminationPeriod& examinationPeriod);
     /**
     * @brief  Return the information type of the given image.
     *         If the image does not contain any information type, an empty information type is returned.
     *
     * @pre    The given image data node has to be valid (!nullptr).
     * @throw  SemanticRelationException, if the given image data node is invalid (==nullptr).
     *
     * @param imageNode    The current case identifier is extracted from the given data node, which contains DICOM information about the case.
     * @return             The information type of the given data node.
     */
     MITKSEMANTICRELATIONS_EXPORT SemanticTypes::InformationType GetInformationTypeOfImage(const DataNode* imageNode);
     /**
-    * @brief  Return the information type of the given image.
-    *         If the image does not contain any information type, an empty information type is returned.
-    *
-    * @param caseID     The current case identifier is defined by the given string.
-    * @param imageID    The image node identifier is defined by the given string.
-    * @return           The information type of the image node, defined by the image node ID.
-    */
-    MITKSEMANTICRELATIONS_EXPORT SemanticTypes::InformationType GetInformationTypeOfImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID);
-    /**
     * @brief  Return a vector of all information types that are valid for the given case, given a specific control point.
     *
     * @param caseID         The current case identifier is defined by the given string.
     * @param controlPoint   A specific control point which has to be available at a returned (found) information type:
     *                       Only those information types are returned for which an associated data is linked to the given control point.
     *                       If the control point instance does not exist, an empty vector is returned.
     * @return               A vector of information types.
     */
     MITKSEMANTICRELATIONS_EXPORT SemanticTypes::InformationTypeVector GetAllInformationTypesOfControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint);
     /**
-    * @brief  Return a vector of all image IDs that identify images that are of the given information type.
-    *         If the information type is not used by any image, an empty vector is returned.
-    *
-    * @pre    The information type has to exist.
-    * @throw  SemanticRelationException, if the information type does not exist (this can be checked via 'InstanceExists').
-    *
-    * @param caseID             The current case identifier is defined by the given string.
-    * @param informationType    An information type.
-    * @return                   A vector of IDs identifying images that are of the given information type.
-    */
-    MITKSEMANTICRELATIONS_EXPORT SemanticTypes::IDVector GetAllImageIDsOfInformationType(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType);
-    /**
     * @brief  Check if the given information type exists.
-    *         This function can be used before calling 'GetAllDataOfInformationType' in order to avoid a possible exception.
     *
     * @param caseID             The current case identifier is defined by the given string.
     * @param informationType    An information type.
     * @return                   True, if the information type exists; false otherwise.
     */
     MITKSEMANTICRELATIONS_EXPORT bool InstanceExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType);
     /**
     * @brief  Determine if the given information type contains images, which are connected to segmentations that represent the given lesion.
     *         If the lesion or the information type are not correctly stored, the function returns false.
     *
     * @param caseID           The current case identifier is defined by the given string.
     * @param lesion           A Lesion with a UID that identifies the corresponding lesion instance.
     * @param informationType  An information type that identifies the corresponding information type instance.
     *
     * @return                 True, if the given information type contains data that is related to the given lesion; false otherwise.
     */
     MITKSEMANTICRELATIONS_EXPORT bool SpecificImageExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion, const SemanticTypes::InformationType& informationType);
     /**
     * @brief  Determine if the given control point contains images, which are connected to segmentations that represent the given lesion.
     *         If the lesion or the control point are not correctly stored, the function returns false.
     *
     * @param caseID         The current case identifier is defined by the given string.
     * @param lesion         A Lesion with a UID that identifies the corresponding lesion instance.
     * @param controlPoint   A control point with a UID that identifies the corresponding control point instance.
     *
     * @return               True, if the given control point contains data that is related to the given lesion; false otherwise.
     */
     MITKSEMANTICRELATIONS_EXPORT bool SpecificImageExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion, const SemanticTypes::ControlPoint& controlPoint);
     /**
     * @brief  Determine if the given control point contains images, which refer to the given information type.
     *         If the information type or the control point are not correctly stored, the function returns false.
     *
     * @param caseID           The current case identifier is defined by the given string.
     * @param informationType  An information type that identifies the corresponding information type instance.
     * @param controlPoint     A control point with a UID that identifies the corresponding control point instance.
     *
     * @return                 True, if the given control point contains data that is related to the given information type; false otherwise.
     */
     MITKSEMANTICRELATIONS_EXPORT bool SpecificImageExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType, const SemanticTypes::ControlPoint& controlPoint);
-    /**
-    * @brief Remove all control points from the storage that are not referenced by any image anymore.
-    *        This might happen if an image has been removed (and unlinked from the corresponding control point)
-    *        or if the user sets a new control point for an image manually in the GUI.
-    *
-    * @param caseID   The current case identifier is defined by the given string.
-    */
-    MITKSEMANTICRELATIONS_EXPORT void ClearControlPoints(const SemanticTypes::CaseID& caseID);
 
   } // namespace SemanticRelationsInference
 } // namespace mitk
 
 #endif // MITKSEMANTICRELATIONSINFERENCE_H
diff --git a/Modules/SemanticRelations/include/mitkSemanticRelationsIntegration.h b/Modules/SemanticRelations/include/mitkSemanticRelationsIntegration.h
index ae65f4309c..2babb30592 100644
--- a/Modules/SemanticRelations/include/mitkSemanticRelationsIntegration.h
+++ b/Modules/SemanticRelations/include/mitkSemanticRelationsIntegration.h
@@ -1,311 +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.
 
 ===================================================================*/
 
 #ifndef MITKSEMANTICRELATIONSINTEGRATION_H
 #define MITKSEMANTICRELATIONSINTEGRATION_H
 
 #include <MitkSemanticRelationsExports.h>
 
 // semantic relations module
 #include "mitkISemanticRelationsObservable.h"
 #include "mitkISemanticRelationsObserver.h"
 #include "mitkSemanticTypes.h"
 
 // mitk core
 #include <mitkDataNode.h>
 
 namespace mitk
 {
   /**
   * @brief  The API provides functions to manipulate image relations and instances
   *         that are helpful during follow-up examination, like control-points (time period),
   *         types of the images or lesions that may be visible on multiple images.
   *
   *   The class is able to generate IDs from given data nodes using DICOM information.
   *   These IDs are used to identify the corresponding instances of a specific case.
   *   The case can also be directly identified by the given case ID.
   *
   *   In order for most functions to work the case ID has to be used as a parameter.
   *   If not, these functions do nothing.
   *
   *   The class implements the ISemanticRelationsObservable interface to allow observers to 
   *   be informed about changes in the semantic relation storage.
   */
   class MITKSEMANTICRELATIONS_EXPORT SemanticRelationsIntegration : public ISemanticRelationsObservable
   {
   public:
 
     /************************************************************************/
     /* functions to implement the observer pattern                          */
     /************************************************************************/
     /**
     * @brief Adds the given concrete observer to the vector that holds all currently registered observer.
     *        If the observer is already registered, it will not be added to the observer vector.
     *
     * @param observer   The concrete observer to register.
     */
     virtual void AddObserver(ISemanticRelationsObserver* observer) override;
     /**
     * @brief Removes the given concrete observer from the vector that holds all currently registered observer.
     *
     * @param observer   The concrete observer to unregister.
     */
     virtual void RemoveObserver(ISemanticRelationsObserver* observer) override;
   
     /************************************************************************/
     /* functions to add / remove instances / attributes                     */
     /************************************************************************/
     /**
     * @brief  Add the given image to the set of already existing images.
     *         The date is extracted from the DICOM data of the image node and is compared to already existing control points in the semantic relations model.
     *         The function tries to find a fitting control point or to extend an already existing control point, if the extracted control point is close to
     *         any other, already existing control point.
     *         Finally, the image is linked to the correct control point.
     *
     * @pre    The given image data node has to be valid (!nullptr).
     * @throw  SemanticRelationException, if the given image data node is invalid (==nullptr).
     *
     * @param imageNode   The current case identifier and node identifier is extracted from the given image data node, which contains DICOM information about the case and the node.
     */
     void AddImage(const DataNode* imageNode);
     /**
     * @brief  Remove the given image from the set of already existing images.
     *
     * @pre    The given image data node has to be valid (!nullptr).
     * @throw  SemanticRelationException, if the given image data node is invalid (==nullptr).
     *
     * @param imageNode   The current case identifier and node identifier is extracted from the given image data node, which contains DICOM information about the case and the node.
     */
     void RemoveImage(const DataNode* imageNode);
     /**
     * @brief  Add a newly created lesion to the set of already existing lesions - with no connection to a specific image / segmentation of the case data.
     *
     * @pre    The UID of the lesion must not already exist for a lesion instance.
     * @throw  SemanticRelationException, it the UID of the lesion already exists for a lesion instance (this can be checked via 'InstanceExists').
     *
     * @param caseID   The current case identifier is defined by the given string.
     * @param lesion   The lesion instance to add.
     */
     void AddLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion);
     /**
     * @brief  Overwrite an already existing lesion instance (this may be useful to overwrite the lesion with a different lesion class).
     *
     * @pre    The UID of the lesion has to exist for a lesion instance.
     * @throw  SemanticRelationException, if the UID of the lesion does not exist for a lesion instance (this can be checked via 'InstanceExists').
     *
     * @param caseID   The current case identifier is defined by the given string.
     * @param lesion   The lesion instance that overwrites an existing lesion.
     */
     void OverwriteLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion);
     /**
     * @brief  Add a newly created lesion to the set of already existing lesions. The lesion is added and a reference to
-    *         the lesion is added to the segmentation data. If the segmentation is already linked to a lesion, the
+    *         the lesion is added to the segmentation. If the segmentation is already linked to a lesion, the
     *         old linkage is overwritten (this can be checked via 'IsRepresentingALesion').
     *
     * @pre    The given segmentation data node has to be valid (!nullptr).
     * @throw  SemanticRelationException, if the given segmentation data node is invalid (==nullptr).
     * @pre    The UID of the lesion must not already exist for a lesion instance.
     * @throw  SemanticRelationException, if the UID of the lesion already exists for a lesion instance (this can be checked via 'InstanceExists').
     *
-    * @param segmentationNode   The segmentation identifier is extracted from the given data node. The segmentation node has DICOM information from its parent node.
+    * @param segmentationNode   The segmentation identifier is extracted from the given segmentation data node. The segmentation node has DICOM information from its parent node.
     * @param lesion             The lesion instance to add and link.
     */
     void AddLesionAndLinkSegmentation(const DataNode* segmentationNode, const SemanticTypes::Lesion& lesion);
     /**
     * @brief  Remove the given lesion from the set of already existing lesions.
     *
     * @pre    The UID of the lesion has to exist for a lesion instance.
     * @throw  SemanticRelationException, if the UID of the lesion does not exist for a lesion instance (this can be checked via 'InstanceExists').
     * @pre    The function needs to assure that no segmentation is still representing (linked to) this lesion.
     * @throw  SemanticRelationException, if the lesion instance to remove is still linked to by any segmentation (this can be checked via 'GetAllSegmentationsOfLesion').
     *
     * @param caseID   The current case identifier is defined by the given string.
     * @param lesion   The lesion instance to remove.
     */
     void RemoveLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion);
     /**
     * @brief  Add a segmentation instance to the set of already existing segmentations - with no connection to a specific lesion.
     *
-    * @param segmentationNode   The segmentation identifier is extracted from the given data node. The segmentation node has DICOM information from its parent node.
+    * @param segmentationNode   The segmentation identifier is extracted from the given segmentation data node. The segmentation node has DICOM information from its parent node.
     * @param parentNode         The node identifier of the parent node is extracted from the given parent data node.
     */
     void AddSegmentation(const DataNode* segmentationNode, const DataNode* parentNode);
     /**
     * @brief  Link the given segmentation instance to an an already existing lesion instance. If the segmentation is already linked to a lesion instance, the
     *         old linkage is overwritten (this can be checked via 'IsRepresentingALesion').
     *
     * @pre    The given segmentation data node has to be valid (!nullptr).
     * @throw  SemanticRelationException, if the given segmentation data node is invalid (==nullptr).
     * @pre    The UID of the lesion has to exist for a lesion instance.
     * @throw  SemanticRelationException, if the UID of the lesion does not exist for a lesion instance (this can be checked via 'InstanceExists').
     *
-    * @param segmentationNode   The segmentation identifier is extracted from the given data node. The segmentation node has DICOM information from its parent node.
+    * @param segmentationNode   The segmentation identifier is extracted from the given segmentation data node. The segmentation node has DICOM information from its parent node.
     * @param lesion             The lesion instance to link.
     */
     void LinkSegmentationToLesion(const DataNode* segmentationNode, const SemanticTypes::Lesion& lesion);
     /**
     * @brief  Unlink the given segmentation instance from the linked lesion instance.
     *         The lesion may stay unlinked to any segmentation.
     *
     * @pre    The given segmentation data node has to be valid (!nullptr).
     * @throw  SemanticRelationException, if the given segmentation data node is invalid (==nullptr).
     *
-    * @param segmentationNode   The segmentation identifier is extracted from the given data node. The segmentation node has DICOM information from its parent node.
+    * @param segmentationNode   The segmentation identifier is extracted from the given segmentation data node. The segmentation node has DICOM information from its parent node.
     */
     void UnlinkSegmentationFromLesion(const DataNode* segmentationNode);
     /**
     * @brief  Remove the given segmentation from the set of already existing segmentations.
     *
     * @pre    The given segmentation data node has to be valid (!nullptr).
     * @throw  SemanticRelationException, if the given segmentation data node is invalid (==nullptr).
     *
-    * @param segmentationNode   The segmentation identifier is extracted from the given data node. The segmentation node has DICOM information from its parent node.
+    * @param segmentationNode   The segmentation identifier is extracted from the given segmentation data node. The segmentation node has DICOM information from its parent node.
     */
     void RemoveSegmentation(const DataNode* segmentationNode);
     /**
-    * @brief Set the control point for the given data node.
+    * @brief Set the control point for the given image.
     *
-    * @pre    The given data node has to be valid (!nullptr).
-    * @throw  SemanticRelationException, if the given data node is invalid (==nullptr).
+    * @pre    The given image data node has to be valid (!nullptr).
+    * @throw  SemanticRelationException, if the given image data node is invalid (==nullptr).
+    *
+    * @param imageNode      The current case identifier and node identifier is extracted from the given image data node, which contains DICOM information about the case and the node.
+    * @param controlPoint   The control point instance which is used for the given image.
     */
-    void SetControlPointOfData(const DataNode* dataNode, const SemanticTypes::ControlPoint& controlPoint);
+    void SetControlPointOfImage(const DataNode* imageNode, const SemanticTypes::ControlPoint& controlPoint);
     /**
-    * @brief  Add a newly created control point to the set of already existing control points. A reference to the control point is added to the given data.
+    * @brief  Add a newly created control point to the set of already existing control points. A reference to the control point is added to the given image.
     *         This function combines adding a control point and linking it, since a control point with no associated data is not allowed.
     *
-    * @pre    The given data node has to be valid (!nullptr).
-    * @throw  SemanticRelationException, if the given data node is invalid (==nullptr).
+    * @pre    The given image data node has to be valid (!nullptr).
+    * @throw  SemanticRelationException, if the given image data node is invalid (==nullptr).
     * @pre    The UID of the control point must not already exist for a control point instance.
     * @throw  SemanticRelationException, if the UID of the control point already exists for a control point instance (this can be checked via 'InstanceExists').
     * @pre    The given control point must not already be contained in an existing control point interval.
     * @throw  SemanticRelationException, if the given control point is already contained in an existing control point interval (this can be checked via 'CheckContainingControlPoint').
-    * @pre    The given control point must contain the date of the given data node (if parameter 'checkConsistence = true').
-    * @throw  SemanticRelationException, if the given control point does not contain the date of the given data node and 'checkConsistence = true' (this can be checked via 'ControlPointManager::InsideControlPoint').
+    * @pre    The given control point must contain the date of the given image data node (if parameter 'checkConsistence = true').
+    * @throw  SemanticRelationException, if the given control point does not contain the date of the given image data node and 'checkConsistence = true' (this can be checked via 'ControlPointManager::InsideControlPoint').
     *
-    * @param dataNode         The current case identifier is extracted from the given data node, which contains DICOM information about the case.
+    * @param imageNode        The current case identifier and node identifier is extracted from the given image data node, which contains DICOM information about the case and the node.
     * @param controlPoint     The control point instance to add. For a newly added control point always has "startDate = endDate".
-    * @param checkConsistence If true, the function checks, whether the date of the data node actually lies inside the control point to link.
+    * @param checkConsistence If true, the function checks, whether the date of the image data node actually lies inside the control point to link.
     */
-    void AddControlPointAndLinkData(const DataNode* dataNode, const SemanticTypes::ControlPoint& controlPoint, bool checkConsistence = true);
+    void AddControlPointAndLinkImage(const DataNode* imageNode, const SemanticTypes::ControlPoint& controlPoint, bool checkConsistence = true);
     /**
-    * @brief  Link the given data to an already existing control point.
+    * @brief  Link the given image to an already existing control point.
     *
-    * @pre    The given data node has to be valid (!nullptr).
-    * @throw  SemanticRelationException, if the given data node is invalid (==nullptr).
+    * @pre    The given image data node has to be valid (!nullptr).
+    * @throw  SemanticRelationException, if the given image data node is invalid (==nullptr).
     * @pre    The UID of the control point has to exist for a control point instance.
     * @throw  SemanticRelationException, if the UID of the control point does not exists for a control point instance (this can be checked via 'InstanceExists').
-    * @pre    The given control point must contain the date of the given data node (if parameter 'checkConsistence = true').
-    * @throw  SemanticRelationException, if the given control point does not contain the date of the given data node and 'checkConsistence = true' (this can be checked via 'ControlPointManager::InsideControlPoint').
+    * @pre    The given control point must contain the date of the given image data node (if parameter 'checkConsistence = true').
+    * @throw  SemanticRelationException, if the given control point does not contain the date of the given image data node and 'checkConsistence = true' (this can be checked via 'ControlPointManager::InsideControlPoint').
     *
-    * @param dataNode         The current case identifier is extracted from the given data node, which contains DICOM information about the case.
+    * @param imageNode        The current case identifier and node identifier is extracted from the given image data node, which contains DICOM information about the case and the node.
     * @param controlPoint     The control point instance to link.
-    * @param checkConsistence If true, the function checks, whether the date of the data node actually lies inside the control point to link.
+    * @param checkConsistence If true, the function checks, whether the date of the image data node actually lies inside the control point to link.
     */
-    void LinkDataToControlPoint(const DataNode* dataNode, const SemanticTypes::ControlPoint& controlPoint, bool checkConsistence = true);
+    void LinkImageToControlPoint(const DataNode* imageNode, const SemanticTypes::ControlPoint& controlPoint, bool checkConsistence = true);
     /**
     * @brief  Unlink the given image from the linked control point.
-    *         If data is unlinked from a control point, the function needs to check whether the control point is still linked to any other data:
-    *           - if not, the control point instance will be removed (has to be removed since a control point with no associated data is not allowed).
+    *         If an image is unlinked from a control point, the function needs to check whether the control point is still linked to any other image:
+    *           - if not, the control point instance will be removed (has to be removed since a control point with no associated image is not allowed).
     *           - if so, the function has to make sure that the control point instance is shortened to its minimum time period (e.g. moving the end point to an earlier date).
     *
-    * @param dataNode       The current case identifier is extracted from the given data node, which contains DICOM information about the case.
+    * @param imageNode        The current case identifier and node identifier is extracted from the given image data node, which contains DICOM information about the case and the node.
     */
-    void UnlinkImageFromControlPoint(const DataNode* dataNode);
+    void UnlinkImageFromControlPoint(const DataNode* imageNode);
     /**
     * @brief  Add an examination period instance to the set of already existing examination periods - with no connection to a specific control point.
     *
     * @pre    The UID of the examination period must not already exist for an examination period instance.
     * @throw  SemanticRelationException, if the UID of the examination period already exists for a examination period instance (this can be checked via 'InstanceExists').
     *
     * @param caseID               The current case identifier is defined by the given string.
     * @param examinationPeriod    The examination period to add.
     */
     void AddExaminationPeriod(const SemanticTypes::CaseID& caseID, const SemanticTypes::ExaminationPeriod& examinationPeriod);
     /**
     * @brief Add a control point to the vector of control point UIDs of an existing examination period.
     *
     * @pre    The UID of the control point has to exist for a control point instance.
     * @throw  SemanticRelationException, if the UID of the control point does not exists for a control point instance (this can be checked via 'InstanceExists').
     * @pre    The UID of the examination period must not already exist for an examination period instance.
     * @throw  SemanticRelationException, if the UID of the examination period already exists for a examination period instance (this can be checked via 'InstanceExists').
     *
     * @param caseID               The current case identifier is defined by the given string.
     * @param controlPoint         The control point instance to add to the examination period.
     * @param examinationPeriod    The examination period to which the control point should be added.
     */
     void AddControlPointToExaminationPeriod(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint, const SemanticTypes::ExaminationPeriod& examinationPeriod);
     /**
     * @brief Set (and possibly overwrite) the information type of the given image.
     *        An already associated information type might be removed if is not referenced by any other image:
     *
     * @pre    The given image data node has to be valid (!nullptr).
     * @throw  SemanticRelationException, if the given image data node is invalid (==nullptr).
     * @post   If the information type instance did not exist before, it is now added.
     *
-    * @param imageNode        The current case identifier is extracted from the given data node, which contains DICOM information about the case.
+    * @param imageNode        The current case identifier is extracted from the given image data node, which contains DICOM information about the case.
     * @param informationType  An information type that identifies the corresponding information type instance.
     */
     void SetInformationType(const DataNode* imageNode, const SemanticTypes::InformationType& informationType);
     /**
     * @brief  Set the information type of the given image.
     *
     * @pre    The given image data node has to be valid (!nullptr).
     * @throw  SemanticRelationException, if the given image data node is invalid (==nullptr).
     * @post   If the information type instance did not exist before, it is now added.
     *
-    * @param imageNode        The current case identifier is extracted from the given data node, which contains DICOM information about the case.
+    * @param imageNode        The current case identifier is extracted from the given image data node, which contains DICOM information about the case.
     * @param informationType  An information type that identifies the corresponding information type instance.
     */
     void AddInformationTypeToImage(const DataNode* imageNode, const SemanticTypes::InformationType& informationType);
     /**
     * @brief  Remove the information type of the given image.
     *         If the information type is removed, the function needs to check whether the information type is referenced by any other image:
     *           - if not, the information type instance can be removed (has to be removed since an information type with no associated image is not allowed).
     *           - if so, the information type is just removed from the given image.
     *
     * @pre    The given image data node has to be valid (!nullptr).
     * @throw  SemanticRelationException, if the given image data node is invalid (==nullptr).
     *
-    * @param imageNode        The current case identifier is extracted from the given data node, which contains DICOM information about the case.
+    * @param imageNode        The current case identifier is extracted from the given image data node, which contains DICOM information about the case.
     */
     void RemoveInformationTypeFromImage(const DataNode* imageNode);
 
   private:
     /**
     * @brief A vector that stores the currently registered observer of this observable subject.
     */
     static std::vector<mitk::ISemanticRelationsObserver*> m_ObserverVector;
     /**
     * @brief The class notifies (updates) the observer with a given case ID.
     *        The view's caseID was set before in the GUI. The parts of the view that observe changes in the semantic relations are only updated,
     *        if the given case ID is equal to the observer's current caseID and thus the observer currently shows the semantic information of the given case.
     *
     * @param  caseID    The caseID that identifies the currently active patient / case.
     */
     virtual void NotifyObserver(const mitk::SemanticTypes::CaseID& caseID) const override;
     /**
     * @brief Remove all control points from the storage that are not referenced by any image anymore.
     *        This might happen if an image has been removed (and unlinked from the corresponding control point)
     *        or if the user sets a new control point for an image manually in the GUI.
     *
     * @param caseID   The current case identifier is defined by the given string.
     */
     void ClearControlPoints(const SemanticTypes::CaseID& caseID);
 
   };
 } // namespace mitk
 
 #endif // MITKSEMANTICRELATIONSINTEGRATION_H
diff --git a/Modules/SemanticRelations/include/mitkSemanticTypes.h b/Modules/SemanticRelations/include/mitkSemanticTypes.h
index 2f12a09fff..2731adb52e 100644
--- a/Modules/SemanticRelations/include/mitkSemanticTypes.h
+++ b/Modules/SemanticRelations/include/mitkSemanticTypes.h
@@ -1,129 +1,129 @@
 /*===================================================================
 
 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 MITKSEMANTICTYPES_H
 #define MITKSEMANTICTYPES_H
 
 #define BOOST_DATE_TIME_NO_LIB
 #if defined(BOOST_ALL_DYN_LINK)
 #undef BOOST_ALL_DYN_LINK
 #endif
 
 // boost
 #include <boost/date_time/gregorian/gregorian.hpp>
 
 // c++
 #include <set>
 #include <tuple>
 #include <vector>
 
 namespace mitk
 {
   namespace SemanticTypes
   {
     using ID = std::string;
-    using CaseID = std::string; // an ID of the current case (e.g. the DICOM PatientID)
+    using CaseID = std::string;
     using InformationType = std::string;
 
     /*
     * @brief The concept of a control point.
     */
     struct ControlPoint
     {
       ID UID;
       boost::gregorian::date date;
 
       ControlPoint()
       {
         date = boost::gregorian::date(boost::gregorian::min_date_time);
       }
 
       // less comparison to sort containers of control points
       bool operator<(const ControlPoint& other) const
       {
         return date < other.date;
       }
 
       std::string ToString() const
       {
         std::stringstream controlPointAsString;
         if (date.is_not_a_date())
         {
           return "";
         }
 
         controlPointAsString << std::to_string(date.year()) << "-"
           << std::setfill('0') << std::setw(2) << std::to_string(date.month()) << "-"
           << std::setfill('0') << std::setw(2) << std::to_string(date.day());
 
         return controlPointAsString.str();
       }
 
       void SetDateFromString(const std::string& dateAsString)
       {
         date = boost::gregorian::from_undelimited_string(dateAsString);
       }
 
       int DistanceInDays(const ControlPoint& other) const
       {
         boost::gregorian::date_duration duration = date - other.date;
         return std::abs(duration.days());
       }
     };
 
     /**
     * @brief The concept of an examination period.
     *     An examination period holds a vector of control point UIDs.
     *     The semantic relation storage stores the UIDs such that
     *     the represented control points are in chronological order.
     */
     struct ExaminationPeriod
     {
       ID UID;
       std::string name = "";
       std::vector<ID> controlPointUIDs;
     };
 
     /*
     * @brief The concept of a lesion class.
     */
     struct LesionClass
     {
       ID UID;
       std::string classType = "";
     };
 
     /*
     * @brief The concept of a lesion.
     */
     struct Lesion
     {
       ID UID;
       std::string name = "";
       LesionClass lesionClass;
     };
 
     using IDVector = std::vector<ID>;
     using LesionVector = std::vector<Lesion>;
     using LesionClassVector = std::vector<LesionClass>;
     using ControlPointVector = std::vector<ControlPoint>;
     using ExaminationPeriodVector = std::vector<ExaminationPeriod>;
     using InformationTypeVector = std::vector<InformationType>;
 
   } // namespace SemanticTypes
 } // namespace mitk
 
 #endif // MITKSEMANTICTYPES_H
diff --git a/Modules/SemanticRelations/src/mitkControlPointManager.cpp b/Modules/SemanticRelations/src/mitkControlPointManager.cpp
index e08a3fe44a..98f1486379 100644
--- a/Modules/SemanticRelations/src/mitkControlPointManager.cpp
+++ b/Modules/SemanticRelations/src/mitkControlPointManager.cpp
@@ -1,170 +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.
 
 ===================================================================*/
 
 // semantic relations module
 #include "mitkControlPointManager.h"
 #include "mitkDICOMHelper.h"
+#include "mitkSemanticRelationException.h"
 #include "mitkUIDGeneratorBoost.h"
 
 // mitk core
 #include <mitkPropertyNameHelper.h>
 
 mitk::SemanticTypes::ControlPoint mitk::GenerateControlPoint(const DataNode* datanode)
 {
-  SemanticTypes::ControlPoint controlPoint = GetDICOMDateFromDataNode(datanode);
-  controlPoint.UID = UIDGeneratorBoost::GenerateUID();
+  SemanticTypes::ControlPoint controlPoint;
+  try
+  {
+    controlPoint = GetDICOMDateFromDataNode(datanode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot generate a control point from the DICOM tag of the given data node";
+  }
 
+  controlPoint.UID = UIDGeneratorBoost::GenerateUID();
   return controlPoint;
 }
 
 mitk::SemanticTypes::ControlPoint mitk::GetControlPointByUID(const SemanticTypes::ID& controlPointUID, const std::vector<SemanticTypes::ControlPoint>& allControlPoints)
 {
   auto lambda = [&controlPointUID](const SemanticTypes::ControlPoint& currentControlPoint)
   {
     return currentControlPoint.UID == controlPointUID;
   };
 
   const auto existingControlPoint = std::find_if(allControlPoints.begin(), allControlPoints.end(), lambda);
 
   mitk::SemanticTypes::ControlPoint controlPoint;
   if (existingControlPoint != allControlPoints.end())
   {
     controlPoint = *existingControlPoint;
   }
 
   return controlPoint;
 }
 
 mitk::SemanticTypes::ControlPoint mitk::FindExistingControlPoint(const SemanticTypes::ControlPoint& controlPoint, const SemanticTypes::ControlPointVector& allControlPoints)
 {
   for (const auto& currentControlPoint : allControlPoints)
   {
     if (controlPoint.date == currentControlPoint.date)
     {
       return currentControlPoint;
     }
   }
 
   return SemanticTypes::ControlPoint();
 }
 
 mitk::SemanticTypes::ControlPoint mitk::FindClosestControlPoint(const SemanticTypes::ControlPoint& controlPoint, SemanticTypes::ControlPointVector& allControlPoints)
 {
   if (allControlPoints.empty())
   {
     return SemanticTypes::ControlPoint();
   }
 
   // sort the vector of control points for easier lookup
   std::sort(allControlPoints.begin(), allControlPoints.end());
   // new control point does not match an existing control point
   // check if the control point is close to an already existing control point
   std::vector<SemanticTypes::ControlPoint>::const_iterator it;
   for (it = allControlPoints.begin(); it != allControlPoints.end(); ++it)
   {
     if (controlPoint.date < it->date)
     {
       break;
     }
   }
 
   SemanticTypes::ControlPoint nextControlPoint;
   SemanticTypes::ControlPoint previousControlPoint;
   if (it == allControlPoints.begin())
   {
     // new date is smaller ("older") than the smallest already existing control point
     nextControlPoint = *it;
   }
   else if (it != allControlPoints.end())
   {
     // new date is greater ("newer") than an already existing control point,
     // but smaller ("older") than another already existing control point
     nextControlPoint = *it;
     previousControlPoint = *(--it);
   }
   else
   {
     // new date is greater ("newer") than the greatest already existing control point
     previousControlPoint = *(--it);
   }
 
   // test distance to next and previous time period
   double distanceToNextExaminationPeriod = nextControlPoint.DistanceInDays(controlPoint);
   double distanceToPreviousExaminationPeriod = previousControlPoint.DistanceInDays(controlPoint);
 
   SemanticTypes::ControlPoint closestControlPoint;
   int closestDistanceInDays = 0;
   if (distanceToNextExaminationPeriod < distanceToPreviousExaminationPeriod)
   {
     // control point is closer to the next control point
     closestControlPoint = nextControlPoint;
     closestDistanceInDays = distanceToNextExaminationPeriod;
   }
   else
   {
     // control point is closer to the previous control point
     closestControlPoint = previousControlPoint;
     closestDistanceInDays = distanceToPreviousExaminationPeriod;
   }
 
   int THRESHOLD_DISTANCE_IN_DAYS = 30;
-  if (closestDistanceInDays < THRESHOLD_DISTANCE_IN_DAYS)
+  if (closestDistanceInDays <= THRESHOLD_DISTANCE_IN_DAYS)
   {
     return closestControlPoint;
   }
 
   return SemanticTypes::ControlPoint();
 }
 
 mitk::SemanticTypes::ExaminationPeriod mitk::FindExaminationPeriod(const SemanticTypes::ControlPoint& controlPoint, const SemanticTypes::ExaminationPeriodVector& allExaminationPeriods)
 {
   for (const auto& examinationPeriod : allExaminationPeriods)
   {
     for (const auto& UID : examinationPeriod.controlPointUIDs)
     {
       if (controlPoint.UID == UID)
       {
         return examinationPeriod;
       }
     }
   }
 
   return SemanticTypes::ExaminationPeriod();
 }
 
 void mitk::SortExaminationPeriods(SemanticTypes::ExaminationPeriodVector& allExaminationPeriods, const SemanticTypes::ControlPointVector& allControlPoints)
 {
   auto lambda = [allControlPoints](const SemanticTypes::ExaminationPeriod& leftExaminationPeriod, const SemanticTypes::ExaminationPeriod& rightExaminationPeriod)
   {
     if (leftExaminationPeriod.controlPointUIDs.empty())
     {
       return true;
     }
 
     if (rightExaminationPeriod.controlPointUIDs.empty())
     {
       return false;
     }
     const auto leftUID = leftExaminationPeriod.controlPointUIDs.front();
     const auto rightUID = rightExaminationPeriod.controlPointUIDs.front();
     const auto& leftControlPoint = GetControlPointByUID(leftUID, allControlPoints);
     const auto& rightControlPoint = GetControlPointByUID(rightUID, allControlPoints);
 
     return leftControlPoint.date < rightControlPoint.date;
   };
 
   std::sort(allExaminationPeriods.begin(), allExaminationPeriods.end(), lambda);
 }
diff --git a/Modules/SemanticRelations/src/mitkDICOMHelper.cpp b/Modules/SemanticRelations/src/mitkDICOMHelper.cpp
index 7dffde337f..7be974ef13 100644
--- a/Modules/SemanticRelations/src/mitkDICOMHelper.cpp
+++ b/Modules/SemanticRelations/src/mitkDICOMHelper.cpp
@@ -1,161 +1,190 @@
 /*===================================================================
 
 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 module
 #include "mitkDICOMHelper.h"
 #include "mitkSemanticRelationException.h"
 #include "mitkUIDGeneratorBoost.h"
 
 // mitk core
 #include <mitkPropertyNameHelper.h>
 
 // c++
 #include <algorithm>
 
-mitk::SemanticTypes::ControlPoint GetControlPointFromString(const std::string& dateAsString);
+mitk::SemanticTypes::ControlPoint GetControlPointFromString(const std::string& dateAsString)
+{
+  // date expected to be YYYYMMDD (8 characters)
+  if (dateAsString.size() != 8)
+  {
+    // string does not represent a DICOM date
+    mitkThrowException(mitk::SemanticRelationException) << "Not a valid DICOM date format.";
+  }
+
+  mitk::SemanticTypes::ControlPoint controlPoint;
+  controlPoint.SetDateFromString(dateAsString);
+
+  return controlPoint;
+}
+
+std::string mitk::GetCaseIDDICOMProperty()
+{
+  // extract suitable DICOM tag to use as the case id
+  // two alternatives can be used:
+  //        - DICOM tag "0x0010, 0x0010" is PatientName
+  //        - DICOM tag "0x0010, 0x0020" is PatientID
+  // in the current implementation the PatientName (0x0010, 0x0010) is used
+  return GeneratePropertyNameForDICOMTag(0x0010, 0x0010);
+}
+
+std::string mitk::GetNodeIDDICOMProperty()
+{
+  // extract suitable DICOM tag to use as the data node id
+  // DICOM tag "0x0020, 0x000e" is SeriesInstanceUID
+  return GeneratePropertyNameForDICOMTag(0x0020, 0x000e);
+}
+
+std::string mitk::GetDateDICOMProperty()
+{
+  // extract suitable DICOM tag to use as the data node id
+  // DICOM tag "0x0008, 0x0022" is AcquisitionDate
+  return GeneratePropertyNameForDICOMTag(0x0008, 0x0022);
+}
+
+std::string mitk::GetModalityDICOMProperty()
+{
+  // extract suitable DICOM tag to use as the information type
+  // DICOM tag "0x0008, 0x0060" is Modality
+  return GeneratePropertyNameForDICOMTag(0x0008, 0x0060);
+}
 
 mitk::SemanticTypes::CaseID mitk::GetCaseIDFromDataNode(const mitk::DataNode* dataNode)
 {
   if (nullptr == dataNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid data node.";
   }
 
   mitk::BaseData* baseData = dataNode->GetData();
   if (nullptr == baseData)
   {
     mitkThrowException(SemanticRelationException) << "No valid base data.";
   }
 
-  // extract suitable DICOM tag to use as the case id
-  // two alternatives can be used:
-  //        - DICOM tag "0x0010, 0x0010" is PatientName
-  //        - DICOM tag "0x0010, 0x0020" is PatientID
-  // in the current implementation the PatientID (0x0010, 0x0010) is used
-  mitk::BaseProperty* dicomTag = baseData->GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0010, 0x0010).c_str());
+  mitk::BaseProperty* dicomTag = baseData->GetProperty(GetCaseIDDICOMProperty().c_str());
   if (nullptr == dicomTag)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid DICOM property.";
   }
 
   std::string dicomTagAsString = dicomTag->GetValueAsString();
   return dicomTagAsString;
 }
 
 mitk::SemanticTypes::ID mitk::GetIDFromDataNode(const mitk::DataNode* dataNode)
 {
   if (nullptr == dataNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid data node.";
   }
 
   mitk::BaseData* baseData = dataNode->GetData();
   if (nullptr == baseData)
   {
     mitkThrowException(SemanticRelationException) << "No valid base data.";
   }
 
-  // extract suitable DICOM tag to use as the data node id
-  // DICOM tag "0x0020, 0x000e" is SeriesInstanceUID
-  mitk::BaseProperty* dicomTag = baseData->GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0020, 0x000e).c_str());
+  mitk::BaseProperty* dicomTag = baseData->GetProperty(GetNodeIDDICOMProperty().c_str());
   if (nullptr == dicomTag)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid DICOM property.";
   }
   std::string dicomTagAsString = dicomTag->GetValueAsString();
   return dicomTagAsString;
 }
 
 mitk::SemanticTypes::ControlPoint mitk::GetDICOMDateFromDataNode(const mitk::DataNode* dataNode)
 {
   if (nullptr == dataNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid data node.";
   }
 
   mitk::BaseData* baseData = dataNode->GetData();
   if (nullptr == baseData)
   {
     mitkThrowException(SemanticRelationException) << "No valid base data.";
   }
 
-  // extract suitable DICOM tag to use as the data node id
-  // DICOM tag "0x0008, 0x0022" is AcquisitionDate
-  mitk::BaseProperty* acquisitionDateProperty = baseData->GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x0022).c_str());
+  mitk::BaseProperty* acquisitionDateProperty = baseData->GetProperty(GetDateDICOMProperty().c_str());
   if (nullptr == acquisitionDateProperty)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid DICOM property.";
   }
   std::string acquisitionDateAsString = acquisitionDateProperty->GetValueAsString();
-  return GetControlPointFromString(acquisitionDateAsString);
+
+  SemanticTypes::ControlPoint controlPoint;
+  try
+  {
+    controlPoint = GetControlPointFromString(acquisitionDateAsString);
+  }
+  catch (SemanticRelationException &e)
+  {
+    mitkReThrow(e) << "Cannot retrieve a valid DICOM date.";
+  }
+
+  return controlPoint;
 }
 
 mitk::SemanticTypes::InformationType mitk::GetDICOMModalityFromDataNode(const mitk::DataNode* dataNode)
 {
   if (nullptr == dataNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid data node.";
   }
 
   mitk::BaseData* baseData = dataNode->GetData();
   if (nullptr == baseData)
   {
     mitkThrowException(SemanticRelationException) << "No valid base data.";
   }
 
-  // extract suitable DICOM tag to use as the information type
-  // DICOM tag "0x0008, 0x0060" is Modality
-  mitk::BaseProperty* dicomTag = baseData->GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x0060).c_str());
+  mitk::BaseProperty* dicomTag = baseData->GetProperty(GetModalityDICOMProperty().c_str());
   if (nullptr == dicomTag)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid DICOM property.";
   }
   std::string dicomTagAsString = dicomTag->GetValueAsString();
   return dicomTagAsString;
 }
 
 std::string mitk::TrimDICOM(const std::string& identifier)
 {
   if (identifier.empty())
   {
     return identifier;
   }
 
   // leading whitespace
   std::size_t first = identifier.find_first_not_of(' ');
   if (std::string::npos == first)
   {
     return "";
   }
   // trailing whitespace
   std::size_t last = identifier.find_last_not_of(' ');
   return identifier.substr(first, last - first + 1);
 }
-
-mitk::SemanticTypes::ControlPoint GetControlPointFromString(const std::string& dateAsString)
-{
-  // date expected to be YYYYMMDD (8 characters)
-  if (dateAsString.size() != 8)
-  {
-    // string does not represent a DICOM date
-    return mitk::SemanticTypes::ControlPoint();
-  }
-
-  mitk::SemanticTypes::ControlPoint controlPoint;
-  controlPoint.SetDateFromString(dateAsString);
-
-  return controlPoint;
-}
diff --git a/Modules/SemanticRelations/src/mitkLesionManager.cpp b/Modules/SemanticRelations/src/mitkLesionManager.cpp
index fc459ad32e..a9e83d88e2 100644
--- a/Modules/SemanticRelations/src/mitkLesionManager.cpp
+++ b/Modules/SemanticRelations/src/mitkLesionManager.cpp
@@ -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.
 
 ===================================================================*/
 
 // semantic relations module
 #include "mitkLesionManager.h"
 #include "mitkSemanticRelationException.h"
 #include "mitkSemanticRelationsInference.h"
 #include "mitkRelationStorage.h"
 #include "mitkUIDGeneratorBoost.h"
 
 double GetLesionVolume(const mitk::SemanticTypes::CaseID& caseID, const mitk::SemanticTypes::Lesion& lesion, const mitk::SemanticTypes::ControlPoint& controlPoint);
 
 mitk::SemanticTypes::Lesion mitk::GenerateNewLesion(const std::string& lesionClassType/* = ""*/)
 {
-  mitk::SemanticTypes::Lesion lesion;
+  SemanticTypes::Lesion lesion;
   lesion.UID = mitk::UIDGeneratorBoost::GenerateUID();
   lesion.name = "New lesion";
-  lesion.lesionClass = mitk::SemanticTypes::LesionClass();
-  lesion.lesionClass.UID = mitk::UIDGeneratorBoost::GenerateUID();
-  lesion.lesionClass.classType = lesionClassType;
+  lesion.lesionClass = GenerateNewLesionClass(lesionClassType);
 
   return lesion;
 }
 
 mitk::SemanticTypes::LesionClass mitk::GenerateNewLesionClass(const std::string& lesionClassType/* = ""*/)
 {
-  mitk::SemanticTypes::LesionClass lesionClass;
+  SemanticTypes::LesionClass lesionClass;
   lesionClass.UID = mitk::UIDGeneratorBoost::GenerateUID();
   lesionClass.classType = lesionClassType;
 
   return lesionClass;
 }
 
 mitk::SemanticTypes::Lesion mitk::GetLesionByUID(const SemanticTypes::ID& lesionUID, const std::vector<SemanticTypes::Lesion>& allLesions)
 {
   auto lambda = [&lesionUID](const SemanticTypes::Lesion& currentLesion)
   {
     return currentLesion.UID == lesionUID;
   };
 
   const auto existingLesion = std::find_if(allLesions.begin(), allLesions.end(), lambda);
 
-  mitk::SemanticTypes::Lesion lesion;
+  SemanticTypes::Lesion lesion;
   if (existingLesion != allLesions.end())
   {
     lesion = *existingLesion;
   }
 
   return lesion;
 }
 
 mitk::SemanticTypes::LesionClass mitk::FindExistingLesionClass(const std::string& lesionClassType, const std::vector<SemanticTypes::LesionClass>& allLesionClasses)
 {
   auto lambda = [&lesionClassType](const SemanticTypes::LesionClass& currentLesionClass)
   {
     return currentLesionClass.classType == lesionClassType;
   };
 
   const auto existingLesionClass = std::find_if(allLesionClasses.begin(), allLesionClasses.end(), lambda);
 
-  mitk::SemanticTypes::LesionClass lesionClass;
+  SemanticTypes::LesionClass lesionClass;
   if (existingLesionClass != allLesionClasses.end())
   {
     lesionClass = *existingLesionClass;
   }
 
   return lesionClass;
 }
 
 void mitk::GenerateAdditionalLesionData(LesionData& lesionData, const SemanticTypes::CaseID& caseID)
 {
   std::vector<bool> lesionPresence;
   std::vector<double> lesionVolume;
   SemanticTypes::Lesion lesion = lesionData.GetLesion();
   bool presence = false;
   double volume = 0.0;
-  try
+
+  SemanticTypes::ControlPointVector controlPoints = RelationStorage::GetAllControlPointsOfCase(caseID);
+  // sort the vector of control points for the timeline
+  std::sort(controlPoints.begin(), controlPoints.end());
+  for (const auto& controlPoint : controlPoints)
   {
-    SemanticTypes::ControlPointVector controlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
-    for (const auto& controlPoint : controlPoints)
+    try
     {
-      presence = mitk::SemanticRelationsInference::IsLesionPresentAtControlPoint(caseID, lesion, controlPoint);
-      lesionPresence.push_back(presence);
-
-      volume = GetLesionVolume(caseID, lesion, controlPoint);
-      lesionVolume.push_back(volume);
+      presence = SemanticRelationsInference::IsLesionPresentAtControlPoint(caseID, lesion, controlPoint);
     }
-  }
-  catch (const mitk::SemanticRelationException&)
-  {
-    return;
+    catch (SemanticRelationException& e)
+    {
+      mitkReThrow(e) << "Cannot determine the lesion presence for generating additional lesion data.";
+    }
+
+    lesionPresence.push_back(presence);
+    volume = GetLesionVolume(caseID, lesion, controlPoint);
+    lesionVolume.push_back(volume);
   }
 
   lesionData.SetLesionPresence(lesionPresence);
   lesionData.SetLesionVolume(lesionVolume);
 }
 
 double GetLesionVolume(const mitk::SemanticTypes::CaseID& caseID, const mitk::SemanticTypes::Lesion& lesion, const mitk::SemanticTypes::ControlPoint& controlPoint)
 {
   bool presence = mitk::SemanticRelationsInference::IsLesionPresentAtControlPoint(caseID, lesion, controlPoint);
   if (presence)
   {
     return 1.0;
   }
   else
   {
     return 0.0;
   }
 }
diff --git a/Modules/SemanticRelations/src/mitkRelationStorage.cpp b/Modules/SemanticRelations/src/mitkRelationStorage.cpp
index 3a9dd560e1..0a1f1c9e40 100644
--- a/Modules/SemanticRelations/src/mitkRelationStorage.cpp
+++ b/Modules/SemanticRelations/src/mitkRelationStorage.cpp
@@ -1,1498 +1,1539 @@
 /*===================================================================
 
 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 "mitkRelationStorage.h"
 
 // semantic relations module
 #include "mitkDICOMHelper.h"
 
 // multi label module
 #include <mitkLabelSetImage.h>
 
 // mitk core
 #include <mitkIPersistenceService.h>
 #include <mitkVectorProperty.h>
 
 // c++
 #include <algorithm>
 #include <iostream>
 
 namespace
 {
+  std::vector<mitk::SemanticTypes::CaseID> GetCaseIDs()
+  {
+    PERSISTENCE_GET_SERVICE_MACRO
+    if (nullptr == persistenceService)
+    {
+      MITK_DEBUG << "Persistence service could not be loaded";
+      return std::vector<mitk::SemanticTypes::CaseID>();
+    }
+    // the property list is valid for a certain scenario and contains all the case IDs of the radiological user's MITK session
+    std::string listIdentifier = "caseIDs";
+    mitk::PropertyList::Pointer propertyList = persistenceService->GetPropertyList(listIdentifier);
+    if (nullptr == propertyList)
+    {
+      MITK_DEBUG << "Could not find the property list " << listIdentifier << " for the current MITK workbench / session.";
+      return std::vector<mitk::SemanticTypes::CaseID>();
+    }
+    // retrieve a vector property that contains all case IDs
+    mitk::VectorProperty<std::string>* caseIDsVectorProperty = dynamic_cast<mitk::VectorProperty<std::string>*>(propertyList->GetProperty(listIdentifier));
+    if (nullptr == caseIDsVectorProperty)
+    {
+      MITK_DEBUG << "Could not find the property " << listIdentifier << " for the " << listIdentifier << " property list.";
+      return std::vector<mitk::SemanticTypes::CaseID>();
+    }
+
+    return caseIDsVectorProperty->GetValue();
+  }
+
+  bool CaseIDExists(const mitk::SemanticTypes::CaseID& caseID)
+  {
+    auto allCaseIDs = GetCaseIDs();
+    auto existingCase = std::find(allCaseIDs.begin(), allCaseIDs.end(), caseID);
+    if (existingCase == allCaseIDs.end())
+    {
+      return false;
+    }
+
+    return true;
+  }
+
   mitk::PropertyList::Pointer GetStorageData(const mitk::SemanticTypes::CaseID& caseID)
   {
     // access the storage
     PERSISTENCE_GET_SERVICE_MACRO
-      if (nullptr == persistenceService)
-      {
-        MITK_DEBUG << "Persistence service could not be loaded";
-        return nullptr;
-      }
+    if (nullptr == persistenceService)
+    {
+      MITK_DEBUG << "Persistence service could not be loaded";
+      return nullptr;
+    }
+
+    // The persistence service may create a new property list with the given ID, if no property list is found.
+    // Since we don't want to return a new property list but rather inform the user that the given case
+    // is not a valid, stored case, we will return nullptr in that case.
+    if (CaseIDExists(caseID))
+    {
+      // the property list is valid for a whole case and contains all the properties for the current case
+      return persistenceService->GetPropertyList(const_cast<mitk::SemanticTypes::CaseID&>(caseID));
+    }
 
-    // the property list is valid for a whole case and contains all the properties for the current case
-    // the persistence service may create a new property list with the given ID, if no property list is found
-    return persistenceService->GetPropertyList(const_cast<mitk::SemanticTypes::CaseID&>(caseID));
+    return nullptr;
   }
 
   mitk::SemanticTypes::Lesion GenerateLesion(const mitk::SemanticTypes::CaseID& caseID, const mitk::SemanticTypes::ID& lesionID)
   {
     mitk::PropertyList::Pointer propertyList = GetStorageData(caseID);
     if (nullptr == propertyList)
     {
       MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
       return mitk::SemanticTypes::Lesion();
     }
 
     mitk::VectorProperty<std::string>* lesionDataProperty = dynamic_cast<mitk::VectorProperty<std::string>*>(propertyList->GetProperty(lesionID));
     if (nullptr == lesionDataProperty)
     {
       MITK_DEBUG << "Lesion " << lesionID << " not found. Lesion can not be retrieved.";
       return mitk::SemanticTypes::Lesion();
     }
 
     std::vector<std::string> lesionData = lesionDataProperty->GetValue();
     // a lesion date has to have exactly two values (the name of the lesion and the UID of the lesion class)
     if (lesionData.size() != 2)
     {
       MITK_DEBUG << "Incorrect lesion data storage. Not two (2) strings of the lesion name and the lesion UID are stored.";
       return mitk::SemanticTypes::Lesion();
     }
 
     // the lesion class ID is stored as the second property
     std::string lesionClassID = lesionData[1];
     mitk::StringProperty* lesionClassProperty = dynamic_cast<mitk::StringProperty*>(propertyList->GetProperty(lesionClassID));
     if (nullptr != lesionClassProperty)
     {
       mitk::SemanticTypes::LesionClass generatedLesionClass;
       generatedLesionClass.UID = lesionClassID;
       generatedLesionClass.classType = lesionClassProperty->GetValue();
 
       mitk::SemanticTypes::Lesion generatedLesion;
       generatedLesion.UID = lesionID;
       generatedLesion.name = lesionData[0];
       generatedLesion.lesionClass = generatedLesionClass;
 
       return generatedLesion;
     }
 
     MITK_DEBUG << "Incorrect lesion class storage. Lesion " << lesionID << " can not be retrieved.";
     return mitk::SemanticTypes::Lesion();
   }
 
   mitk::SemanticTypes::ControlPoint GenerateControlpoint(const mitk::SemanticTypes::CaseID& caseID, const mitk::SemanticTypes::ID& controlPointUID)
   {
     mitk::PropertyList::Pointer propertyList = GetStorageData(caseID);
     if (nullptr == propertyList)
     {
       MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
       return mitk::SemanticTypes::ControlPoint();
     }
 
     // retrieve a vector property that contains the integer values of the date of a control point (0. year 1. month 2. day)
     mitk::VectorProperty<int>* controlPointVectorProperty = dynamic_cast<mitk::VectorProperty<int>*>(propertyList->GetProperty(controlPointUID));
     if (nullptr == controlPointVectorProperty)
     {
       MITK_DEBUG << "Could not find the control point " << controlPointUID << " in the storage.";
       return mitk::SemanticTypes::ControlPoint();
     }
 
     std::vector<int> controlPointVectorPropertyValue = controlPointVectorProperty->GetValue();
     // a control point has to have exactly three integer values (year, month and day)
     if (controlPointVectorPropertyValue.size() != 3)
     {
       MITK_DEBUG << "Incorrect control point storage. Not three (3) values of the date are stored.";
       return mitk::SemanticTypes::ControlPoint();
     }
 
     // set the values of the control point
     mitk::SemanticTypes::ControlPoint generatedControlPoint;
     generatedControlPoint.UID = controlPointUID;
     generatedControlPoint.date = boost::gregorian::date(controlPointVectorPropertyValue[0],
       controlPointVectorPropertyValue[1],
       controlPointVectorPropertyValue[2]);
 
     return generatedControlPoint;
   }
 }
 
 mitk::SemanticTypes::LesionVector mitk::RelationStorage::GetAllLesionsOfCase(const SemanticTypes::CaseID& caseID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return SemanticTypes::LesionVector();
   }
   // retrieve a vector property that contains the valid lesion-IDs for the current case
   VectorProperty<std::string>* lesionsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("lesions"));
   if (nullptr == lesionsVectorProperty)
   {
     MITK_DEBUG << "Could not find any lesion in the storage.";
     return SemanticTypes::LesionVector();
   }
 
   std::vector<std::string> lesionsVectorPropertyValue = lesionsVectorProperty->GetValue();
   SemanticTypes::LesionVector allLesionsOfCase;
   for (const auto& lesionID : lesionsVectorPropertyValue)
   {
     SemanticTypes::Lesion generatedLesion = GenerateLesion(caseID, lesionID);
     if (!generatedLesion.UID.empty())
     {
       allLesionsOfCase.push_back(generatedLesion);
     }
   }
 
   return allLesionsOfCase;
 }
 
 mitk::SemanticTypes::Lesion mitk::RelationStorage::GetLesionOfSegmentation(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& segmentationID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return SemanticTypes::Lesion();
   }
 
   // retrieve a vector property that contains the referenced ID of a segmentation (0. image ID 1. lesion ID)
   VectorProperty<std::string>* segmentationVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(segmentationID));
   if (nullptr == segmentationVectorProperty)
   {
     MITK_DEBUG << "Could not find the segmentation " << segmentationID << " in the storage.";
     return SemanticTypes::Lesion();
   }
 
   std::vector<std::string> segmentationVectorPropertyValue = segmentationVectorProperty->GetValue();
   // the lesion ID of a segmentation is the second value in the vector
   if (segmentationVectorPropertyValue.size() != 2)
   {
     MITK_DEBUG << "Incorrect segmentation storage. Not two (2) IDs stored.";
     return SemanticTypes::Lesion();
   }
 
   std::string lesionID = segmentationVectorPropertyValue[1];
   if (lesionID.empty())
   {
     // segmentation does not refer to any lesion; return empty lesion
     return SemanticTypes::Lesion();
   }
 
   return GenerateLesion(caseID, lesionID);
 }
 
+mitk::SemanticTypes::ControlPointVector mitk::RelationStorage::GetAllControlPointsOfCase(const SemanticTypes::CaseID& caseID)
+{
+  PropertyList::Pointer propertyList = GetStorageData(caseID);
+  if (nullptr == propertyList)
+  {
+    MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
+    return SemanticTypes::ControlPointVector();
+  }
+
+  // retrieve a vector property that contains the valid control point-IDs for the current case
+  VectorProperty<std::string>* controlPointsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("controlpoints"));
+  if (nullptr == controlPointsVectorProperty)
+  {
+    MITK_DEBUG << "Could not find any control points in the storage.";
+    return SemanticTypes::ControlPointVector();
+  }
+
+  std::vector<std::string> controlPointsVectorPropertyValue = controlPointsVectorProperty->GetValue();
+  SemanticTypes::ControlPointVector allControlPointsOfCase;
+  for (const auto& controlPointUID : controlPointsVectorPropertyValue)
+  {
+    SemanticTypes::ControlPoint generatedControlPoint = GenerateControlpoint(caseID, controlPointUID);
+    if (!generatedControlPoint.UID.empty())
+    {
+      allControlPointsOfCase.push_back(generatedControlPoint);
+    }
+  }
+
+  return allControlPointsOfCase;
+}
+
 mitk::SemanticTypes::ControlPoint mitk::RelationStorage::GetControlPointOfImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return SemanticTypes::ControlPoint();
   }
   // retrieve a vector property that contains the information type and the referenced ID of a control point (0. information type 1. control point ID)
   VectorProperty<std::string>* imageVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(imageID));
   if (nullptr == imageVectorProperty)
   {
     MITK_DEBUG << "Could not find the image " << imageID << " in the storage.";
     return SemanticTypes::ControlPoint();
   }
 
   std::vector<std::string> imageVectorPropertyValue = imageVectorProperty->GetValue();
   SemanticTypes::ControlPoint controlPoint;
   // an image has to have exactly two values (the information type and the ID of the control point)
   if (imageVectorPropertyValue.size() != 2)
   {
     MITK_DEBUG << "Incorrect data storage. Not two (2) values stored.";
     return SemanticTypes::ControlPoint();
   }
 
   // the second value of the image vector is the ID of the referenced control point
   std::string controlPointID = imageVectorPropertyValue[1];
   // retrieve a vector property that contains the integer values of the date of a control point (0. year 1. month 2. day)
   VectorProperty<int>* controlPointVectorProperty = dynamic_cast<VectorProperty<int>*>(propertyList->GetProperty(controlPointID));
   if (nullptr == controlPointVectorProperty)
   {
     MITK_DEBUG << "Could not find the control point " << controlPointID << " in the storage.";
     return SemanticTypes::ControlPoint();
   }
 
   std::vector<int> controlPointVectorPropertyValue = controlPointVectorProperty->GetValue();
   // a control point has to have exactly three integer values (year, month and day)
   if (controlPointVectorPropertyValue.size() != 3)
   {
     MITK_DEBUG << "Incorrect control point storage. Not three (3) values of the date are stored.";
     return SemanticTypes::ControlPoint();
   }
 
   // set the values of the control point
   controlPoint.UID = controlPointID;
   controlPoint.date = boost::gregorian::date(controlPointVectorPropertyValue[0],
                                              controlPointVectorPropertyValue[1],
                                              controlPointVectorPropertyValue[2]);
 
   return controlPoint;
 }
 
-mitk::SemanticTypes::ControlPointVector mitk::RelationStorage::GetAllControlPointsOfCase(const SemanticTypes::CaseID& caseID)
-{
-  PropertyList::Pointer propertyList = GetStorageData(caseID);
-  if (nullptr == propertyList)
-  {
-    MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
-    return SemanticTypes::ControlPointVector();
-  }
-
-  // retrieve a vector property that contains the valid control point-IDs for the current case
-  VectorProperty<std::string>* controlPointsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("controlpoints"));
-  if (nullptr == controlPointsVectorProperty)
-  {
-    MITK_DEBUG << "Could not find any control points in the storage.";
-    return SemanticTypes::ControlPointVector();
-  }
-
-  std::vector<std::string> controlPointsVectorPropertyValue = controlPointsVectorProperty->GetValue();
-  SemanticTypes::ControlPointVector allControlPointsOfCase;
-  for (const auto& controlPointUID : controlPointsVectorPropertyValue)
-  {
-    SemanticTypes::ControlPoint generatedControlPoint = GenerateControlpoint(caseID, controlPointUID);
-    if (!generatedControlPoint.UID.empty())
-    {
-      allControlPointsOfCase.push_back(generatedControlPoint);
-    }
-  }
-
-  return allControlPointsOfCase;
-}
-
 mitk::SemanticTypes::ExaminationPeriodVector mitk::RelationStorage::GetAllExaminationPeriodsOfCase(const SemanticTypes::CaseID& caseID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return SemanticTypes::ExaminationPeriodVector();
   }
 
   // retrieve a vector property that contains the valid examination period UIDs for the current case
   VectorProperty<std::string>::Pointer examinationPeriodsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("examinationperiods"));
   if (nullptr == examinationPeriodsVectorProperty)
   {
     MITK_DEBUG << "Could not find any examination periods in the storage.";
     return SemanticTypes::ExaminationPeriodVector();
   }
 
   std::vector<std::string> examinationPeriodsVectorPropertyValue = examinationPeriodsVectorProperty->GetValue();
   SemanticTypes::ExaminationPeriodVector allExaminationPeriods;
   for (const auto& examinationPeriodID : examinationPeriodsVectorPropertyValue)
   {
     // retrieve a vector property that contains the represented control point-IDs
     VectorProperty<std::string>::Pointer examinationPeriodVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(examinationPeriodID));
     if (nullptr == examinationPeriodVectorProperty)
     {
       MITK_DEBUG << "Could not find the examination period " << examinationPeriodID << " in the storage.";
       continue;
     }
 
     std::vector<std::string> examinationPeriodVectorPropertyValue = examinationPeriodVectorProperty->GetValue();
     // an examination period has an arbitrary number of vector values (name and control point UIDs) (at least one for the name)
     if (examinationPeriodVectorPropertyValue.empty())
     {
       MITK_DEBUG << "Incorrect examination period storage. At least one (1) value for the examination period name has to be stored.";
       continue;
     }
     else
     {
       // set the values of the name and the control points
       SemanticTypes::ExaminationPeriod generatedExaminationPeriod;
       generatedExaminationPeriod.UID = examinationPeriodID;
       generatedExaminationPeriod.name = examinationPeriodVectorPropertyValue[0];
-      for (int i = 1; i < examinationPeriodVectorPropertyValue.size(); ++i)
+      for (size_t i = 1; i < examinationPeriodVectorPropertyValue.size(); ++i)
       {
         generatedExaminationPeriod.controlPointUIDs.push_back(examinationPeriodVectorPropertyValue[i]);
       }
 
       allExaminationPeriods.push_back(generatedExaminationPeriod);
     }
   }
   return allExaminationPeriods;
 }
 
+mitk::SemanticTypes::InformationTypeVector mitk::RelationStorage::GetAllInformationTypesOfCase(const SemanticTypes::CaseID& caseID)
+{
+  PropertyList::Pointer propertyList = GetStorageData(caseID);
+  if (nullptr == propertyList)
+  {
+    MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
+    return SemanticTypes::InformationTypeVector();
+  }
+  // retrieve a vector property that contains the valid information types of the current case
+  VectorProperty<std::string>* informationTypesVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("informationtypes"));
+  if (nullptr == informationTypesVectorProperty)
+  {
+    MITK_DEBUG << "Could not find any information types in the storage.";
+    return SemanticTypes::InformationTypeVector();
+  }
+
+  return informationTypesVectorProperty->GetValue();
+}
+
 mitk::SemanticTypes::InformationType mitk::RelationStorage::GetInformationTypeOfImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return SemanticTypes::InformationType();
   }
   // retrieve a vector property that contains the information type and the referenced ID of an image (0. information type 1. control point ID)
   VectorProperty<std::string>* imageVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(imageID));
   if (nullptr == imageVectorProperty)
   {
     MITK_DEBUG << "Could not find the image " << imageID << " in the storage.";
     return SemanticTypes::InformationType();
   }
 
   std::vector<std::string> imageVectorPropertyValue = imageVectorProperty->GetValue();
   // an image has to have exactly two values (the information type and the ID of the control point)
   if (imageVectorPropertyValue.size() != 2)
   {
     MITK_DEBUG << "Incorrect data storage. Not two (2) values stored.";
     return SemanticTypes::InformationType();
   }
 
   // the first value of the image vector is the information type
   return imageVectorPropertyValue[0];
 }
 
-mitk::SemanticTypes::InformationTypeVector mitk::RelationStorage::GetAllInformationTypesOfCase(const SemanticTypes::CaseID& caseID)
-{
-  PropertyList::Pointer propertyList = GetStorageData(caseID);
-  if (nullptr == propertyList)
-  {
-    MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
-    return SemanticTypes::InformationTypeVector();
-  }
-  // retrieve a vector property that contains the valid information types of the current case
-  VectorProperty<std::string>* informationTypesVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("informationtypes"));
-  if (nullptr == informationTypesVectorProperty)
-  {
-    MITK_DEBUG << "Could not find any information types in the storage.";
-    return SemanticTypes::InformationTypeVector();
-  }
-
-  return informationTypesVectorProperty->GetValue();
-}
-
 mitk::SemanticTypes::IDVector mitk::RelationStorage::GetAllImageIDsOfCase(const SemanticTypes::CaseID& caseID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return SemanticTypes::IDVector();
   }
   // retrieve a vector property that contains the valid image-IDs of the current case
   VectorProperty<std::string>* imagesVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("images"));
   if (nullptr == imagesVectorProperty)
   {
     MITK_DEBUG << "Could not find any image in the storage.";
     return SemanticTypes::IDVector();
   }
 
   return imagesVectorProperty->GetValue();
 }
 
 mitk::SemanticTypes::IDVector mitk::RelationStorage::GetAllImageIDsOfControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return SemanticTypes::IDVector();
   }
   // retrieve a vector property that contains the valid image-IDs of the current case
   VectorProperty<std::string>* imagesVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("images"));
   if (nullptr == imagesVectorProperty)
   {
     MITK_DEBUG << "Could not find any image in the storage.";
     return SemanticTypes::IDVector();
   }
 
   mitk::SemanticTypes::IDVector allImageIDsOfControlPoint;
   std::vector<std::string> imagesVectorPropertyValue = imagesVectorProperty->GetValue();
   for (const auto& imageID : imagesVectorPropertyValue)
   {
     // retrieve a vector property that contains the referenced ID of an image (0. information type 1. control point ID)
     VectorProperty<std::string>* imageVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(imageID));
     if (nullptr == imageVectorProperty)
     {
       continue;
     }
 
     std::vector<std::string> imageVectorPropertyValue = imageVectorProperty->GetValue();
     // an image has to have exactly two values (the information type and the ID of the control point)
     if (imageVectorPropertyValue.size() != 2)
     {
       continue;
     }
 
     // the second value of the image vector is the ID of the referenced control point
     if (imageVectorPropertyValue[1] == controlPoint.UID)
     {
       allImageIDsOfControlPoint.push_back(imageID);
     }
   }
 
   return allImageIDsOfControlPoint;
 }
 
 mitk::SemanticTypes::IDVector mitk::RelationStorage::GetAllImageIDsOfInformationType(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return SemanticTypes::IDVector();
   }
   // retrieve a vector property that contains the valid image-IDs of the current case
   VectorProperty<std::string>* imagesVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("images"));
   if (nullptr == imagesVectorProperty)
   {
     MITK_DEBUG << "Could not find any image in the storage.";
     return SemanticTypes::IDVector();
   }
 
   mitk::SemanticTypes::IDVector allImageIDsOfInformationType;
   std::vector<std::string> imagesVectorPropertyValue = imagesVectorProperty->GetValue();
   for (const auto& imageID : imagesVectorPropertyValue)
   {
     // retrieve a vector property that contains the referenced ID of an image (0. information type 1. control point ID)
     VectorProperty<std::string>* imageVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(imageID));
     if (nullptr == imageVectorProperty)
     {
       continue;
     }
 
     std::vector<std::string> imageVectorPropertyValue = imageVectorProperty->GetValue();
     // an image has to have exactly two values (the information type and the ID of the control point)
     if (imageVectorPropertyValue.size() != 2)
     {
       continue;
     }
 
     // the first value of the image vector is the ID of the referenced information type
     if (imageVectorPropertyValue[0] == informationType)
     {
       allImageIDsOfInformationType.push_back(imageID);
     }
   }
 
   return allImageIDsOfInformationType;
 }
 
 mitk::SemanticTypes::IDVector mitk::RelationStorage::GetAllSegmentationIDsOfCase(const SemanticTypes::CaseID& caseID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return SemanticTypes::IDVector();
   }
   // retrieve a vector property that contains the valid segmentation-IDs for the current case
   VectorProperty<std::string>* segmentationsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("segmentations"));
   if (nullptr == segmentationsVectorProperty)
   {
     MITK_DEBUG << "Could not find any segmentation in the storage.";
     return SemanticTypes::IDVector();
   }
 
   return segmentationsVectorProperty->GetValue();
 }
 
 mitk::SemanticTypes::IDVector mitk::RelationStorage::GetAllSegmentationIDsOfImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return SemanticTypes::IDVector();
   }
   // retrieve a vector property that contains the valid segmentation-IDs for the current case
   VectorProperty<std::string>* segmentationsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("segmentations"));
   if (nullptr == segmentationsVectorProperty)
   {
     MITK_DEBUG << "Could not find any segmentation in the storage.";
     return SemanticTypes::IDVector();
   }
 
   mitk::SemanticTypes::IDVector allSegmentationIDsOfImage;
   std::vector<std::string> segmentationsVectorPropertyValue = segmentationsVectorProperty->GetValue();
   for (const auto& segmentationID : segmentationsVectorPropertyValue)
   {
     // retrieve a vector property that contains the referenced ID of a segmentation (0. image ID 1. lesion ID)
     VectorProperty<std::string>* segmentationVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(segmentationID));
     if (nullptr == segmentationVectorProperty)
     {
       continue;
     }
 
     std::vector<std::string> segmentationVectorPropertyValue = segmentationVectorProperty->GetValue();
     // a segmentation has to have exactly two values (the ID of the referenced image and the ID of the referenced lesion)
     if (segmentationVectorPropertyValue.size() != 2)
     {
       continue;
     }
 
     // the first value of the segmentation vector is the ID of the referenced image
     if (segmentationVectorPropertyValue[0] == imageID)
     {
-      allSegmentationIDsOfImage.push_back(imageID);
+      allSegmentationIDsOfImage.push_back(segmentationID);
     }
   }
 
   return allSegmentationIDsOfImage;
 }
 
 mitk::SemanticTypes::IDVector mitk::RelationStorage::GetAllSegmentationIDsOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return SemanticTypes::IDVector();
   }
   // retrieve a vector property that contains the valid segmentation-IDs for the current case
   VectorProperty<std::string>* segmentationsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("segmentations"));
   if (nullptr == segmentationsVectorProperty)
   {
     MITK_DEBUG << "Could not find any segmentation in the storage.";
     return SemanticTypes::IDVector();
   }
 
   mitk::SemanticTypes::IDVector allSegmentationIDsOfLesion;
   std::vector<std::string> segmentationsVectorPropertyValue = segmentationsVectorProperty->GetValue();
   for (const auto& segmentationID : segmentationsVectorPropertyValue)
   {
     // retrieve a vector property that contains the referenced ID of a segmentation (0. image ID 1. lesion ID)
     VectorProperty<std::string>* segmentationVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(segmentationID));
     if (nullptr == segmentationVectorProperty)
     {
       continue;
     }
 
     std::vector<std::string> segmentationVectorPropertyValue = segmentationVectorProperty->GetValue();
     // a segmentation has to have exactly two values (the ID of the referenced image and the ID of the referenced lesion)
     if (segmentationVectorPropertyValue.size() != 2)
     {
       continue;
     }
 
     // the second value of the segmentation vector is the ID of the referenced lesion
     if (segmentationVectorPropertyValue[1] == lesion.UID)
     {
       allSegmentationIDsOfLesion.push_back(segmentationID);
     }
   }
 
   return allSegmentationIDsOfLesion;
 }
 
 mitk::SemanticTypes::ID mitk::RelationStorage::GetImageIDOfSegmentation(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& segmentationID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return SemanticTypes::ID();
   }
 
   // retrieve a vector property that contains the referenced ID of a segmentation (0. image ID 1. lesion ID)
   VectorProperty<std::string>* segmentationVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(segmentationID));
   if (nullptr == segmentationVectorProperty)
   {
     MITK_DEBUG << "Could not find the segmentation " << segmentationID << " in the storage.";
     return SemanticTypes::ID();
   }
 
   std::vector<std::string> segmentationVectorPropertyValue = segmentationVectorProperty->GetValue();
   // the lesion ID of a segmentation is the second value in the vector
   if (segmentationVectorPropertyValue.size() != 2)
   {
     MITK_DEBUG << "Incorrect segmentation storage. Not two (2) IDs stored.";
     return SemanticTypes::ID();
   }
 
   return segmentationVectorPropertyValue[0];
 }
 
 std::vector<mitk::SemanticTypes::CaseID> mitk::RelationStorage::GetAllCaseIDs()
 {
-  PERSISTENCE_GET_SERVICE_MACRO
-  if (nullptr == persistenceService)
-  {
-    MITK_DEBUG << "Persistence service could not be loaded";
-    return std::vector<SemanticTypes::CaseID>();
-  }
-  // the property list is valid for a certain scenario and contains all the case IDs of the radiological user's MITK session
-  std::string listIdentifier = "caseIDs";
-  PropertyList::Pointer propertyList = persistenceService->GetPropertyList(listIdentifier);
-  if (nullptr == propertyList)
-  {
-    MITK_DEBUG << "Could not find the property list " << listIdentifier << " for the current MITK workbench / session.";
-    return std::vector<SemanticTypes::CaseID>();
-  }
-  // retrieve a vector property that contains all case IDs
-  VectorProperty<std::string>* caseIDsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(listIdentifier));
-  if (nullptr == caseIDsVectorProperty)
-  {
-    MITK_DEBUG << "Could not find the property " << listIdentifier << " for the " << listIdentifier << " property list.";
-    return std::vector<SemanticTypes::CaseID>();
-  }
+  return GetCaseIDs();
+}
 
-  return caseIDsVectorProperty->GetValue();
+bool mitk::RelationStorage::InstanceExists(const SemanticTypes::CaseID& caseID)
+{
+  return CaseIDExists(caseID);
 }
 
 void mitk::RelationStorage::AddCase(const SemanticTypes::CaseID& caseID)
 {
   PERSISTENCE_GET_SERVICE_MACRO
   if (nullptr == persistenceService)
   {
     MITK_DEBUG << "Persistence service could not be loaded";
     return;
   }
   // the property list is valid for a certain scenario and contains all the case IDs of the radiological user's MITK session
   std::string listIdentifier = "caseIDs";
   PropertyList::Pointer propertyList = persistenceService->GetPropertyList(listIdentifier);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << listIdentifier << " for the current MITK workbench / session.";
     return;
   }
   // retrieve a vector property that contains all case IDs
   VectorProperty<std::string>::Pointer caseIDsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(listIdentifier));
   std::vector<std::string> caseIDsVectorPropertyValue;
   if (nullptr == caseIDsVectorProperty)
   {
     caseIDsVectorProperty = VectorProperty<std::string>::New();
   }
   else
   {
     caseIDsVectorPropertyValue = caseIDsVectorProperty->GetValue();
   }
 
   auto existingCase = std::find(caseIDsVectorPropertyValue.begin(), caseIDsVectorPropertyValue.end(), caseID);
   if (existingCase != caseIDsVectorPropertyValue.end())
   {
     return;
   }
 
   // add case to the "caseIDs" property list
   caseIDsVectorPropertyValue.push_back(caseID);
   caseIDsVectorProperty->SetValue(caseIDsVectorPropertyValue);
   propertyList->SetProperty(listIdentifier, caseIDsVectorProperty);
 }
 
 void mitk::RelationStorage::AddImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
 
   // retrieve a vector property that contains the valid image-IDs for the current case
   VectorProperty<std::string>::Pointer imagesVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("images"));
   std::vector<std::string> imagesVectorPropertyValue;
   if (nullptr == imagesVectorProperty)
   {
     imagesVectorProperty = VectorProperty<std::string>::New();
   }
   else
   {
     imagesVectorPropertyValue = imagesVectorProperty->GetValue();
   }
 
   auto existingImage = std::find(imagesVectorPropertyValue.begin(), imagesVectorPropertyValue.end(), imageID);
   if (existingImage != imagesVectorPropertyValue.end())
   {
     return;
   }
 
   // add image to the "images" property list
   imagesVectorPropertyValue.push_back(imageID);
   imagesVectorProperty->SetValue(imagesVectorPropertyValue);
   propertyList->SetProperty("images", imagesVectorProperty);
 
   // add the image itself
   VectorProperty<std::string>::Pointer imageVectorProperty = VectorProperty<std::string>::New();
   // an image has to have exactly two values (the information type and the ID of the control point)
   std::vector<std::string> imageVectorPropertyValue(2);
   imageVectorProperty->SetValue(imageVectorPropertyValue);
   propertyList->SetProperty(imageID, imageVectorProperty);
 }
 
 void mitk::RelationStorage::RemoveImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
 
   // retrieve a vector property that contains the valid image-IDs for the current case
   VectorProperty<std::string>::Pointer imagesVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("images"));
   if (nullptr == imagesVectorProperty)
   {
     MITK_DEBUG << "Could not find any images in the storage.";
     return;
   }
 
   // remove the image reference from the list of all images of the current case
   std::vector<std::string> imagesVectorPropertyValue = imagesVectorProperty->GetValue();
   imagesVectorPropertyValue.erase(std::remove(imagesVectorPropertyValue.begin(), imagesVectorPropertyValue.end(), imageID), imagesVectorPropertyValue.end());
   if (imagesVectorPropertyValue.empty())
   {
     // no more images stored -> remove the images property list
     propertyList->DeleteProperty("images");
   }
   else
   {
     // or store the modified vector value
     imagesVectorProperty->SetValue(imagesVectorPropertyValue);
   }
 
   // remove the image instance itself
   propertyList->DeleteProperty(imageID);
 }
 
 void mitk::RelationStorage::AddSegmentation(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& segmentationID, const SemanticTypes::ID& parentID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
 
   // retrieve a vector property that contains the valid segmentation-IDs for the current case
   VectorProperty<std::string>::Pointer segmentationsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("segmentations"));
   std::vector<std::string> segmentationsVectorPropertyValue;
   if (nullptr == segmentationsVectorProperty)
   {
     segmentationsVectorProperty = VectorProperty<std::string>::New();
   }
   else
   {
     segmentationsVectorPropertyValue = segmentationsVectorProperty->GetValue();
   }
 
-  auto existingImage = std::find(segmentationsVectorPropertyValue.begin(), segmentationsVectorPropertyValue.end(), segmentationID);
-  if (existingImage != segmentationsVectorPropertyValue.end())
+  auto existingSegmentation = std::find(segmentationsVectorPropertyValue.begin(), segmentationsVectorPropertyValue.end(), segmentationID);
+  if (existingSegmentation != segmentationsVectorPropertyValue.end())
   {
     return;
   }
 
   // add segmentation to the "segmentations" property list
   segmentationsVectorPropertyValue.push_back(segmentationID);
   segmentationsVectorProperty->SetValue(segmentationsVectorPropertyValue);
   propertyList->SetProperty("segmentations", segmentationsVectorProperty);
 
   // add the segmentation itself
   VectorProperty<std::string>::Pointer segmentationVectorProperty = VectorProperty<std::string>::New();
   // a segmentation has to have exactly two values (the ID of the referenced image and the ID of the referenced lesion)
   std::vector<std::string> segmentationVectorPropertyValue(2);
   segmentationVectorPropertyValue[0] = parentID;
   segmentationVectorProperty->SetValue(segmentationVectorPropertyValue);
   propertyList->SetProperty(segmentationID, segmentationVectorProperty);
 }
 
 void mitk::RelationStorage::RemoveSegmentation(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& segmentationID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
 
   // retrieve a vector property that contains the valid segmentation-IDs for the current case
   VectorProperty<std::string>::Pointer segmentationsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("segmentations"));
   if (nullptr == segmentationsVectorProperty)
   {
     MITK_DEBUG << "Could not find any segmentation in the storage.";
     return;
   }
 
   // remove the lesion reference from the list of all lesions of the current case
   std::vector<std::string> segmentationsVectorPropertyValue = segmentationsVectorProperty->GetValue();
   segmentationsVectorPropertyValue.erase(std::remove(segmentationsVectorPropertyValue.begin(), segmentationsVectorPropertyValue.end(), segmentationID), segmentationsVectorPropertyValue.end());
   if (segmentationsVectorPropertyValue.empty())
   {
     // no more segmentations stored -> remove the segmentations property list
     propertyList->DeleteProperty("segmentations");
   }
   else
   {
     // or store the modified vector value
     segmentationsVectorProperty->SetValue(segmentationsVectorPropertyValue);
   }
 
   // remove the lesion instance itself
   propertyList->DeleteProperty(segmentationID);
 }
 
 void mitk::RelationStorage::AddLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
   // retrieve a vector property that contains the valid lesion-IDs for the current case
   VectorProperty<std::string>::Pointer lesionsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("lesions"));
   std::vector<std::string> lesionsVectorPropertyValue;
   if (nullptr == lesionsVectorProperty)
   {
     lesionsVectorProperty = VectorProperty<std::string>::New();
   }
   else
   {
     lesionsVectorPropertyValue = lesionsVectorProperty->GetValue();
   }
 
   const auto& existingIndex = std::find(lesionsVectorPropertyValue.begin(), lesionsVectorPropertyValue.end(), lesion.UID);
   if (existingIndex != lesionsVectorPropertyValue.end())
   {
     return;
   }
 
   // add the new lesion id from the given lesion to the vector of all current lesion IDs
   lesionsVectorPropertyValue.push_back(lesion.UID);
   // overwrite the current vector property with the new, extended string vector
   lesionsVectorProperty->SetValue(lesionsVectorPropertyValue);
   propertyList->SetProperty("lesions", lesionsVectorProperty);
 
   // add the lesion with the lesion UID as the key and the lesion information as value
   std::vector<std::string> lesionData;
   lesionData.push_back(lesion.name);
   lesionData.push_back(lesion.lesionClass.UID);
   VectorProperty<std::string>::Pointer newLesionVectorProperty = VectorProperty<std::string>::New();
   newLesionVectorProperty->SetValue(lesionData);
   propertyList->SetProperty(lesion.UID, newLesionVectorProperty);
 
   // add the lesion class with the lesion class UID as key and the class type as value
   std::string lesionClassType = lesion.lesionClass.classType;
   propertyList->SetStringProperty(lesion.lesionClass.UID.c_str(), lesionClassType.c_str());
 }
 
 void mitk::RelationStorage::OverwriteLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
   // retrieve a vector property that contains the valid lesion-IDs for the current case
   VectorProperty<std::string>* lesionVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("lesions"));
   if (nullptr == lesionVectorProperty)
   {
     MITK_DEBUG << "Could not find any lesion in the storage.";
     return;
   }
 
   std::vector<std::string> lesionVectorPropertyValue = lesionVectorProperty->GetValue();
   const auto existingLesion = std::find(lesionVectorPropertyValue.begin(), lesionVectorPropertyValue.end(), lesion.UID);
   if (existingLesion != lesionVectorPropertyValue.end())
   {
     // overwrite the referenced lesion class UID with the new, given lesion class data
     std::vector<std::string> lesionData;
     lesionData.push_back(lesion.name);
     lesionData.push_back(lesion.lesionClass.UID);
     VectorProperty<std::string>::Pointer newLesionVectorProperty = VectorProperty<std::string>::New();
     newLesionVectorProperty->SetValue(lesionData);
     propertyList->SetProperty(lesion.UID, newLesionVectorProperty);
 
     // overwrite the lesion class with the lesion class UID as key and the new, given class type as value
     std::string lesionClassType = lesion.lesionClass.classType;
     propertyList->SetStringProperty(lesion.lesionClass.UID.c_str(), lesionClassType.c_str());
   }
   else
   {
     MITK_DEBUG << "Could not find lesion " << lesion.UID << " in the storage. Cannot overwrite the lesion.";
   }
 }
 
 void mitk::RelationStorage::LinkSegmentationToLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& segmentationID, const SemanticTypes::Lesion& lesion)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
   // retrieve a vector property that contains the valid lesion-IDs for the current case
   VectorProperty<std::string>* lesionVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("lesions"));
   if (nullptr == lesionVectorProperty)
   {
     MITK_DEBUG << "Could not find any lesion in the storage.";
     return;
   }
 
   std::vector<std::string> lesionVectorPropertyValue = lesionVectorProperty->GetValue();
   const auto existingLesion = std::find(lesionVectorPropertyValue.begin(), lesionVectorPropertyValue.end(), lesion.UID);
   if (existingLesion != lesionVectorPropertyValue.end())
   {
     // set / overwrite the lesion reference of the given segmentation
     // retrieve a vector property that contains the referenced ID of a segmentation (0. image ID 1. lesion ID)
     VectorProperty<std::string>* segmentationVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(segmentationID));
     if (nullptr == segmentationVectorProperty)
     {
       MITK_DEBUG << "Could not find the segmentation " << segmentationID << " in the storage. Cannot link segmentation to lesion.";
       return;
     }
 
     std::vector<std::string> segmentationVectorPropertyValue = segmentationVectorProperty->GetValue();
     if (segmentationVectorPropertyValue.size() != 2)
     {
       MITK_DEBUG << "Incorrect segmentation storage. Not two (2) IDs stored.";
       return;
     }
 
     // the lesion ID of a segmentation is the second value in the vector
     segmentationVectorPropertyValue[1] = lesion.UID;
     segmentationVectorProperty->SetValue(segmentationVectorPropertyValue);
     return;
   }
 
   MITK_DEBUG << "Could not find lesion " << lesion.UID << " in the storage. Cannot link segmentation to lesion.";
 }
 
 void mitk::RelationStorage::UnlinkSegmentationFromLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& segmentationID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
   // retrieve a vector property that contains the referenced ID of a segmentation (0. image ID 1. lesion ID)
   VectorProperty<std::string>* segmentationVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(segmentationID));
   if (nullptr == segmentationVectorProperty)
   {
     MITK_DEBUG << "Could not find the segmentation " << segmentationID << " in the storage. Cannot unlink lesion from segmentation.";
     return;
   }
 
   std::vector<std::string> segmentationVectorPropertyValue = segmentationVectorProperty->GetValue();
   // a segmentation has to have exactly two values (the ID of the linked image and the ID of the lesion)
   if (segmentationVectorPropertyValue.size() != 2)
   {
     MITK_DEBUG << "Incorrect data storage. Not two (2) values stored.";
     return;
   }
 
   // the second value of the segmentation vector is the ID of the referenced lesion
   // set the lesion reference to an empty string for removal
   segmentationVectorPropertyValue[1] = "";
   segmentationVectorProperty->SetValue(segmentationVectorPropertyValue);
 }
 
 void mitk::RelationStorage::RemoveLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
   // retrieve a vector property that contains the valid lesions of the current case
   VectorProperty<std::string>* lesionVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("lesions"));
   if (nullptr == lesionVectorProperty)
   {
     MITK_DEBUG << "Could not find any lesion in the storage.";
     return;
   }
 
   // remove the lesion reference from the list of all lesions of the current case
   std::vector<std::string> lesionsVectorPropertyValue = lesionVectorProperty->GetValue();
   lesionsVectorPropertyValue.erase(std::remove(lesionsVectorPropertyValue.begin(), lesionsVectorPropertyValue.end(), lesion.UID), lesionsVectorPropertyValue.end());
   if (lesionsVectorPropertyValue.empty())
   {
     // no more lesions stored -> remove the lesions property list
     propertyList->DeleteProperty("lesions");
   }
   else
   {
     // or store the modified vector value
     lesionVectorProperty->SetValue(lesionsVectorPropertyValue);
   }
 
   // remove the lesion instance itself
   // the lesion data is stored under the lesion ID
   VectorProperty<std::string>* lesionDataProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(lesion.UID));
   if (nullptr == lesionDataProperty)
   {
     MITK_DEBUG << "Lesion " << lesion.UID << " not found (already removed?). Cannot remove the lesion.";
     return;
   }
 
   std::vector<std::string> lesionData = lesionDataProperty->GetValue();
   // a lesion date has to have exactly two values (the name of the lesion and the UID of the lesion class)
   if (lesionData.size() != 2)
   {
     MITK_DEBUG << "Incorrect lesion data storage. Not two (2) strings of the lesion UID and the lesion name are stored.";
   }
   else
   {
     std::string lesionClassID = lesionData[1];
     RemoveLesionClass(caseID, lesionClassID);
   }
   propertyList->DeleteProperty(lesion.UID);
 }
 
 void mitk::RelationStorage::RemoveLesionClass(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& lesionClassID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
 
   // retrieve a vector property that contains the lesion class
   StringProperty* lesionClassProperty = dynamic_cast<StringProperty*>(propertyList->GetProperty(lesionClassID));
   if (nullptr == lesionClassProperty)
   {
     MITK_DEBUG << "Lesion class " << lesionClassID << " not found (already removed?). Cannot remove the lesion class.";
     return;
   }
 
   // retrieve a vector property that contains the valid lesions of the current case
   VectorProperty<std::string>* lesionVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("lesions"));
   if (nullptr == lesionVectorProperty)
   {
     return;
   }
 
   // check if the lesion class ID is referenced by any other lesion
   std::vector<std::string> lesionsVectorPropertyValue = lesionVectorProperty->GetValue();
   const auto existingLesionClass = std::find_if(lesionsVectorPropertyValue.begin(), lesionsVectorPropertyValue.end(),
     [&propertyList, &lesionClassID](const std::string& lesionID)
   {
     VectorProperty<std::string>* lesionDataProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(lesionID));
     if (nullptr == lesionDataProperty)
     {
       return false;
     }
 
     std::vector<std::string> lesionData = lesionDataProperty->GetValue();
     // a lesion date has to have exactly two values (the name of the lesion and the UID of the lesion class)
     if (lesionData.size() != 2)
     {
       return false;
     }
 
     return lesionData[1] == lesionClassID;
   });
 
   if (existingLesionClass == lesionsVectorPropertyValue.end())
   {
     // lesion class ID not referenced; remove lesion class
     propertyList->DeleteProperty(lesionClassID);
   }
 }
 
 void mitk::RelationStorage::AddControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
   // retrieve a vector property that contains the valid controlPoint UIDs for the current case
   VectorProperty<std::string>::Pointer controlPointsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("controlpoints"));
   std::vector<std::string> controlPointsVectorPropertyValue;
   if (nullptr == controlPointsVectorProperty)
   {
     controlPointsVectorProperty = VectorProperty<std::string>::New();
   }
   else
   {
     controlPointsVectorPropertyValue = controlPointsVectorProperty->GetValue();
   }
 
   const auto existingControlPoint = std::find(controlPointsVectorPropertyValue.begin(), controlPointsVectorPropertyValue.end(), controlPoint.UID);
   if (existingControlPoint != controlPointsVectorPropertyValue.end())
   {
     return;
   }
 
   // add the new control point UID from the given control point to the vector of all current control point UIDs
   controlPointsVectorPropertyValue.push_back(controlPoint.UID);
   // overwrite the current vector property with the new, extended string vector
   controlPointsVectorProperty->SetValue(controlPointsVectorPropertyValue);
   propertyList->SetProperty("controlpoints", controlPointsVectorProperty);
 
   // store the control point values (the three integer values of a date)
   std::vector<int> controlPointDate;
   controlPointDate.push_back(controlPoint.date.year());
   controlPointDate.push_back(controlPoint.date.month());
   controlPointDate.push_back(controlPoint.date.day());
 
   VectorProperty<int>::Pointer newControlPointVectorProperty = VectorProperty<int>::New();
   newControlPointVectorProperty->SetValue(controlPointDate);
   propertyList->SetProperty(controlPoint.UID, newControlPointVectorProperty);
 }
 
 void mitk::RelationStorage::LinkImageToControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID, const SemanticTypes::ControlPoint& controlPoint)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
   // retrieve a vector property that contains the valid controlPoint UIDs for the current case
   VectorProperty<std::string>* controlPointsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("controlpoints"));
   if (nullptr == controlPointsVectorProperty)
   {
     MITK_DEBUG << "Could not find any control point in the storage.";
     return;
   }
 
   std::vector<std::string> controlPointsVectorPropertyValue = controlPointsVectorProperty->GetValue();
   const auto existingControlPoint = std::find(controlPointsVectorPropertyValue.begin(), controlPointsVectorPropertyValue.end(), controlPoint.UID);
   if (existingControlPoint != controlPointsVectorPropertyValue.end())
   {
     // set / overwrite the control point reference of the given data
     // retrieve a vector property that contains the referenced ID of a image (0. information type 1. control point ID)
     VectorProperty<std::string>* imageVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(imageID));
     if (nullptr == imageVectorProperty)
     {
       MITK_DEBUG << "Could not find the image " << imageID << " in the storage. Cannot link data to control point.";
       return;
     }
 
     std::vector<std::string> imageVectorPropertyValue = imageVectorProperty->GetValue();
     // an image has to have exactly two values (the information type and the ID of the control point)
     if (imageVectorPropertyValue.size() != 2)
     {
       MITK_DEBUG << "Incorrect data storage. Not two (2) values stored.";
       return;
     }
 
     // the second value of the image vector is the ID of the referenced control point
     imageVectorPropertyValue[1] = controlPoint.UID;
     imageVectorProperty->SetValue(imageVectorPropertyValue);
     return;
   }
 
   MITK_DEBUG << "Could not find control point " << controlPoint.UID << " in the storage. Cannot link data to control point.";
 }
 
 void mitk::RelationStorage::UnlinkImageFromControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
   // retrieve a vector property that contains the referenced ID of a date (0. information type 1. control point ID)
   VectorProperty<std::string>* imageVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(imageID));
   if (nullptr == imageVectorProperty)
   {
     MITK_DEBUG << "Could not find the date " << imageID << " in the storage. Cannot unlink control point from date.";
     return;
   }
 
   std::vector<std::string> imageVectorPropertyValue = imageVectorProperty->GetValue();
   // an image has to have exactly two values (the information type and the ID of the control point)
   if (imageVectorPropertyValue.size() != 2)
   {
     MITK_DEBUG << "Incorrect data storage. Not two (2) values stored.";
     return;
   }
 
   // the second value of the image vector is the ID of the referenced control point
   // set the control point reference to an empty string for removal
   imageVectorPropertyValue[1] = "";
   imageVectorProperty->SetValue(imageVectorPropertyValue);
 }
 
-void mitk::RelationStorage::RemoveControlPointFromCase(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint)
+void mitk::RelationStorage::RemoveControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
   // retrieve a vector property that contains the valid controlPoint UIDs for the current case
   VectorProperty<std::string>* controlPointsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("controlpoints"));
   if (nullptr == controlPointsVectorProperty)
   {
     MITK_DEBUG << "Could not find any control point in the storage.";
     return;
   }
 
   // remove the control point reference from the list of all control points of the current case
   std::vector<std::string> controlPointsVectorPropertyValue = controlPointsVectorProperty->GetValue();
   controlPointsVectorPropertyValue.erase(std::remove(controlPointsVectorPropertyValue.begin(), controlPointsVectorPropertyValue.end(), controlPoint.UID), controlPointsVectorPropertyValue.end());
-  controlPointsVectorProperty->SetValue(controlPointsVectorPropertyValue);
+  if (controlPointsVectorPropertyValue.empty())
+  {
+    // no more control points stored -> remove the control point property list
+    propertyList->DeleteProperty("controlpoints");
+  }
+  else
+  {
+    // or store the modified vector value
+    controlPointsVectorProperty->SetValue(controlPointsVectorPropertyValue);
+  }
 
   // remove the control point instance itself
   propertyList->DeleteProperty(controlPoint.UID);
 }
 
 void mitk::RelationStorage::AddExaminationPeriod(const SemanticTypes::CaseID& caseID, const SemanticTypes::ExaminationPeriod& examinationPeriod)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
   // retrieve a vector property that contains the valid examination period UIDs for the current case
   VectorProperty<std::string>::Pointer examinationPeriodsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("examinationperiods"));
   std::vector<std::string> examinationPeriodsVectorPropertyValue;
   if (nullptr == examinationPeriodsVectorProperty)
   {
     examinationPeriodsVectorProperty = VectorProperty<std::string>::New();
   }
   else
   {
     examinationPeriodsVectorPropertyValue = examinationPeriodsVectorProperty->GetValue();
   }
 
   const auto& existingIndex = std::find(examinationPeriodsVectorPropertyValue.begin(), examinationPeriodsVectorPropertyValue.end(), examinationPeriod.UID);
   if (existingIndex != examinationPeriodsVectorPropertyValue.end())
   {
     return;
   }
 
   // add the new examination period id from the given examination period to the vector of all current examination period UIDs
   examinationPeriodsVectorPropertyValue.push_back(examinationPeriod.UID);
   // overwrite the current vector property with the new, extended string vector
   examinationPeriodsVectorProperty->SetValue(examinationPeriodsVectorPropertyValue);
   propertyList->SetProperty("examinationperiods", examinationPeriodsVectorProperty);
 
   // add the examination period with the UID as the key and the name as as the vector value
   std::vector<std::string> examinationPeriodData;
   examinationPeriodData.push_back(examinationPeriod.name);
   VectorProperty<std::string>::Pointer newExaminationPeriodVectorProperty = VectorProperty<std::string>::New();
   newExaminationPeriodVectorProperty->SetValue(examinationPeriodData);
   propertyList->SetProperty(examinationPeriod.UID, newExaminationPeriodVectorProperty);
 }
 
 void mitk::RelationStorage::AddControlPointToExaminationPeriod(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint, const SemanticTypes::ExaminationPeriod& examinationPeriod)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
 
   // retrieve a vector property that contains the represented control point UIDs of the given examination period
   VectorProperty<std::string>* controlPointUIDsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(examinationPeriod.UID));
   if (nullptr == controlPointUIDsVectorProperty)
   {
     MITK_DEBUG << "Could not find the examination period " << examinationPeriod.UID << " in the storage. Cannot add the control point to the examination period.";
     return;
   }
 
   std::vector<std::string> controlPointUIDsVectorPropertyValue = controlPointUIDsVectorProperty->GetValue();
   // store the control point UID
   controlPointUIDsVectorPropertyValue.push_back(controlPoint.UID);
   // sort the vector according to the date of the control points referenced by the UIDs
   auto lambda = [&caseID](const SemanticTypes::ID& leftControlPointUID, const SemanticTypes::ID& rightControlPointUID)
   {
     const auto& leftControlPoint = GenerateControlpoint(caseID, leftControlPointUID);
     const auto& rightControlPoint = GenerateControlpoint(caseID, rightControlPointUID);
 
     return leftControlPoint.date <= rightControlPoint.date;
   };
 
   std::sort(controlPointUIDsVectorPropertyValue.begin(), controlPointUIDsVectorPropertyValue.end(), lambda);
   // store the modified and sorted control point UID vector of this examination period
   controlPointUIDsVectorProperty->SetValue(controlPointUIDsVectorPropertyValue);
 }
 
 void mitk::RelationStorage::RemoveControlPointFromExaminationPeriod(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint, const SemanticTypes::ExaminationPeriod& examinationPeriod)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
 
   // retrieve a vector property that contains the represented control point UIDs of the given examination period
   VectorProperty<std::string>* controlPointUIDsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(examinationPeriod.UID));
   if (nullptr == controlPointUIDsVectorProperty)
   {
     MITK_DEBUG << "Could not find examination period " << examinationPeriod.UID << " in the storage. Cannot add the control point to the examination period.";
     return;
   }
 
   std::vector<std::string> controlPointUIDsVectorPropertyValue = controlPointUIDsVectorProperty->GetValue();
   // an examination period has an arbitrary number of vector values (name and control point UIDs) (at least one for the name)
   if (controlPointUIDsVectorPropertyValue.size() < 2)
   {
     MITK_DEBUG << "Incorrect examination period storage. At least one (1) control point ID has to be stored.";
     return;
   }
   else
   {
     controlPointUIDsVectorPropertyValue.erase(std::remove(controlPointUIDsVectorPropertyValue.begin(), controlPointUIDsVectorPropertyValue.end(), controlPoint.UID), controlPointUIDsVectorPropertyValue.end());
     if (controlPointUIDsVectorPropertyValue.size() < 2)
     {
-      RemoveExaminationPeriodFromCase(caseID, examinationPeriod);
+      RemoveExaminationPeriod(caseID, examinationPeriod);
     }
     else
     {
       // store the modified vector value
       controlPointUIDsVectorProperty->SetValue(controlPointUIDsVectorPropertyValue);
     }
   }
 }
 
-void mitk::RelationStorage::RemoveExaminationPeriodFromCase(const SemanticTypes::CaseID& caseID, const SemanticTypes::ExaminationPeriod& examinationPeriod)
+void mitk::RelationStorage::RemoveExaminationPeriod(const SemanticTypes::CaseID& caseID, const SemanticTypes::ExaminationPeriod& examinationPeriod)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
   // retrieve a vector property that contains the valid examination period UIDs for the current case
   VectorProperty<std::string>::Pointer examinationPeriodsVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("examinationperiods"));
   if (nullptr == examinationPeriodsVectorProperty)
   {
     MITK_DEBUG << "Could not find any examination periods in the storage.";
     return;
   }
 
   std::vector<std::string> examinationPeriodsVectorPropertyValue = examinationPeriodsVectorProperty->GetValue();
   examinationPeriodsVectorPropertyValue.erase(std::remove(examinationPeriodsVectorPropertyValue.begin(), examinationPeriodsVectorPropertyValue.end(), examinationPeriod.UID), examinationPeriodsVectorPropertyValue.end());
   if (examinationPeriodsVectorPropertyValue.empty())
   {
     // no more examination periods stored -> remove the examination period property list
     propertyList->DeleteProperty("examinationperiods");
   }
   else
   {
     // or store the modified vector value
     examinationPeriodsVectorProperty->SetValue(examinationPeriodsVectorPropertyValue);
   }
+
+  // remove the examination period instance itself
+  propertyList->DeleteProperty(examinationPeriod.UID);
 }
 
 void mitk::RelationStorage::AddInformationTypeToImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID, const SemanticTypes::InformationType& informationType)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
   // retrieve a vector property that contains the valid information types of the current case
   VectorProperty<std::string>::Pointer informationTypesVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("informationtypes"));
   std::vector<std::string> informationTypesVectorPropertyValue;
   if (nullptr == informationTypesVectorProperty)
   {
     informationTypesVectorProperty = VectorProperty<std::string>::New();
   }
   else
   {
     informationTypesVectorPropertyValue = informationTypesVectorProperty->GetValue();
   }
  
   const auto existingInformationType = std::find(informationTypesVectorPropertyValue.begin(), informationTypesVectorPropertyValue.end(), informationType);
   if (existingInformationType == informationTypesVectorPropertyValue.end())
   {
     // at first: add the information type to the storage
     informationTypesVectorPropertyValue.push_back(informationType);
     informationTypesVectorProperty->SetValue(informationTypesVectorPropertyValue);
     propertyList->SetProperty("informationtypes", informationTypesVectorProperty);
   }
 
   // set / overwrite the information type of the given data
   // retrieve a vector property that contains the referenced ID of an image (0. information type 1. control point ID)
   VectorProperty<std::string>* imageVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(imageID));
   if (nullptr == imageVectorProperty)
   {
     MITK_DEBUG << "Could not find the image " << imageID << " in the storage. Cannot add information type to image.";
     return;
   }
 
   std::vector<std::string> imageVectorPropertyValue = imageVectorProperty->GetValue();
   // an image has to have exactly two values (the information type and the ID of the control point)
   if (imageVectorPropertyValue.size() != 2)
   {
     MITK_DEBUG << "Incorrect data storage. Not two (2) values stored.";
     return;
   }
 
   // the first value of the image vector is the information type
   imageVectorPropertyValue[0] = informationType;
   imageVectorProperty->SetValue(imageVectorPropertyValue);
 }
 
 void mitk::RelationStorage::RemoveInformationTypeFromImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
   // retrieve a vector property that contains the referenced ID of an image (0. information type 1. control point ID)
   VectorProperty<std::string>* imageVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty(imageID));
   if (nullptr == imageVectorProperty)
   {
     MITK_DEBUG << "Could not find the image " << imageID << " in the storage. Cannot remove information type from image.";
     return;
   }
 
   std::vector<std::string> imageVectorPropertyValue = imageVectorProperty->GetValue();
   // an image has to have exactly two values (the information type and the ID of the control point)
   if (imageVectorPropertyValue.size() != 2)
   {
     MITK_DEBUG << "Incorrect data storage. Not two (2) values stored.";
     return;
   }
 
   // the first value of the image vector is the information type
   // set the information type to an empty string for removal
   imageVectorPropertyValue[0] = "";
   imageVectorProperty->SetValue(imageVectorPropertyValue);
 }
 
-void mitk::RelationStorage::RemoveInformationTypeFromCase(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType)
+void mitk::RelationStorage::RemoveInformationType(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType)
 {
   PropertyList::Pointer propertyList = GetStorageData(caseID);
   if (nullptr == propertyList)
   {
     MITK_DEBUG << "Could not find the property list " << caseID << " for the current MITK workbench / session.";
     return;
   }
   // retrieve a vector property that contains the valid information types of the current case
   VectorProperty<std::string>* informationTypesVectorProperty = dynamic_cast<VectorProperty<std::string>*>(propertyList->GetProperty("informationtypes"));
   if (nullptr == informationTypesVectorProperty)
   {
     MITK_DEBUG << "Could not find any information type in the storage.";
     return;
   }
 
   std::vector<std::string> informationTypesVectorPropertyValue = informationTypesVectorProperty->GetValue();
   informationTypesVectorPropertyValue.erase(std::remove(informationTypesVectorPropertyValue.begin(), informationTypesVectorPropertyValue.end(), informationType), informationTypesVectorPropertyValue.end());
   if (informationTypesVectorPropertyValue.empty())
   {
     // no more information types stored -> remove the information types property list
     propertyList->DeleteProperty("informationtypes");
   }
   else
   {
     // or store the modified vector value
     informationTypesVectorProperty->SetValue(informationTypesVectorPropertyValue);
   }
 }
diff --git a/Modules/SemanticRelations/src/mitkSemanticRelationsDataStorageAccess.cpp b/Modules/SemanticRelations/src/mitkSemanticRelationsDataStorageAccess.cpp
index b02e89d69e..e020f5706b 100644
--- a/Modules/SemanticRelations/src/mitkSemanticRelationsDataStorageAccess.cpp
+++ b/Modules/SemanticRelations/src/mitkSemanticRelationsDataStorageAccess.cpp
@@ -1,218 +1,236 @@
 /*===================================================================
 
 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 "mitkSemanticRelationsDataStorageAccess.h"
 
 // semantic relations module
 #include "mitkControlPointManager.h"
 #include "mitkDICOMHelper.h"
 #include "mitkNodePredicates.h"
 #include "mitkRelationStorage.h"
 #include "mitkSemanticRelationException.h"
 #include "mitkSemanticRelationsInference.h"
 
 // c++
 #include <iterator>
 #include <algorithm>
 
 mitk::SemanticRelationsDataStorageAccess::SemanticRelationsDataStorageAccess(DataStorage* dataStorage)
   : m_DataStorage(dataStorage)
 {
   // nothing here
 }
 
 mitk::SemanticRelationsDataStorageAccess::~SemanticRelationsDataStorageAccess()
 {
   // nothing here
 }
 
 /************************************************************************/
 /* functions to get instances / attributes                              */
 /************************************************************************/
 
 mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllSegmentationsOfCase(const SemanticTypes::CaseID& caseID) const
 {
   if (m_DataStorage.IsExpired())
   {
     mitkThrowException(SemanticRelationException) << "Not a valid data storage.";
   }
 
   std::vector<std::string> allSegmentationIDsOfCase = RelationStorage::GetAllSegmentationIDsOfCase(caseID);
   std::vector<DataNode::Pointer> allSegmentationsOfCase;
   // get all segmentation nodes of the current data storage
   // only those nodes are respected, that are currently held in the data storage
   DataStorage::SetOfObjects::ConstPointer segmentationNodes = m_DataStorage.Lock()->GetSubset(NodePredicates::GetSegmentationPredicate());
   for (auto it = segmentationNodes->Begin(); it != segmentationNodes->End(); ++it)
   {
     DataNode* segmentationNode = it->Value();
+
+    std::string caseID;
+    std::string segmentationID;
     try
     {
       // find the corresponding segmentation node for the given segmentation ID
-      std::string nodeCaseID = GetCaseIDFromDataNode(segmentationNode);
-      std::string nodeSegmentationID = GetIDFromDataNode(segmentationNode);
-      if (nodeCaseID == caseID && (std::find(allSegmentationIDsOfCase.begin(), allSegmentationIDsOfCase.end(), nodeSegmentationID) != allSegmentationIDsOfCase.end()))
-      {
-        // found current image node in the storage, add it to the return vector
-        allSegmentationsOfCase.push_back(segmentationNode);
-      }
+      caseID = GetCaseIDFromDataNode(segmentationNode);
+      segmentationID = GetIDFromDataNode(segmentationNode);
     }
-    catch (const std::exception&)
+    catch (SemanticRelationException&)
     {
       // found a segmentation node that is not stored in the semantic relations
       // this segmentation node does not have any DICOM information --> exception thrown
       // continue with the next segmentation to compare IDs
       continue;
     }
+
+    if (caseID == caseID && (std::find(allSegmentationIDsOfCase.begin(), allSegmentationIDsOfCase.end(), segmentationID) != allSegmentationIDsOfCase.end()))
+    {
+      // found current image node in the storage, add it to the return vector
+      allSegmentationsOfCase.push_back(segmentationNode);
+    }
   }
 
   return allSegmentationsOfCase;
 }
 
 mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllSegmentationsOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion) const
 {
   if (SemanticRelationsInference::InstanceExists(caseID, lesion))
   {
     // lesion exists, retrieve all case segmentations from the storage
     DataNodeVector allSegmentationsOfLesion = GetAllSegmentationsOfCase(caseID);
 
     // filter all segmentations: check for semantic relation with the given lesion using a lambda function
     auto lambda = [&lesion, this](DataNode::Pointer segmentation)
     {
       try
       {
         SemanticTypes::Lesion representedLesion = SemanticRelationsInference::GetLesionOfSegmentation(segmentation);
         return lesion.UID != representedLesion.UID;
       }
       catch (const SemanticRelationException&)
       {
         return true;
       }
     };
     allSegmentationsOfLesion.erase(std::remove_if(allSegmentationsOfLesion.begin(), allSegmentationsOfLesion.end(), lambda), allSegmentationsOfLesion.end());
 
     return allSegmentationsOfLesion;
   }
   else
   {
     mitkThrowException(SemanticRelationException) << "Could not find an existing lesion instance for the given caseID " << caseID << " and lesion " << lesion.UID << ".";
   }
 }
 
 mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllImagesOfCase(const SemanticTypes::CaseID& caseID) const
 {
   if (m_DataStorage.IsExpired())
   {
     mitkThrowException(SemanticRelationException) << "Not a valid data storage.";
   }
 
   std::vector<std::string> allImageIDsOfCase = RelationStorage::GetAllImageIDsOfCase(caseID);
   std::vector<DataNode::Pointer> allImagesOfCase;
   // get all image nodes of the current data storage
   // only those nodes are respected, that are currently held in the data storage
   DataStorage::SetOfObjects::ConstPointer imageNodes = m_DataStorage.Lock()->GetSubset(NodePredicates::GetImagePredicate());
   for (auto it = imageNodes->Begin(); it != imageNodes->End(); ++it)
   {
     DataNode* imageNode = it->Value();
-    // find the corresponding image node for the given segmentation ID
-    std::string nodeCaseID = GetCaseIDFromDataNode(imageNode);
-    std::string nodeImageID = GetIDFromDataNode(imageNode);
-    if (nodeCaseID == caseID && (std::find(allImageIDsOfCase.begin(), allImageIDsOfCase.end(), nodeImageID) != allImageIDsOfCase.end()))
+
+    std::string caseID;
+    std::string imageID;
+    try
+    {
+      // find the corresponding image node for the given segmentation ID
+      caseID = GetCaseIDFromDataNode(imageNode);
+      imageID = GetIDFromDataNode(imageNode);
+    }
+    catch (SemanticRelationException&)
+    {
+      // found an image node that is not stored in the semantic relations
+      // this image node does not have any DICOM information --> exception thrown
+      // continue with the next image to compare IDs
+      continue;
+    }
+
+    if (caseID == caseID && (std::find(allImageIDsOfCase.begin(), allImageIDsOfCase.end(), imageID) != allImageIDsOfCase.end()))
     {
       // found current image node in the storage, add it to the return vector
       allImagesOfCase.push_back(imageNode);
     }
   }
 
   return allImagesOfCase;
 }
 
 mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllImagesOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion) const
 {
   if (m_DataStorage.IsExpired())
   {
     mitkThrowException(SemanticRelationException) << "Not a valid data storage.";
   }
 
   DataNodeVector allImagesOfLesion;
   // 1. get all segmentations that define the lesion
   // 2. retrieve the parent node (source) of the found segmentation node
   DataNodeVector allSegmentationsOfLesion = GetAllSegmentationsOfLesion(caseID, lesion);
   for (const auto& segmentationNode : allSegmentationsOfLesion)
   {
     // get parent node of the current segmentation node with the node predicate
     DataStorage::SetOfObjects::ConstPointer parentNodes = m_DataStorage.Lock()->GetSources(segmentationNode, NodePredicates::GetImagePredicate(), false);
     for (auto it = parentNodes->Begin(); it != parentNodes->End(); ++it)
     {
       DataNode::Pointer dataNode = it->Value();
       allImagesOfLesion.push_back(it->Value());
     }
   }
 
   std::sort(allImagesOfLesion.begin(), allImagesOfLesion.end());
   allImagesOfLesion.erase(std::unique(allImagesOfLesion.begin(), allImagesOfLesion.end()), allImagesOfLesion.end());
   return allImagesOfLesion;
 }
 
 mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllSpecificImages(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint, const SemanticTypes::InformationType& informationType) const
 {
   if (SemanticRelationsInference::InstanceExists(caseID, controlPoint))
   {
     if (SemanticRelationsInference::InstanceExists(caseID, informationType))
     {
       // control point exists, information type exists, retrieve all images from the storage
       DataNodeVector allImagesOfCase = GetAllImagesOfCase(caseID);
       // filter all images to remove the ones with a different control point and information type using a lambda function
       auto lambda = [&controlPoint, &informationType, this](DataNode::Pointer imageNode)
       {
         return (informationType != SemanticRelationsInference::GetInformationTypeOfImage(imageNode))
             || (controlPoint.date != SemanticRelationsInference::GetControlPointOfImage(imageNode).date);
       };
 
       allImagesOfCase.erase(std::remove_if(allImagesOfCase.begin(), allImagesOfCase.end(), lambda), allImagesOfCase.end());
 
       return allImagesOfCase;
     }
     else
     {
       mitkThrowException(SemanticRelationException) << "Could not find an existing information type for the given caseID " << caseID << " and information type " << informationType;
     }
   }
   else
   {
     mitkThrowException(SemanticRelationException) << "Could not find an existing control point for the given caseID " << caseID << " and control point " << controlPoint.UID;
   }
 }
 
 mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllSpecificSegmentations(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint, const SemanticTypes::InformationType& informationType) const
 {
   if (m_DataStorage.IsExpired())
   {
     mitkThrow() << "Not a valid data storage.";
   }
 
   DataNodeVector allSpecificImages = GetAllSpecificImages(caseID, controlPoint, informationType);
   DataNodeVector allSpecificSegmentations;
   for (const auto& imageNode : allSpecificImages)
   {
     DataStorage::SetOfObjects::ConstPointer segmentationNodes = m_DataStorage.Lock()->GetDerivations(imageNode, NodePredicates::GetSegmentationPredicate(), false);
     for (auto it = segmentationNodes->Begin(); it != segmentationNodes->End(); ++it)
     {
       allSpecificSegmentations.push_back(it->Value());
     }
   }
 
   return allSpecificSegmentations;
 }
diff --git a/Modules/SemanticRelations/src/mitkSemanticRelationsInference.cpp b/Modules/SemanticRelations/src/mitkSemanticRelationsInference.cpp
index 3e6174fc76..21dfdb3301 100644
--- a/Modules/SemanticRelations/src/mitkSemanticRelationsInference.cpp
+++ b/Modules/SemanticRelations/src/mitkSemanticRelationsInference.cpp
@@ -1,561 +1,528 @@
 /*===================================================================
 
 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 "mitkSemanticRelationsInference.h"
 
 // semantic relations module
 #include "mitkControlPointManager.h"
 #include "mitkDICOMHelper.h"
 #include "mitkNodePredicates.h"
 #include "mitkRelationStorage.h"
 #include "mitkSemanticRelationException.h"
 
 /************************************************************************/
 /* functions to get instances / attributes                              */
 /************************************************************************/
 
 mitk::SemanticTypes::LesionClassVector mitk::SemanticRelationsInference::GetAllLesionClassesOfCase(const SemanticTypes::CaseID& caseID)
 {
   SemanticTypes::LesionVector allLesionsOfCase = RelationStorage::GetAllLesionsOfCase(caseID);
   SemanticTypes::LesionClassVector allLesionClassesOfCase;
 
   for (const auto& lesion : allLesionsOfCase)
   {
     allLesionClassesOfCase.push_back(lesion.lesionClass);
   }
 
   // remove duplicate entries
   auto lessThan = [](const SemanticTypes::LesionClass& lesionClassLeft, const SemanticTypes::LesionClass& lesionClassRight)
   {
     return lesionClassLeft.UID < lesionClassRight.UID;
   };
 
   auto equal = [](const SemanticTypes::LesionClass& lesionClassLeft, const SemanticTypes::LesionClass& lesionClassRight)
   {
     return lesionClassLeft.UID == lesionClassRight.UID;
   };
 
   std::sort(allLesionClassesOfCase.begin(), allLesionClassesOfCase.end(), lessThan);
   allLesionClassesOfCase.erase(std::unique(allLesionClassesOfCase.begin(), allLesionClassesOfCase.end(), equal), allLesionClassesOfCase.end());
 
   return allLesionClassesOfCase;
 }
 
 mitk::SemanticTypes::Lesion mitk::SemanticRelationsInference::GetLesionOfSegmentation(const DataNode* segmentationNode)
 {
   if (nullptr == segmentationNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid segmentation data node.";
   }
 
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(segmentationNode);
-  SemanticTypes::ID segmentationID = GetIDFromDataNode(segmentationNode);
+  SemanticTypes::CaseID caseID = "";
+  SemanticTypes::ID segmentationID = "";
+  try
+  {
+    caseID = GetCaseIDFromDataNode(segmentationNode);
+    segmentationID = GetIDFromDataNode(segmentationNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot get the lesion of the given segmentation data node.";
+  }
+
   return RelationStorage::GetLesionOfSegmentation(caseID, segmentationID);
 }
 
 mitk::SemanticTypes::LesionVector mitk::SemanticRelationsInference::GetAllLesionsOfImage(const DataNode* imageNode)
 {
   if (nullptr == imageNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid image data node.";
   }
 
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(imageNode);
-  SemanticTypes::ID imageID = GetIDFromDataNode(imageNode);
+  SemanticTypes::CaseID caseID = "";
+  SemanticTypes::ID imageID = "";
+  try
+  {
+    caseID = GetCaseIDFromDataNode(imageNode);
+    imageID = GetIDFromDataNode(imageNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot get all lesions of the given image data node.";
+  }
 
   SemanticTypes::LesionVector allLesionsOfImage;
   // 1. get all segmentations that are connected to the given image
   // 2. get the lesion of each segmentation
   // 3. guarantee uniqueness of lesions
   SemanticTypes::IDVector allSegmentationIDsOfImage = RelationStorage::GetAllSegmentationIDsOfImage(caseID, imageID);
   for (const auto& segmentationID : allSegmentationIDsOfImage)
   {
     // get represented lesion of the current segmentation
     SemanticTypes::Lesion representedLesion = RelationStorage::GetLesionOfSegmentation(caseID, segmentationID);
     if (!representedLesion.UID.empty())
     {
       allLesionsOfImage.push_back(representedLesion);
     }
   }
 
   // remove duplicate entries
   auto lessThan = [](const SemanticTypes::Lesion& lesionLeft, const SemanticTypes::Lesion& lesionRight)
   {
     return lesionLeft.UID < lesionRight.UID;
   };
 
   auto equal = [](const SemanticTypes::Lesion& lesionLeft, const SemanticTypes::Lesion& lesionRight)
   {
     return lesionLeft.UID == lesionRight.UID;
   };
 
   std::sort(allLesionsOfImage.begin(), allLesionsOfImage.end(), lessThan);
   allLesionsOfImage.erase(std::unique(allLesionsOfImage.begin(), allLesionsOfImage.end(), equal), allLesionsOfImage.end());
 
   return allLesionsOfImage;
 }
 
 mitk::SemanticTypes::LesionVector mitk::SemanticRelationsInference::GetAllLesionsOfControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint)
 {
   SemanticTypes::LesionVector allLesions = RelationStorage::GetAllLesionsOfCase(caseID);
 
   // filter the lesions: use only those, where the associated data is connected to image data that refers to the given control point using a lambda function
   auto lambda = [&caseID, &controlPoint](const SemanticTypes::Lesion& lesion)
   {
     return !SpecificImageExists(caseID, lesion, controlPoint);
   };
 
   allLesions.erase(std::remove_if(allLesions.begin(), allLesions.end(), lambda), allLesions.end());
 
   return allLesions;
 }
 
 bool mitk::SemanticRelationsInference::IsRepresentingALesion(const DataNode* segmentationNode)
 {
+  SemanticTypes::Lesion representedLesion;
   try
   {
-    SemanticTypes::Lesion representedLesion = GetLesionOfSegmentation(segmentationNode);
-    if (representedLesion.UID.empty())
-    {
-      return false;
-    }
+    representedLesion = GetLesionOfSegmentation(segmentationNode);
   }
-  catch (const Exception&)
+  catch (const SemanticRelationException&)
   {
     return false;
   }
 
-  return true;
+  return !representedLesion.UID.empty();
 }
 
 bool mitk::SemanticRelationsInference::IsRepresentingALesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& segmentationID)
 {
   SemanticTypes::Lesion representedLesion = RelationStorage::GetLesionOfSegmentation(caseID, segmentationID);
-  if (representedLesion.UID.empty())
-  {
-    return false;
-  }
-
-  return true;
+  return !representedLesion.UID.empty();
 }
 
 bool mitk::SemanticRelationsInference::IsLesionPresent(const SemanticTypes::Lesion& lesion, const DataNode* dataNode)
 {
+  SemanticTypes::CaseID caseID = "";
+  SemanticTypes::ID dataNodeID = "";
   try
   {
-    SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(dataNode);
-    SemanticTypes::ID dataNodeID = GetIDFromDataNode(dataNode);
-
-    if (NodePredicates::GetImagePredicate()->CheckNode(dataNode))
-    {
-      return IsLesionPresentOnImage(caseID, lesion, dataNodeID);
-    }
-
-    if (NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
-    {
-      return IsLesionPresentOnSegmentation(caseID, lesion, dataNodeID);
-    }
-
-    return false;
+    caseID = GetCaseIDFromDataNode(dataNode);
+    dataNodeID = GetIDFromDataNode(dataNode);
   }
   catch (const SemanticRelationException&)
   {
     return false;
   }
+
+  if (NodePredicates::GetImagePredicate()->CheckNode(dataNode))
+  {
+    return IsLesionPresentOnImage(caseID, lesion, dataNodeID);
+  }
+
+  if (NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
+  {
+    return IsLesionPresentOnSegmentation(caseID, lesion, dataNodeID);
+  }
+
+  return false;
 }
 
 bool mitk::SemanticRelationsInference::IsLesionPresentOnImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion, const SemanticTypes::ID& imageID)
 {
-  SemanticTypes::IDVector allImageIDsOfLesion = GetAllImageIDsOfLesion(caseID, lesion);
+  SemanticTypes::IDVector allImageIDsOfLesion;
+  try
+  {
+    allImageIDsOfLesion = GetAllImageIDsOfLesion(caseID, lesion);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot get all image IDs of the given lesion to determine the lesion presence.";
+  }
+
   for (const auto& imageIDOfLesion : allImageIDsOfLesion)
   {
     if (imageIDOfLesion == imageID)
     {
       return true;
     }
   }
 
   return false;
 }
 
 bool mitk::SemanticRelationsInference::IsLesionPresentOnSegmentation(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion, const SemanticTypes::ID& segmentationID)
 {
   const auto representedLesion = RelationStorage::GetLesionOfSegmentation(caseID, segmentationID);
   return lesion.UID == representedLesion.UID;
 }
 
 bool mitk::SemanticRelationsInference::IsLesionPresentAtControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion, const SemanticTypes::ControlPoint& controlPoint)
 {
-  SemanticTypes::IDVector allImageIDsOfLesion = GetAllImageIDsOfLesion(caseID, lesion);
-  for (const auto& imageID : allImageIDsOfLesion)
+  SemanticTypes::IDVector allImageIDsOfLesion;
+  try
   {
-    auto imageControlPoint = mitk::RelationStorage::GetControlPointOfImage(caseID, imageID);
+    allImageIDsOfLesion = GetAllImageIDsOfLesion(caseID, lesion);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot get all image IDs of the given lesion to determine the lesion presence.";
+  }
+
+  for (const auto& imageIDOfLesion : allImageIDsOfLesion)
+  {
+    auto imageControlPoint = mitk::RelationStorage::GetControlPointOfImage(caseID, imageIDOfLesion);
     if (imageControlPoint.date == controlPoint.date)
     {
       return true;
     }
   }
 
   return false;
 }
 
 bool mitk::SemanticRelationsInference::InstanceExists(const DataNode* dataNode)
 {
+  SemanticTypes::CaseID caseID = "";
+  SemanticTypes::ID dataNodeID = "";
   try
   {
-    SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(dataNode);
-    SemanticTypes::ID dataNodeID = GetIDFromDataNode(dataNode);
-
-    if (NodePredicates::GetImagePredicate()->CheckNode(dataNode))
-    {
-      std::vector<std::string> allImageIDsOfCase = RelationStorage::GetAllImageIDsOfCase(caseID);
-      return std::find(allImageIDsOfCase.begin(), allImageIDsOfCase.end(), dataNodeID) != allImageIDsOfCase.end();
-    }
-    else if (NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
-    {
-      std::vector<std::string> allSegmentationIDsOfCase = RelationStorage::GetAllSegmentationIDsOfCase(caseID);
-      return std::find(allSegmentationIDsOfCase.begin(), allSegmentationIDsOfCase.end(), dataNodeID) != allSegmentationIDsOfCase.end();
-    }
-    else
-    {
-      return false;
-    }
+    caseID = GetCaseIDFromDataNode(dataNode);
+    dataNodeID = GetIDFromDataNode(dataNode);
   }
   catch (const SemanticRelationException&)
   {
     return false;
   }
+
+  if (NodePredicates::GetImagePredicate()->CheckNode(dataNode))
+  {
+    std::vector<std::string> allImageIDsOfCase = RelationStorage::GetAllImageIDsOfCase(caseID);
+    return std::find(allImageIDsOfCase.begin(), allImageIDsOfCase.end(), dataNodeID) != allImageIDsOfCase.end();
+  }
+
+  if (NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
+  {
+    std::vector<std::string> allSegmentationIDsOfCase = RelationStorage::GetAllSegmentationIDsOfCase(caseID);
+    return std::find(allSegmentationIDsOfCase.begin(), allSegmentationIDsOfCase.end(), dataNodeID) != allSegmentationIDsOfCase.end();
+  }
+
+  return false;
 }
 
 bool mitk::SemanticRelationsInference::InstanceExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion)
 {
   SemanticTypes::LesionVector allLesions = RelationStorage::GetAllLesionsOfCase(caseID);
 
   // filter all lesions: check for equality with the given lesion using a lambda function
-  auto lambda = [&lesion](const SemanticTypes::Lesion& currentLesion) { return currentLesion.UID == lesion.UID; };
+  auto lambda = [&lesion](const SemanticTypes::Lesion& currentLesion)
+  {
+    return currentLesion.UID == lesion.UID;
+  };
+
   const auto existingLesion = std::find_if(allLesions.begin(), allLesions.end(), lambda);
 
-  if (existingLesion != allLesions.end())
-  {
-    return true;
-  }
-  else
-  {
-    return false;
-  }
+  return existingLesion != allLesions.end();
 }
 
 mitk::SemanticTypes::IDVector mitk::SemanticRelationsInference::GetAllImageIDsOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion)
 {
   if (!InstanceExists(caseID, lesion))
   {
     mitkThrowException(SemanticRelationException) << "Could not find an existing lesion instance for the given caseID " << caseID << " and lesion " << lesion.UID << ".";
   }
 
   SemanticTypes::IDVector allImageIDsOfLesion;
   // 1. get all segmentations that define the lesion
   // 2. get the parentID (imageID) of each segmentation
   // 3. guarantee uniqueness of image IDs
-  SemanticTypes::IDVector allSegmentationIDsOfLesion = GetAllSegmentationIDsOfLesion(caseID, lesion);
+  SemanticTypes::IDVector allSegmentationIDsOfLesion = RelationStorage::GetAllSegmentationIDsOfLesion(caseID, lesion);
   for (const auto& segmentationID : allSegmentationIDsOfLesion)
   {
     // get parent ID of the current segmentation ID
     SemanticTypes::ID imageID = RelationStorage::GetImageIDOfSegmentation(caseID, segmentationID);
     if(!imageID.empty())
     {
       allImageIDsOfLesion.push_back(imageID);
     }
   }
 
   std::sort(allImageIDsOfLesion.begin(), allImageIDsOfLesion.end());
   allImageIDsOfLesion.erase(std::unique(allImageIDsOfLesion.begin(), allImageIDsOfLesion.end()), allImageIDsOfLesion.end());
 
   return allImageIDsOfLesion;
 }
 
-mitk::SemanticTypes::IDVector mitk::SemanticRelationsInference::GetAllSegmentationIDsOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion)
+mitk::SemanticTypes::ControlPoint mitk::SemanticRelationsInference::GetControlPointOfImage(const DataNode* imageNode)
 {
-  if (!InstanceExists(caseID, lesion))
+  if (nullptr == imageNode)
   {
-    mitkThrowException(SemanticRelationException) << "Could not find an existing lesion instance for the given caseID " << caseID << " and lesion " << lesion.UID << ".";
+    mitkThrowException(SemanticRelationException) << "Not a valid data node.";
   }
 
-  // lesion exists, retrieve all case segmentations from the storage
-  SemanticTypes::IDVector allSegmentationIDs = RelationStorage::GetAllSegmentationIDsOfCase(caseID);
-
-  // filter all segmentationIDs: check for semantic relation with the given lesion using a lambda function
-  auto lambda = [&lesion, caseID](const SemanticTypes::ID& segmentationID)
+  SemanticTypes::CaseID caseID = "";
+  SemanticTypes::ID imageID = "";
+  try
   {
-    SemanticTypes::Lesion representedLesion = RelationStorage::GetLesionOfSegmentation(caseID, segmentationID);
-    return lesion.UID != representedLesion.UID;
-  };
-
-  allSegmentationIDs.erase(std::remove_if(allSegmentationIDs.begin(), allSegmentationIDs.end(), lambda), allSegmentationIDs.end());
-
-  return allSegmentationIDs;
-}
-
-mitk::SemanticTypes::ControlPoint mitk::SemanticRelationsInference::GetControlPointOfImage(const DataNode* imageNode)
-{
-  if (nullptr == imageNode)
+    caseID = GetCaseIDFromDataNode(imageNode);
+    imageID = GetIDFromDataNode(imageNode);
+  }
+  catch (SemanticRelationException& e)
   {
-    mitkThrowException(SemanticRelationException) << "Not a valid data node.";
+    mitkReThrow(e) << "Cannot get the control point of the given image data node.";
   }
 
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(imageNode);
-  SemanticTypes::ID dataNodeID = GetIDFromDataNode(imageNode);
-  return RelationStorage::GetControlPointOfImage(caseID, dataNodeID);
+  return RelationStorage::GetControlPointOfImage(caseID, imageID);
 }
 
 mitk::SemanticTypes::ControlPointVector mitk::SemanticRelationsInference::GetAllControlPointsOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion)
 {
   SemanticTypes::ControlPointVector allControlPoints = RelationStorage::GetAllControlPointsOfCase(caseID);
 
   // filter the control points: use only those, where the associated image data has a segmentation that refers to the given lesion using a lambda function
   auto lambda = [&caseID, &lesion](const SemanticTypes::ControlPoint& controlPoint)
   {
     return !SpecificImageExists(caseID, lesion, controlPoint);
   };
 
   allControlPoints.erase(std::remove_if(allControlPoints.begin(), allControlPoints.end(), lambda), allControlPoints.end());
 
   return allControlPoints;
 }
 
 mitk::SemanticTypes::ControlPointVector mitk::SemanticRelationsInference::GetAllControlPointsOfInformationType(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType)
 {
   SemanticTypes::ControlPointVector allControlPoints = RelationStorage::GetAllControlPointsOfCase(caseID);
 
   // filter the control points: use only those, where the associated image data refers to the given information type using a lambda function
   auto lambda = [&caseID, &informationType](const SemanticTypes::ControlPoint& controlPoint)
   {
     return !SpecificImageExists(caseID, informationType, controlPoint);
   };
 
   allControlPoints.erase(std::remove_if(allControlPoints.begin(), allControlPoints.end(), lambda), allControlPoints.end());
 
   return allControlPoints;
 }
 
 bool mitk::SemanticRelationsInference::InstanceExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint)
 {
   SemanticTypes::ControlPointVector allControlPoints = RelationStorage::GetAllControlPointsOfCase(caseID);
 
   // filter all control points: check for equality with the given control point using a lambda function
   auto lambda = [&controlPoint](const SemanticTypes::ControlPoint& currentControlPoint) { return currentControlPoint.UID == controlPoint.UID; };
   const auto existingControlPoint = std::find_if(allControlPoints.begin(), allControlPoints.end(), lambda);
 
   if (existingControlPoint != allControlPoints.end())
   {
     return true;
   }
   else
   {
     return false;
   }
 }
 
-mitk::SemanticTypes::ExaminationPeriodVector mitk::SemanticRelationsInference::GetAllExaminationPeriodsOfCase(const SemanticTypes::CaseID& caseID)
-{
-  return RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
-}
-
 bool mitk::SemanticRelationsInference::InstanceExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::ExaminationPeriod& examinationPeriod)
 {
-  SemanticTypes::ExaminationPeriodVector allExaminationPeriods = GetAllExaminationPeriodsOfCase(caseID);
+  SemanticTypes::ExaminationPeriodVector allExaminationPeriods = RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
 
   // filter all examination periods: check for equality with the given examination period using a lambda function
   auto lambda = [&examinationPeriod](const SemanticTypes::ExaminationPeriod& currentExaminationPeriod) { return currentExaminationPeriod.UID == examinationPeriod.UID; };
   const auto existingExaminationPeriod = std::find_if(allExaminationPeriods.begin(), allExaminationPeriods.end(), lambda);
 
   if (existingExaminationPeriod != allExaminationPeriods.end())
   {
     return true;
   }
   else
   {
     return false;
   }
 }
 
 mitk::SemanticTypes::InformationType mitk::SemanticRelationsInference::GetInformationTypeOfImage(const DataNode* imageNode)
 {
   if (nullptr == imageNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid image data node.";
   }
 
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(imageNode);
-  SemanticTypes::ID imageID = GetIDFromDataNode(imageNode);
-  return GetInformationTypeOfImage(caseID, imageID);
-}
+  SemanticTypes::CaseID caseID = "";
+  SemanticTypes::ID imageID = "";
+  try
+  {
+    caseID = GetCaseIDFromDataNode(imageNode);
+    imageID = GetIDFromDataNode(imageNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot get the information type of the given image data node.";
+  }
 
-mitk::SemanticTypes::InformationType mitk::SemanticRelationsInference::GetInformationTypeOfImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& imageID)
-{
   return RelationStorage::GetInformationTypeOfImage(caseID, imageID);
 }
 
 mitk::SemanticTypes::InformationTypeVector mitk::SemanticRelationsInference::GetAllInformationTypesOfControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint)
 {
   SemanticTypes::InformationTypeVector allInformationTypes = RelationStorage::GetAllInformationTypesOfCase(caseID);
 
   // filter the information types: use only those, where the associated data refers to the given control point using a lambda function
   auto lambda = [&caseID, &controlPoint](const SemanticTypes::InformationType& informationType)
   {
     return !SpecificImageExists(caseID, informationType, controlPoint);
   };
 
   allInformationTypes.erase(std::remove_if(allInformationTypes.begin(), allInformationTypes.end(), lambda), allInformationTypes.end());
 
   return allInformationTypes;
 }
 
-mitk::SemanticTypes::IDVector mitk::SemanticRelationsInference::GetAllImageIDsOfInformationType(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType)
-{
-  if (InstanceExists(caseID, informationType))
-  {
-    mitkThrowException(SemanticRelationException) << "Could not find an existing information type for the given caseID " << caseID << " and information type " << informationType;
-  }
-
-  // information type exists, retrieve all imageIDs from the storage
-  SemanticTypes::IDVector allImageIDs = RelationStorage::GetAllImageIDsOfCase(caseID);
-
-  // filter all images to remove the ones with a different information type using a lambda function
-  auto lambda = [&informationType, caseID](const SemanticTypes::ID& imageID)
-  {
-    return informationType != RelationStorage::GetInformationTypeOfImage(caseID, imageID);
-  };
-
-  allImageIDs.erase(std::remove_if(allImageIDs.begin(), allImageIDs.end(), lambda), allImageIDs.end());
-
-  return allImageIDs;
-}
-
 bool mitk::SemanticRelationsInference::InstanceExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType)
 {
   SemanticTypes::InformationTypeVector allInformationTypes = RelationStorage::GetAllInformationTypesOfCase(caseID);
 
   // filter all information types: check for equality with the given information type using a lambda function
   auto lambda = [&informationType](const SemanticTypes::InformationType& currentInformationType) { return currentInformationType == informationType; };
   const auto existingInformationType = std::find_if(allInformationTypes.begin(), allInformationTypes.end(), lambda);
 
   if (existingInformationType != allInformationTypes.end())
   {
     return true;
   }
   else
   {
     return false;
   }
 }
 
 bool mitk::SemanticRelationsInference::SpecificImageExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion, const SemanticTypes::InformationType& informationType)
 {
   SemanticTypes::IDVector allImageIDsOfLesion;
   try
   {
     allImageIDsOfLesion = GetAllImageIDsOfLesion(caseID, lesion);
   }
   catch (const SemanticRelationException&)
   {
     return false;
   }
 
   SemanticTypes::IDVector allImageIDsOfInformationType = RelationStorage::GetAllImageIDsOfInformationType(caseID, informationType);
 
   std::sort(allImageIDsOfLesion.begin(), allImageIDsOfLesion.end());
   std::sort(allImageIDsOfInformationType.begin(), allImageIDsOfInformationType.end());
   SemanticTypes::IDVector allImageIDsIntersection;
   // set_intersection removes duplicated nodes, since 'GetAllImageIDsOfInformationType' only contains at most one of each node
   std::set_intersection(allImageIDsOfLesion.begin(), allImageIDsOfLesion.end(),
     allImageIDsOfInformationType.begin(), allImageIDsOfInformationType.end(),
     std::back_inserter(allImageIDsIntersection));
 
   // if the vector of intersecting image IDs is empty, the information type does not contain the lesion
   return !allImageIDsIntersection.empty();
 }
 
 bool mitk::SemanticRelationsInference::SpecificImageExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion, const SemanticTypes::ControlPoint& controlPoint)
 {
   SemanticTypes::IDVector allImageIDsOfLesion;
   try
   {
     allImageIDsOfLesion = GetAllImageIDsOfLesion(caseID, lesion);
   }
   catch (const SemanticRelationException&)
   {
     return false;
   }
 
   SemanticTypes::IDVector allImageIDsOfControlPoint = RelationStorage::GetAllImageIDsOfControlPoint(caseID, controlPoint);
 
   std::sort(allImageIDsOfLesion.begin(), allImageIDsOfLesion.end());
   std::sort(allImageIDsOfControlPoint.begin(), allImageIDsOfControlPoint.end());
   SemanticTypes::IDVector allImageIDsIntersection;
   // set_intersection removes duplicated nodes, since 'GetAllImageIDsOfControlPoint' only contains at most one of each node
   std::set_intersection(allImageIDsOfLesion.begin(), allImageIDsOfLesion.end(),
     allImageIDsOfControlPoint.begin(), allImageIDsOfControlPoint.end(),
     std::back_inserter(allImageIDsIntersection));
 
   // if the vector of intersecting image IDs is empty, the control point does not contain the lesion
   return !allImageIDsIntersection.empty();
 }
 
 bool mitk::SemanticRelationsInference::SpecificImageExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType, const SemanticTypes::ControlPoint& controlPoint)
 {
   SemanticTypes::IDVector allImageIDsOfInformationType = RelationStorage::GetAllImageIDsOfInformationType(caseID, informationType);
   SemanticTypes::IDVector allImageIDsOfControlPoint = RelationStorage::GetAllImageIDsOfControlPoint(caseID, controlPoint);
 
   std::sort(allImageIDsOfInformationType.begin(), allImageIDsOfInformationType.end());
   std::sort(allImageIDsOfControlPoint.begin(), allImageIDsOfControlPoint.end());
   SemanticTypes::IDVector allImageIDsIntersection;
   // set_intersection removes duplicated nodes
   std::set_intersection(allImageIDsOfInformationType.begin(), allImageIDsOfInformationType.end(),
     allImageIDsOfControlPoint.begin(), allImageIDsOfControlPoint.end(),
     std::back_inserter(allImageIDsIntersection));
 
   // if the vector of intersecting image IDs is empty no image exists for the given information type and control point
   return !allImageIDsIntersection.empty();
 }
-
-void mitk::SemanticRelationsInference::ClearControlPoints(const SemanticTypes::CaseID& caseID)
-{
-  SemanticTypes::ControlPointVector allControlPointsOfCase = RelationStorage::GetAllControlPointsOfCase(caseID);
-
-  std::vector<std::string> allImageIDsVectorValue = RelationStorage::GetAllImageIDsOfCase(caseID);
-  SemanticTypes::ControlPointVector referencedControlPoints;
-  for (const auto& imageID : allImageIDsVectorValue)
-  {
-    auto controlPointOfImage = RelationStorage::GetControlPointOfImage(caseID, imageID);
-    referencedControlPoints.push_back(controlPointOfImage);
-  }
-
-  std::sort(allControlPointsOfCase.begin(), allControlPointsOfCase.end());
-  std::sort(referencedControlPoints.begin(), referencedControlPoints.end());
-
-  SemanticTypes::ControlPointVector nonReferencedControlPoints;
-  std::set_difference(allControlPointsOfCase.begin(), allControlPointsOfCase.end(),
-                      referencedControlPoints.begin(), referencedControlPoints.end(),
-                      std::inserter(nonReferencedControlPoints, nonReferencedControlPoints.begin()));
-
-  auto allExaminationPeriods = GetAllExaminationPeriodsOfCase(caseID);
-  for (const auto& controlPoint : nonReferencedControlPoints)
-  {
-    const auto& examinationPeriod = FindExaminationPeriod(controlPoint, allExaminationPeriods);
-    RelationStorage::RemoveControlPointFromExaminationPeriod(caseID, controlPoint, examinationPeriod);
-    RelationStorage::RemoveControlPointFromCase(caseID, controlPoint);
-  }
-}
diff --git a/Modules/SemanticRelations/src/mitkSemanticRelationsIntegration.cpp b/Modules/SemanticRelations/src/mitkSemanticRelationsIntegration.cpp
index deee49a3ab..6e65122cb3 100644
--- a/Modules/SemanticRelations/src/mitkSemanticRelationsIntegration.cpp
+++ b/Modules/SemanticRelations/src/mitkSemanticRelationsIntegration.cpp
@@ -1,446 +1,592 @@
 /*===================================================================
 
 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 "mitkSemanticRelationsIntegration.h"
 
 // semantic relations module
 #include "mitkControlPointManager.h"
 #include "mitkDICOMHelper.h"
 #include "mitkNodePredicates.h"
 #include "mitkRelationStorage.h"
 #include "mitkSemanticRelationException.h"
 #include "mitkSemanticRelationsInference.h"
 #include "mitkUIDGeneratorBoost.h"
 
 // multi label module
 #include <mitkLabelSetImage.h>
 
 // c++
 #include <iterator>
 #include <algorithm>
 
 std::vector<mitk::ISemanticRelationsObserver*> mitk::SemanticRelationsIntegration::m_ObserverVector;
 
 void mitk::SemanticRelationsIntegration::AddObserver(ISemanticRelationsObserver* observer)
 {
   std::vector<ISemanticRelationsObserver*>::iterator existingObserver = std::find(m_ObserverVector.begin(), m_ObserverVector.end(), observer);
   if (existingObserver != m_ObserverVector.end())
   {
     // no need to add the already existing observer
     return;
   }
 
   m_ObserverVector.push_back(observer);
 }
 
 void mitk::SemanticRelationsIntegration::RemoveObserver(ISemanticRelationsObserver* observer)
 {
   m_ObserverVector.erase(std::remove(m_ObserverVector.begin(), m_ObserverVector.end(), observer), m_ObserverVector.end());
 }
 
 /************************************************************************/
 /* functions to add / remove instances / attributes                     */
 /************************************************************************/
 
 void mitk::SemanticRelationsIntegration::AddImage(const DataNode* imageNode)
 {
   if (nullptr == imageNode)
   {
-    mitkThrowException(SemanticRelationException) << "Not a valid data node.";
+    mitkThrowException(SemanticRelationException) << "Not a valid image data node.";
   }
 
-  // continue with a valid data node
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(imageNode);
-  SemanticTypes::ID nodeID = GetIDFromDataNode(imageNode);
+  SemanticTypes::CaseID caseID;
+  SemanticTypes::ID imageID;
+  SemanticTypes::InformationType informationType;
+  SemanticTypes::ControlPoint controlPoint;
+  try // retrieve information
+  {
+    caseID = GetCaseIDFromDataNode(imageNode);
+    imageID = GetIDFromDataNode(imageNode);
 
-  RelationStorage::AddCase(caseID);
-  RelationStorage::AddImage(caseID, nodeID);
+    informationType = GetDICOMModalityFromDataNode(imageNode);
+    controlPoint = GenerateControlPoint(imageNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot add the given image data node.";
+  }
 
-  SemanticTypes::InformationType informationType = GetDICOMModalityFromDataNode(imageNode);
-  AddInformationTypeToImage(imageNode, informationType);
+  try // add and set information
+  {
+    RelationStorage::AddCase(caseID);
+    RelationStorage::AddImage(caseID, imageID);
 
-  // set the correct control point for this image
-  SemanticTypes::ControlPoint controlPoint = GenerateControlPoint(imageNode);
-  SetControlPointOfData(imageNode, controlPoint);
+    AddInformationTypeToImage(imageNode, informationType);
+    SetControlPointOfImage(imageNode, controlPoint);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot add the given image data node.";
+  }
 }
 
 void mitk::SemanticRelationsIntegration::RemoveImage(const DataNode* imageNode)
 {
   if (nullptr == imageNode)
   {
-    mitkThrowException(SemanticRelationException) << "Not a valid data node.";
+    mitkThrowException(SemanticRelationException) << "Not a valid image data node.";
   }
 
-  // continue with a valid data node
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(imageNode);
-  SemanticTypes::ID nodeID = GetIDFromDataNode(imageNode);
+  SemanticTypes::CaseID caseID;
+  SemanticTypes::ID imageID;
+  try // retrieve information
+  {
+    caseID = GetCaseIDFromDataNode(imageNode);
+    imageID = GetIDFromDataNode(imageNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot remove the given image data node.";
+  }
 
-  RemoveInformationTypeFromImage(imageNode);
-  UnlinkImageFromControlPoint(imageNode);
-  RelationStorage::RemoveImage(caseID, nodeID);
+  try // add and set information
+  {
+    RemoveInformationTypeFromImage(imageNode);
+    UnlinkImageFromControlPoint(imageNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot remove the given image data node.";
+  }
+
+  RelationStorage::RemoveImage(caseID, imageID);
   NotifyObserver(caseID);
 }
 
 void mitk::SemanticRelationsIntegration::AddLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion)
 {
   if (SemanticRelationsInference::InstanceExists(caseID, lesion))
   {
     mitkThrowException(SemanticRelationException) << "The lesion " << lesion.UID << " to add already exists for the given case.";
   }
-  else
-  {
-    RelationStorage::AddLesion(caseID, lesion);
-    NotifyObserver(caseID);
-  }
+
+  RelationStorage::AddLesion(caseID, lesion);
+  NotifyObserver(caseID);
 }
 
 void mitk::SemanticRelationsIntegration::OverwriteLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion)
 {
   if (SemanticRelationsInference::InstanceExists(caseID, lesion))
   {
     RelationStorage::OverwriteLesion(caseID, lesion);
     NotifyObserver(caseID);
   }
   else
   {
     mitkThrowException(SemanticRelationException) << "The lesion " << lesion.UID << " to overwrite does not exist for the given case.";
   }
 }
 
 void mitk::SemanticRelationsIntegration::AddLesionAndLinkSegmentation(const DataNode* segmentationNode, const SemanticTypes::Lesion& lesion)
 {
   if (nullptr == segmentationNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid segmentation data node.";
   }
 
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(segmentationNode);
-  AddLesion(caseID, lesion);
-  LinkSegmentationToLesion(segmentationNode, lesion);
+  SemanticTypes::CaseID caseID;
+  try
+  {
+    caseID = GetCaseIDFromDataNode(segmentationNode);
+    AddLesion(caseID, lesion);
+    LinkSegmentationToLesion(segmentationNode, lesion);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot add given lesion and link the given segmentation data node.";
+  }
+
   NotifyObserver(caseID);
 }
 
 void mitk::SemanticRelationsIntegration::RemoveLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion)
 {
   if (SemanticRelationsInference::InstanceExists(caseID, lesion))
   {
-    SemanticTypes::IDVector allSegmentationIDsOfLesion = SemanticRelationsInference::GetAllSegmentationIDsOfLesion(caseID, lesion);
+    SemanticTypes::IDVector allSegmentationIDsOfLesion = RelationStorage::GetAllSegmentationIDsOfLesion(caseID, lesion);
     if (allSegmentationIDsOfLesion.empty())
     {
       // no more segmentations are linked to the specific lesion
       // the lesion can be removed from the storage
       RelationStorage::RemoveLesion(caseID, lesion);
       NotifyObserver(caseID);
     }
     else
     {
       mitkThrowException(SemanticRelationException) << "The lesion " << lesion.UID << " to remove is still referred to by a segmentation node. Lesion will not be removed.";
     }
   }
   else
   {
     mitkThrowException(SemanticRelationException) << "The lesion " << lesion.UID << " to remove does not exist for the given case.";
   }
 }
 
 void mitk::SemanticRelationsIntegration::AddSegmentation(const DataNode* segmentationNode, const DataNode* parentNode)
 {
   if (nullptr == segmentationNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid segmentation data node.";
   }
 
   if (nullptr == parentNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid parent data node.";
   }
 
-  // continue with a valid data node
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(segmentationNode);
-  SemanticTypes::ID segmentationNodeID = GetIDFromDataNode(segmentationNode);
-  SemanticTypes::ID parentNodeID = GetIDFromDataNode(parentNode);
+  SemanticTypes::CaseID caseID;
+  SemanticTypes::ID segmentationNodeID;
+  SemanticTypes::ID parentNodeID;
+  try
+  {
+    caseID = GetCaseIDFromDataNode(segmentationNode);
+    segmentationNodeID = GetIDFromDataNode(segmentationNode);
+    parentNodeID = GetIDFromDataNode(parentNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot add the given segmentation data node.";
+  }
 
   RelationStorage::AddSegmentation(caseID, segmentationNodeID, parentNodeID);
   NotifyObserver(caseID);
 }
 
 void mitk::SemanticRelationsIntegration::LinkSegmentationToLesion(const DataNode* segmentationNode, const SemanticTypes::Lesion& lesion)
 {
   if (nullptr == segmentationNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid segmentation data node.";
   }
 
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(segmentationNode);
+  SemanticTypes::CaseID caseID;
+  SemanticTypes::ID segmentationID;
+  try
+  {
+    caseID = GetCaseIDFromDataNode(segmentationNode);
+    segmentationID = GetIDFromDataNode(segmentationNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot link the given segmentation data node to the given lesion.";
+  }
+
   if (SemanticRelationsInference::InstanceExists(caseID, lesion))
   {
-    SemanticTypes::ID segmentationID = GetIDFromDataNode(segmentationNode);
     RelationStorage::LinkSegmentationToLesion(caseID, segmentationID, lesion);
     NotifyObserver(caseID);
   }
   else
   {
     mitkThrowException(SemanticRelationException) << "The lesion " << lesion.UID << " to link does not exist for the given case.";
   }
 }
 
 void mitk::SemanticRelationsIntegration::UnlinkSegmentationFromLesion(const DataNode* segmentationNode)
 {
   if (nullptr == segmentationNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid segmentation data node.";
   }
 
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(segmentationNode);
-  SemanticTypes::ID segmentationID = GetIDFromDataNode(segmentationNode);
+  SemanticTypes::CaseID caseID;
+  SemanticTypes::ID segmentationID;
+  try
+  {
+    caseID = GetCaseIDFromDataNode(segmentationNode);
+    segmentationID = GetIDFromDataNode(segmentationNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot unlink the given segmentation data node from its lesion.";
+  }
+
   RelationStorage::UnlinkSegmentationFromLesion(caseID, segmentationID);
   NotifyObserver(caseID);
 }
 
 void mitk::SemanticRelationsIntegration::RemoveSegmentation(const DataNode* segmentationNode)
 {
   if (nullptr == segmentationNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid segmentation data node.";
   }
 
-  // continue with a valid data node
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(segmentationNode);
-  SemanticTypes::ID segmentationNodeID = GetIDFromDataNode(segmentationNode);
+  SemanticTypes::CaseID caseID;
+  SemanticTypes::ID segmentationNodeID;
+  try
+  {
+    caseID = GetCaseIDFromDataNode(segmentationNode);
+    segmentationNodeID = GetIDFromDataNode(segmentationNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot remove the given segmentation data node.";
+  }
+
   RelationStorage::RemoveSegmentation(caseID, segmentationNodeID);
   NotifyObserver(caseID);
 }
 
-void mitk::SemanticRelationsIntegration::SetControlPointOfData(const DataNode* dataNode, const SemanticTypes::ControlPoint& controlPoint)
+void mitk::SemanticRelationsIntegration::SetControlPointOfImage(const DataNode* imageNode, const SemanticTypes::ControlPoint& controlPoint)
 {
-  if (nullptr == dataNode)
+  if (nullptr == imageNode)
+  {
+    mitkThrowException(SemanticRelationException) << "Not a valid image data node.";
+  }
+
+  SemanticTypes::CaseID caseID;
+  try
   {
-    mitkThrowException(SemanticRelationException) << "Not a valid data node.";
+    caseID = GetCaseIDFromDataNode(imageNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot set the given control point for the given image data node.";
   }
 
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(dataNode);
   SemanticTypes::ControlPointVector allControlPoints = RelationStorage::GetAllControlPointsOfCase(caseID);
   // need to check if an already existing control point fits/contains the user control point
   SemanticTypes::ControlPoint existingControlPoint = FindExistingControlPoint(controlPoint, allControlPoints);
-  if (!existingControlPoint.UID.empty())
+  try
   {
-    try
+    if (!existingControlPoint.UID.empty())
     {
       // found an already existing control point
-      LinkDataToControlPoint(dataNode, existingControlPoint, false);
-    }
-    catch (const SemanticRelationException&)
-    {
-      mitkThrowException(SemanticRelationException) << "The data can not be linked. Inconsistency in the semantic relations storage assumed.";
+      LinkImageToControlPoint(imageNode, existingControlPoint, false);
     }
-  }
-  else
-  {
-    try
+    else
     {
-      AddControlPointAndLinkData(dataNode, controlPoint, false);
+      AddControlPointAndLinkImage(imageNode, controlPoint, false);
       // added a new control point
       // find closest control point to add the new control point to the correct examination period
       SemanticTypes::ControlPoint closestControlPoint = FindClosestControlPoint(controlPoint, allControlPoints);
       SemanticTypes::ExaminationPeriodVector allExaminationPeriods = RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
       SemanticTypes::ExaminationPeriod examinationPeriod = FindExaminationPeriod(closestControlPoint, allExaminationPeriods);
       if (examinationPeriod.UID.empty())
       {
         // no closest control point (exceed threshold) or no examination period found
         // create a new examination period for this control point and add it to the storage
         examinationPeriod.UID = UIDGeneratorBoost::GenerateUID();
         examinationPeriod.name = "New examination period " + std::to_string(allExaminationPeriods.size());
         AddExaminationPeriod(caseID, examinationPeriod);
       }
 
       // add the control point to the (newly created or found / close) examination period
       AddControlPointToExaminationPeriod(caseID, controlPoint, examinationPeriod);
     }
-    catch (const SemanticRelationException&)
-    {
-      mitkThrowException(SemanticRelationException) << "The data can not be linked. Inconsistency in the semantic relations storage assumed.";
-    }
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot set the given control point for the given image data node.";
   }
 
   ClearControlPoints(caseID);
   NotifyObserver(caseID);
+
 }
 
-void mitk::SemanticRelationsIntegration::AddControlPointAndLinkData(const DataNode* dataNode, const SemanticTypes::ControlPoint& controlPoint, bool checkConsistence)
+void mitk::SemanticRelationsIntegration::AddControlPointAndLinkImage(const DataNode* imageNode, const SemanticTypes::ControlPoint& controlPoint, bool checkConsistence)
 {
-  if (nullptr == dataNode)
+  if (nullptr == imageNode)
   {
-    mitkThrowException(SemanticRelationException) << "Not a valid data node.";
+    mitkThrowException(SemanticRelationException) << "Not a valid image data node.";
+  }
+
+  SemanticTypes::CaseID caseID;
+  try
+  {
+    caseID = GetCaseIDFromDataNode(imageNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot add the given control point and link the given image data node.";
   }
 
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(dataNode);
   if (SemanticRelationsInference::InstanceExists(caseID, controlPoint))
   {
-    mitkThrowException(SemanticRelationException) << "The control point " << controlPoint.UID << " to add already exists for the given case. \n Use 'LinkDataToControlPoint' instead.";
+    mitkThrowException(SemanticRelationException) << "The control point " << controlPoint.UID << " to add already exists for the given case. \n Use 'LinkImageToControlPoint' instead.";
   }
 
   RelationStorage::AddControlPoint(caseID, controlPoint);
-  LinkDataToControlPoint(dataNode, controlPoint, checkConsistence);
+
+  try
+  {
+    LinkImageToControlPoint(imageNode, controlPoint, checkConsistence);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot add the given control point and link the given image data node.";
+  }
 }
 
-void mitk::SemanticRelationsIntegration::LinkDataToControlPoint(const DataNode* dataNode, const SemanticTypes::ControlPoint& controlPoint, bool checkConsistence)
+void mitk::SemanticRelationsIntegration::LinkImageToControlPoint(const DataNode* imageNode, const SemanticTypes::ControlPoint& controlPoint, bool /*checkConsistence*/)
 {
-  if (nullptr == dataNode)
+  if (nullptr == imageNode)
+  {
+    mitkThrowException(SemanticRelationException) << "Not a valid image data node.";
+  }
+
+  SemanticTypes::CaseID caseID;
+  SemanticTypes::ID imageID;
+  try
   {
-    mitkThrowException(SemanticRelationException) << "Not a valid data node.";
+    caseID = GetCaseIDFromDataNode(imageNode);
+    imageID = GetIDFromDataNode(imageNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot link the image data node to the given control point.";
   }
 
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(dataNode);
   if (SemanticRelationsInference::InstanceExists(caseID, controlPoint))
   {
-    SemanticTypes::ID dataID = GetIDFromDataNode(dataNode);
-    RelationStorage::LinkImageToControlPoint(caseID, dataID, controlPoint);
+    RelationStorage::LinkImageToControlPoint(caseID, imageID, controlPoint);
   }
   else
   {
     mitkThrowException(SemanticRelationException) << "The control point " << controlPoint.UID << " to link does not exist for the given case.";
   }
 }
 
-void mitk::SemanticRelationsIntegration::UnlinkImageFromControlPoint(const DataNode* dataNode)
+void mitk::SemanticRelationsIntegration::UnlinkImageFromControlPoint(const DataNode* imageNode)
 {
-  if (nullptr == dataNode)
+  if (nullptr == imageNode)
+  {
+    mitkThrowException(SemanticRelationException) << "Not a valid image data node.";
+  }
+
+  SemanticTypes::CaseID caseID = "";
+  SemanticTypes::ID imageID = "";
+  try
   {
-    mitkThrowException(SemanticRelationException) << "Not a valid data node.";
+    caseID = GetCaseIDFromDataNode(imageNode);
+    imageID = GetIDFromDataNode(imageNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot unlink the given image data node from its control point.";
   }
 
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(dataNode);
-  SemanticTypes::ID dataID = GetIDFromDataNode(dataNode);
-  SemanticTypes::ControlPoint controlPoint = RelationStorage::GetControlPointOfImage(caseID, dataID);
-  RelationStorage::UnlinkImageFromControlPoint(caseID, dataID);
+  SemanticTypes::ControlPoint controlPoint = RelationStorage::GetControlPointOfImage(caseID, imageID);
+  RelationStorage::UnlinkImageFromControlPoint(caseID, imageID);
   ClearControlPoints(caseID);
 }
 
 void mitk::SemanticRelationsIntegration::AddExaminationPeriod(const SemanticTypes::CaseID& caseID, const SemanticTypes::ExaminationPeriod& examinationPeriod)
 {
   if (SemanticRelationsInference::InstanceExists(caseID, examinationPeriod))
   {
     mitkThrowException(SemanticRelationException) << "The examination period " << examinationPeriod.UID << " to add already exists for the given case.";
   }
   else
   {
     RelationStorage::AddExaminationPeriod(caseID, examinationPeriod);
   }
 }
 
 void mitk::SemanticRelationsIntegration::AddControlPointToExaminationPeriod(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint, const SemanticTypes::ExaminationPeriod& examinationPeriod)
 {
   if (!SemanticRelationsInference::InstanceExists(caseID, controlPoint))
   {
     mitkThrowException(SemanticRelationException) << "The control point " << controlPoint.UID << " to add does not exist for the given case.";
   }
 
   if (!SemanticRelationsInference::InstanceExists(caseID, examinationPeriod))
   {
     mitkThrowException(SemanticRelationException) << "The examination period " << examinationPeriod.UID << " does not exist for the given case. \n Use 'AddExaminationPeriod' before.";
   }
 
   RelationStorage::AddControlPointToExaminationPeriod(caseID, controlPoint, examinationPeriod);
 }
 
 void mitk::SemanticRelationsIntegration::SetInformationType(const DataNode* imageNode, const SemanticTypes::InformationType& informationType)
 {
-  RemoveInformationTypeFromImage(imageNode);
-  AddInformationTypeToImage(imageNode, informationType);
+  SemanticTypes::CaseID caseID;
+  try
+  {
+    caseID = GetCaseIDFromDataNode(imageNode);
+
+    RemoveInformationTypeFromImage(imageNode);
+    AddInformationTypeToImage(imageNode, informationType);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot set the given information type for the given image data node.";
+  }
 
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(imageNode);
   NotifyObserver(caseID);
 }
 
 void mitk::SemanticRelationsIntegration::AddInformationTypeToImage(const DataNode* imageNode, const SemanticTypes::InformationType& informationType)
 {
   if (nullptr == imageNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid image data node.";
   }
 
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(imageNode);
-  SemanticTypes::ID imageID = GetIDFromDataNode(imageNode);
+  SemanticTypes::CaseID caseID = "";
+  SemanticTypes::ID imageID = "";
+  try
+  {
+    caseID = GetCaseIDFromDataNode(imageNode);
+    imageID = GetIDFromDataNode(imageNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot add the given information type to the given image data node.";
+  }
+
   RelationStorage::AddInformationTypeToImage(caseID, imageID, informationType);
 }
 
 void mitk::SemanticRelationsIntegration::RemoveInformationTypeFromImage(const DataNode* imageNode)
 {
   if (nullptr == imageNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid image data node.";
   }
 
-  SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(imageNode);
-  SemanticTypes::ID imageID = GetIDFromDataNode(imageNode);
+  SemanticTypes::CaseID caseID = "";
+  SemanticTypes::ID imageID = "";
+  try
+  {
+    caseID = GetCaseIDFromDataNode(imageNode);
+    imageID = GetIDFromDataNode(imageNode);
+  }
+  catch (SemanticRelationException& e)
+  {
+    mitkReThrow(e) << "Cannot remove the information type from the given image data node.";
+  }
+
   SemanticTypes::InformationType originalInformationType = RelationStorage::GetInformationTypeOfImage(caseID, imageID);
   RelationStorage::RemoveInformationTypeFromImage(caseID, imageID);
 
   // check for further references to the removed information type
   std::vector<std::string> allImageIDsVectorValue = RelationStorage::GetAllImageIDsOfCase(caseID);
   for (const auto& otherImageID : allImageIDsVectorValue)
   {
     SemanticTypes::InformationType otherInformationType = RelationStorage::GetInformationTypeOfImage(caseID, otherImageID);
     if (otherInformationType == originalInformationType)
     {
       // found the information type in another image -> cannot remove the information type from the case
       return;
     }
   }
 
   // given information type was not referred by any other image of the case -> the information type can be removed from the case
-  RelationStorage::RemoveInformationTypeFromCase(caseID, originalInformationType);
+  RelationStorage::RemoveInformationType(caseID, originalInformationType);
 }
 
 /************************************************************************/
 /* private functions                                                    */
 /************************************************************************/
 void mitk::SemanticRelationsIntegration::NotifyObserver(const SemanticTypes::CaseID& caseID) const
 {
   for (auto& observer : m_ObserverVector)
   {
     observer->Update(caseID);
   }
 }
 
 void mitk::SemanticRelationsIntegration::ClearControlPoints(const SemanticTypes::CaseID& caseID)
 {
   SemanticTypes::ControlPointVector allControlPointsOfCase = RelationStorage::GetAllControlPointsOfCase(caseID);
 
   std::vector<std::string> allImageIDsVectorValue = RelationStorage::GetAllImageIDsOfCase(caseID);
   SemanticTypes::ControlPointVector referencedControlPoints;
   for (const auto& imageID : allImageIDsVectorValue)
   {
     auto controlPointOfImage = RelationStorage::GetControlPointOfImage(caseID, imageID);
     referencedControlPoints.push_back(controlPointOfImage);
   }
 
   std::sort(allControlPointsOfCase.begin(), allControlPointsOfCase.end());
   std::sort(referencedControlPoints.begin(), referencedControlPoints.end());
 
   SemanticTypes::ControlPointVector nonReferencedControlPoints;
   std::set_difference(allControlPointsOfCase.begin(), allControlPointsOfCase.end(),
                       referencedControlPoints.begin(), referencedControlPoints.end(),
                       std::inserter(nonReferencedControlPoints, nonReferencedControlPoints.begin()));
 
   auto allExaminationPeriods = RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
   for (const auto& controlPoint : nonReferencedControlPoints)
   {
     const auto& examinationPeriod = FindExaminationPeriod(controlPoint, allExaminationPeriods);
     RelationStorage::RemoveControlPointFromExaminationPeriod(caseID, controlPoint, examinationPeriod);
-    RelationStorage::RemoveControlPointFromCase(caseID, controlPoint);
+    RelationStorage::RemoveControlPoint(caseID, controlPoint);
   }
 }
diff --git a/Modules/SemanticRelationsUI/files.cmake b/Modules/SemanticRelationsUI/files.cmake
index e9fc94045d..8208ef2d16 100644
--- a/Modules/SemanticRelationsUI/files.cmake
+++ b/Modules/SemanticRelationsUI/files.cmake
@@ -1,31 +1,32 @@
 file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*")
 
 set(CPP_FILES
   mitkModuleActivator.cpp
+  QmitkAbstractSemanticRelationsStorageInspector.cpp
   QmitkAbstractSemanticRelationsStorageModel.cpp
   QmitkControlPointDialog.cpp
   QmitkLesionTextDialog.cpp
   QmitkLesionTreeItem.cpp
   QmitkLesionTreeModel.cpp
   QmitkPatientTableHeaderView.cpp
   QmitkPatientTableInspector.cpp
   QmitkPatientTableModel.cpp
   QmitkSemanticRelationsUIHelper.cpp
   QmitkTableItemThumbnailDelegate.cpp
 )
 
 set(MOC_H_FILES
  include/QmitkAbstractSemanticRelationsStorageInspector.h
  include/QmitkAbstractSemanticRelationsStorageModel.h
  include/QmitkControlPointDialog.h
  include/QmitkLesionTextDialog.h
  include/QmitkLesionTreeModel.h
  include/QmitkPatientTableHeaderView.h
  include/QmitkPatientTableInspector.h
  include/QmitkPatientTableModel.h
  include/QmitkTableItemThumbnailDelegate.h
 )
 
 set(UI_FILES
   src/QmitkPatientTableInspector.ui
 )
diff --git a/Modules/SemanticRelationsUI/include/QmitkAbstractSemanticRelationsStorageInspector.h b/Modules/SemanticRelationsUI/include/QmitkAbstractSemanticRelationsStorageInspector.h
index 15a06ca2ea..1bd7d46a0c 100644
--- a/Modules/SemanticRelationsUI/include/QmitkAbstractSemanticRelationsStorageInspector.h
+++ b/Modules/SemanticRelationsUI/include/QmitkAbstractSemanticRelationsStorageInspector.h
@@ -1,55 +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 QMITKABSTRACTSEMANTICRELATIONSSTORAGEINSPECTOR_H
 #define QMITKABSTRACTSEMANTICRELATIONSSTORAGEINSPECTOR_H
 
 // semantic relations UI module
 #include "MitkSemanticRelationsUIExports.h"
 
 // semantic relations module
 #include "mitkSemanticTypes.h"
 
 // qt widgets module
 #include "QmitkAbstractDataStorageInspector.h"
 
 /*
 * @brief The QmitkAbstractSemanticRelationsStorageInspector is a QmitkAbstractDataStorageInspector that can be used to
 *        show the currently available data of an (abstract) semantic relations storage model.
 */
 class MITKSEMANTICRELATIONSUI_EXPORT QmitkAbstractSemanticRelationsStorageInspector : public QmitkAbstractDataStorageInspector
 {
   Q_OBJECT
 
 public:
+
+  virtual ~QmitkAbstractSemanticRelationsStorageInspector();
+
   /**
   * @brief Extends the abstract base class to allow setting the current case ID which is needed to access the
   *        semantic relations storage. The function sets the case ID in the storage model.
   *
   * @param caseID    A case ID as string
   */
   virtual void SetCaseID(const mitk::SemanticTypes::CaseID& caseID) = 0;
   /**
   * @brief Extends the abstract base class to allow setting the current lesion.
   *        The function sets the lesion in the storage model.
   *
   *@param lesion   The selected lesion
   */
   virtual void SetLesion(const mitk::SemanticTypes::Lesion& lesion) = 0;
 
+protected:
+
+  QmitkAbstractSemanticRelationsStorageInspector(QWidget* parent = nullptr);
 };
 
 #endif // QMITKABSTRACTSEMANTICRELATIONSSTORAGEINSPECTOR_H
diff --git a/Modules/SemanticRelationsUI/include/QmitkLesionTreeModel.h b/Modules/SemanticRelationsUI/include/QmitkLesionTreeModel.h
index d130c4d94f..899d912e61 100644
--- a/Modules/SemanticRelationsUI/include/QmitkLesionTreeModel.h
+++ b/Modules/SemanticRelationsUI/include/QmitkLesionTreeModel.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 QMITKLESIONTREEMODEL_H
 #define QMITKLESIONTREEMODEL_H
 
 // mitk semantic relations UI
 #include "MitkSemanticRelationsUIExports.h"
 #include "QmitkAbstractSemanticRelationsStorageModel.h"
 #include "QmitkLesionTreeItem.h"
 
 // c++
 #include <memory>
 
 /*
 * @brief 
 */
 class MITKSEMANTICRELATIONSUI_EXPORT QmitkLesionTreeModel : public QmitkAbstractSemanticRelationsStorageModel
 {
   Q_OBJECT 
    
 public:
 
   /**
   *	@brief Initialize the root item of the model. The root item does not have a parent item.
   */
   QmitkLesionTreeModel(QObject* parent = nullptr);
   ~QmitkLesionTreeModel();
 
   //////////////////////////////////////////////////////////////////////////
   // overridden virtual functions from QAbstractItemModel
   //////////////////////////////////////////////////////////////////////////
   virtual QModelIndex index(int row, int column, const QModelIndex& itemIndex = QModelIndex()) const override;
   virtual QModelIndex parent(const QModelIndex& itemIndex) const override;
 
   virtual int rowCount(const QModelIndex& itemIndex = QModelIndex()) const override;
   virtual int columnCount(const QModelIndex& itemIndex = 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 = Qt::DisplayRole) const override;
   //////////////////////////////////////////////////////////////////////////
   // end override
   //////////////////////////////////////////////////////////////////////////
 
 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 { }
+  virtual void NodeAdded(const mitk::DataNode*) override { }
+  virtual void NodeChanged(const mitk::DataNode*) override { }
+  virtual void NodeRemoved(const mitk::DataNode*) override { }
   /**
   * @brief Overridden from 'QmitkAbstractSemanticRelationsStorageModel': This function retrieves all control points
   *        of the current case and stores them to define the header of the tree.
   *        Furthermore all lesions are retrieved and the lesion data is stored and show in the tree view.
   */
   virtual void SetData() override;
 
 private:
 
   void SetLesionData();
   void AddLesion(const mitk::SemanticTypes::Lesion& lesion);
   void SetSelectedDataNodesPresence();
   /**
   * @brief The function uses the ID of the lesion to see if a data node 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 'SetSelectedDataNodesPresence' function.
   *
   * @param lesion             The lesion whose data node presence should be set
   * @param dataNodePresence   The bool value that defines the data node presence of the given lesion
   */
   void SetDataNodePresenceOfLesion(const mitk::SemanticTypes::Lesion* lesion, bool dataNodePresence);
 
   QmitkLesionTreeItem* GetItemByIndex(const QModelIndex& index) const;
 
   std::map<mitk::SemanticTypes::ID, bool> m_DataNodePresence;
 
   std::shared_ptr<QmitkLesionTreeItem> m_RootItem;
   mitk::SemanticTypes::ControlPointVector m_ControlPoints;
   mitk::SemanticTypes::LesionVector m_CurrentLesions;
 };
 
 #endif // QMITKLESIONTREEMODEL_H
diff --git a/Modules/SemanticRelationsUI/include/QmitkPatientTableModel.h b/Modules/SemanticRelationsUI/include/QmitkPatientTableModel.h
index b32290bf37..16a38ef02b 100644
--- a/Modules/SemanticRelationsUI/include/QmitkPatientTableModel.h
+++ b/Modules/SemanticRelationsUI/include/QmitkPatientTableModel.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 QMITKPATIENTTABLEMODEL_H
 #define QMITKPATIENTTABLEMODEL_H
 
 // semantic relations UI module
 #include "QmitkAbstractSemanticRelationsStorageModel.h"
 
 // semantic relations module
 #include <mitkSemanticTypes.h>
 #include <mitkSemanticRelationsDataStorageAccess.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 = 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...
   virtual void NodePredicateChanged() override;
   // but are not implemented in this model
-  virtual void NodeAdded(const mitk::DataNode* node) override { }
-  virtual void NodeChanged(const mitk::DataNode* node) override { }
-  virtual void NodeRemoved(const mitk::DataNode* node) override { }
+  virtual void NodeAdded(const mitk::DataNode*) override { }
+  virtual void NodeChanged(const mitk::DataNode*) override { }
+  virtual void NodeRemoved(const mitk::DataNode*) 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::SemanticRelationsDataStorageAccess::DataNodeVector m_CurrentDataNodes;
   std::string m_SelectedNodeType;
 
   QStandardItemModel* m_HeaderModel;
 };
 
 #endif // QMITKPATIENTTABLEMODEL_H
diff --git a/Modules/SemanticRelations/include/mitkSemanticRelationException.h b/Modules/SemanticRelationsUI/src/QmitkAbstractSemanticRelationsStorageInspector.cpp
similarity index 55%
copy from Modules/SemanticRelations/include/mitkSemanticRelationException.h
copy to Modules/SemanticRelationsUI/src/QmitkAbstractSemanticRelationsStorageInspector.cpp
index 4def6f9420..2f6013c589 100644
--- a/Modules/SemanticRelations/include/mitkSemanticRelationException.h
+++ b/Modules/SemanticRelationsUI/src/QmitkAbstractSemanticRelationsStorageInspector.cpp
@@ -1,35 +1,29 @@
 /*===================================================================
 
 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 MITKSEMANTICRELATIONEXCEPTION_H
-#define MITKSEMANTICRELATIONEXCEPTION_H
+// semantic relations UI module
+#include "QmitkAbstractSemanticRelationsStorageInspector.h"
 
-// mitk core
-#include <mitkException.h>
-
-namespace mitk
+QmitkAbstractSemanticRelationsStorageInspector::QmitkAbstractSemanticRelationsStorageInspector(QWidget* parent /*= nullptr*/)
+  : QmitkAbstractDataStorageInspector(parent)
 {
-  class SemanticRelationException : public Exception
-  {
-
-  public:
-
-    mitkExceptionClassMacro(SemanticRelationException, Exception);
+  // nothing here
+}
 
-  };
-} // namespace mitk
-
-#endif // MITKSEMANTICRELATIONEXCEPTION_H
+QmitkAbstractSemanticRelationsStorageInspector::~QmitkAbstractSemanticRelationsStorageInspector()
+{
+  // nothing here
+}
diff --git a/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp b/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp
index d1a23715e0..07c1071fc3 100644
--- a/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp
+++ b/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp
@@ -1,303 +1,303 @@
 /*===================================================================
 
 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 "QmitkLesionTreeModel.h"
 
 // semantic relations module
 #include <mitkControlPointManager.h>
 #include <mitkLesionManager.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkSemanticRelationsInference.h>
 #include <mitkRelationStorage.h>
 
 // qt
 #include <QColor>
 
 QmitkLesionTreeModel::QmitkLesionTreeModel(QObject* parent/* = nullptr*/)
   : QmitkAbstractSemanticRelationsStorageModel(parent)
   , m_RootItem(std::make_shared<QmitkLesionTreeItem>(mitk::LesionData()))
 {
   // nothing here
 }
 
 QmitkLesionTreeModel::~QmitkLesionTreeModel()
 {
   // nothing here
 }
 
 //////////////////////////////////////////////////////////////////////////
 // overridden virtual functions from QAbstractItemModel
 //////////////////////////////////////////////////////////////////////////
 QModelIndex QmitkLesionTreeModel::index(int row, int column, const QModelIndex& itemIndex) const
 {
   if (!hasIndex(row, column, itemIndex))
   {
     return QModelIndex();
   }
 
   auto childItem = GetItemByIndex(itemIndex)->GetChildInRow(row);
   if (nullptr == childItem)
   {
     return QModelIndex();
   }
 
   return createIndex(row, column, childItem.get());
 }
 
 QModelIndex QmitkLesionTreeModel::parent(const QModelIndex& itemIndex) const
 {
   if (!itemIndex.isValid())
   {
     return QModelIndex();
   }
 
   auto parentItem = GetItemByIndex(itemIndex)->GetParent();
   if (parentItem.expired())
   {
     return QModelIndex();
   }
 
   auto sharedParent = parentItem.lock();
   if (sharedParent == m_RootItem)
   {
     return QModelIndex();
   }
 
   return createIndex(sharedParent->GetRow(), 0, sharedParent.get());
 }
 
 int QmitkLesionTreeModel::rowCount(const QModelIndex& itemIndex/* = QModelIndex()*/) const
 {
   return GetItemByIndex(itemIndex)->ChildCount();
 }
 
 int QmitkLesionTreeModel::columnCount(const QModelIndex&/* itemIndex = QModelIndex() */) const
 {
   if (0 == m_RootItem->ChildCount())
   {
     // no lesion items stored, no need to display columns
     return 0;
   }
 
   return m_ControlPoints.size() + 1;
 }
 
 QVariant QmitkLesionTreeModel::data(const QModelIndex& index, int role) const
 {
   if (!index.isValid())
   {
     return QVariant();
   }
 
   if (index.column() < 0 || index.column() > static_cast<int>(m_ControlPoints.size()))
   {
     return QVariant();
   }
 
   QmitkLesionTreeItem* currentItem = GetItemByIndex(index);
   if (Qt::DisplayRole == role)
   {
     if (currentItem->GetParent().expired())
     {
       return QVariant();
     }
 
     auto parentItem = currentItem->GetParent().lock();
     // parent exists and is the root item -> 1. item of a lesion entry
     if (m_RootItem == parentItem)
     {
       // display role fills the first columns with the lesion UID / name
       if (0 == index.column())
       {
         std::string itemString = currentItem->GetData().GetLesionName();
         if (itemString.empty())
         {
           itemString = currentItem->GetData().GetLesionUID();
         }
         return QString::fromStdString(itemString);
       }
       else
       {
         // display role fills other columns with the lesion presence info
         const auto lesionPresence = currentItem->GetData().GetLesionPresence();
         if (index.column() - 1 > static_cast<int>(lesionPresence.size()))
         {
           return "";
         }
 
         return QVariant(lesionPresence.at(index.column() - 1));
       }
     }
     // parent is not the root item -> 2. item of a lesion entry
     else
     {
       // display role fills the first columns with the property name "Volume"
       if (0 == index.column())
       {
         return "Volume";
       }
       else
       {
         // display role fills other columns with the lesion volume info
         const auto lesionVolume= currentItem->GetData().GetLesionVolume();
         if (index.column() - 1 > static_cast<int>(lesionVolume.size()))
         {
           return "";
         }
         return QVariant(lesionVolume.at(index.column() - 1));
       }
     }
   }
 
   if (Qt::BackgroundColorRole == role)
   {
     auto it = m_DataNodePresence.find(currentItem->GetData().GetLesion().UID);
     if (it != m_DataNodePresence.end())
     {
       return it->second ? QVariant(QColor(Qt::darkGreen)) : QVariant(QColor(Qt::transparent));
     }
 
     return QVariant(QColor(Qt::transparent));
   }
 
   if (Qt::UserRole == role)
   {
     return QVariant::fromValue(currentItem);
   }
 
   return QVariant();
 }
 
 QVariant QmitkLesionTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if (0 == m_RootItem->ChildCount())
   {
     // no lesion items stored, no need to display the header
     return QVariant();
   }
 
   if (Qt::Horizontal == orientation && Qt::DisplayRole == role)
   {
     if (0 == section)
     {
       return QVariant("Lesion");
     }
 
-    if (m_ControlPoints.size() >= section)
+    if (static_cast<int>(m_ControlPoints.size()) >= section)
     {
       mitk::SemanticTypes::ControlPoint currentControlPoint = m_ControlPoints.at(section-1);
       return QVariant(QString::fromStdString(currentControlPoint.ToString()));
     }
   }
 
   return QVariant();
 }
 
 void QmitkLesionTreeModel::SetData()
 {
   m_RootItem = std::make_shared<QmitkLesionTreeItem>(mitk::LesionData());
 
   // get all control points of current case
   m_ControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(m_CaseID);
   // sort the vector of control points for the timeline
   std::sort(m_ControlPoints.begin(), m_ControlPoints.end());
   
   SetLesionData();
   SetSelectedDataNodesPresence();
 }
 
 void QmitkLesionTreeModel::SetLesionData()
 {
   m_CurrentLesions = mitk::RelationStorage::GetAllLesionsOfCase(m_CaseID);
   for (auto& lesion : m_CurrentLesions)
   {
     AddLesion(lesion);
   }
 }
 
 void QmitkLesionTreeModel::AddLesion(const mitk::SemanticTypes::Lesion& lesion)
 {
   // create new lesion tree item data and modify it according to the control point data
   mitk::LesionData lesionData(lesion);
   mitk::GenerateAdditionalLesionData(lesionData, m_CaseID);
 
   // add the 1. level lesion item to the root item
   std::shared_ptr<QmitkLesionTreeItem> newLesionTreeItem = std::make_shared<QmitkLesionTreeItem>(lesionData);
   m_RootItem->AddChild(newLesionTreeItem);
 
   // add the 2. level lesion item to the 1. level lesion item
   std::shared_ptr<QmitkLesionTreeItem> newChildItem = std::make_shared<QmitkLesionTreeItem>(lesionData);
   newLesionTreeItem->AddChild(newChildItem);
 }
 
 void QmitkLesionTreeModel::SetSelectedDataNodesPresence()
 {
   m_DataNodePresence.clear();
   for (const auto& dataNode : m_SelectedDataNodes)
   {
     if (!mitk::SemanticRelationsInference::InstanceExists(dataNode))
     {
       continue;
     }
 
     for (const auto& lesion : m_CurrentLesions)
     {
       if (!mitk::SemanticRelationsInference::InstanceExists(m_CaseID, lesion))
       {
         continue;
       }
       try
       {
         // set the lesion presence for the current node
         bool dataNodePresence = mitk::SemanticRelationsInference::IsLesionPresent(lesion, dataNode);
         SetDataNodePresenceOfLesion(&lesion, dataNodePresence);
       }
       catch (const mitk::SemanticRelationException&)
       {
         continue;
       }
     }
   }
 }
 
 void QmitkLesionTreeModel::SetDataNodePresenceOfLesion(const mitk::SemanticTypes::Lesion* lesion, bool dataNodePresence)
 {
   std::map<mitk::SemanticTypes::ID, bool>::iterator iter = m_DataNodePresence.find(lesion->UID);
   if (iter != m_DataNodePresence.end())
   {
     // key already existing, overwrite already stored bool value
     iter->second = dataNodePresence;
   }
   else
   {
     m_DataNodePresence.insert(std::make_pair(lesion->UID, dataNodePresence));
   }
 }
 
 QmitkLesionTreeItem* QmitkLesionTreeModel::GetItemByIndex(const QModelIndex& index) const
 {
   if (index.isValid())
   {
     auto item = static_cast<QmitkLesionTreeItem*>(index.internalPointer());
     if (nullptr != item)
     {
       return item;
     }
   }
 
   return m_RootItem.get();
 }
diff --git a/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp b/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp
index 7b02bd0e59..9f8f4d3ca8 100644
--- a/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp
+++ b/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp
@@ -1,182 +1,183 @@
 /*===================================================================
 
 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*/)
+  : QmitkAbstractSemanticRelationsStorageInspector(parent)
 {
   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, &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 1134f56d5d..80b857e1f7 100644
--- a/Modules/SemanticRelationsUI/src/QmitkPatientTableModel.cpp
+++ b/Modules/SemanticRelationsUI/src/QmitkPatientTableModel.cpp
@@ -1,344 +1,342 @@
 /*===================================================================
 
 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 <mitkSemanticRelationsInference.h>
 #include <mitkRelationStorage.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
+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
 {
+  if (parent.isValid())
+  {
+    return 0;
+  }
+
   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)
+    if (static_cast<int>(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::SetData()
 {
   // get all control points of current case
   m_ControlPoints = mitk::RelationStorage::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 = mitk::RelationStorage::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 = mitk::RelationStorage::GetAllInformationTypesOfCase(m_CaseID);
 
   if ("Image" == m_SelectedNodeType)
   {
     m_CurrentDataNodes = m_SemanticRelationsDataStorageAccess->GetAllImagesOfCase(m_CaseID);
   }
   else if ("Segmentation" == m_SelectedNodeType)
   {
     m_CurrentDataNodes = m_SemanticRelationsDataStorageAccess->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 (!mitk::SemanticRelationsInference::InstanceExists(m_CaseID, m_Lesion))
   {
     return;
   }
 
   for (const auto& dataNode : m_CurrentDataNodes)
   {
     if (!mitk::SemanticRelationsInference::InstanceExists(dataNode))
     {
       continue;
     }
 
-    try
-    {
-      // set the lesion presence for the current node
-      bool lesionPresence = mitk::SemanticRelationsInference::IsLesionPresent(m_Lesion, dataNode);
-      SetLesionPresenceOfNode(dataNode, lesionPresence);
-    }
-    catch (const mitk::SemanticRelationException&)
-    {
-      continue;
-    }
+    // set the lesion presence for the current node
+    bool lesionPresence = mitk::SemanticRelationsInference::IsLesionPresent(m_Lesion, dataNode);
+    SetLesionPresenceOfNode(dataNode, lesionPresence);
   }
 }
 
 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_SemanticRelationsDataStorageAccess->GetAllSpecificImages(m_CaseID, currentControlPoint, currentInformationType);
     }
     else if ("Segmentation" == m_SelectedNodeType)
     {
       filteredDataNodes = m_SemanticRelationsDataStorageAccess->GetAllSpecificSegmentations(m_CaseID, currentControlPoint, currentInformationType);
     }
 
     if (filteredDataNodes.empty())
     {
       return nullptr;
     }
     return filteredDataNodes.front();
   }
   catch (const mitk::SemanticRelationException&)
   {
     return nullptr;
   }
 }
diff --git a/Modules/SemanticRelationsUI/src/QmitkTableItemThumbnailDelegate.cpp b/Modules/SemanticRelationsUI/src/QmitkTableItemThumbnailDelegate.cpp
index f0ea252f5c..02091ed14d 100644
--- a/Modules/SemanticRelationsUI/src/QmitkTableItemThumbnailDelegate.cpp
+++ b/Modules/SemanticRelationsUI/src/QmitkTableItemThumbnailDelegate.cpp
@@ -1,47 +1,46 @@
 /*===================================================================
 
 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 "QmitkTableItemThumbnailDelegate.h"
 
 // qt
 #include <QApplication>
 #include <QPainter>
 #include <QStyle>
 
 QmitkTableItemThumbnailDelegate::QmitkTableItemThumbnailDelegate(QObject* parent /*= nullptr*/)
   : QStyledItemDelegate(parent)
 {
   // nothing here
 }
 
 void QmitkTableItemThumbnailDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const
 {
   QPixmap pixmap = index.data(Qt::DecorationRole).value<QPixmap>();
-  QRect rect = option.rect;
   QPoint point = option.rect.center() - pixmap.rect().center();
   painter->save();
 
   if (option.state & QStyle::State_Selected)
   {
     painter->setBrush(option.palette.highlightedText());
     const QWidget* widget = option.widget;
     QStyle* style = widget ? widget->style() : QApplication::style();
     style->drawControl(QStyle::CE_ItemViewItem, &option, painter, widget);
   }
   painter->drawPixmap(point, pixmap);
   painter->restore();
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeOpenInAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeOpenInAction.cpp
index d57e2f137c..6f131f7f07 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeOpenInAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeOpenInAction.cpp
@@ -1,129 +1,129 @@
 /*===================================================================
 
 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 "QmitkDataNodeOpenInAction.h"
 
 // mitk core
 #include <mitkImage.h>
 #include <mitkRenderingManager.h>
 
 // mitk gui common plugin
 #include <mitkDataNodeSelection.h>
 
 // qt
 #include <QMessageBox>
 
 // qt
 #include <QMenu>
 
 QmitkDataNodeOpenInAction::QmitkDataNodeOpenInAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchPartSite)
 {
   setText(tr("Open in"));
   InitializeAction();
 }
 
 QmitkDataNodeOpenInAction::QmitkDataNodeOpenInAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   setText(tr("Open in"));
   InitializeAction();
 }
 
 QmitkDataNodeOpenInAction::~QmitkDataNodeOpenInAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeOpenInAction::SetControlledRenderer(RendererVector controlledRenderer)
 {
   if (m_ControlledRenderer != controlledRenderer)
   {
     // set the new set of controlled renderer
     m_ControlledRenderer = controlledRenderer;
   }
 }
 
 void QmitkDataNodeOpenInAction::InitializeAction()
 {
   setCheckable(true);
 
   setMenu(new QMenu);
   connect(menu(), &QMenu::aboutToShow, this, &QmitkDataNodeOpenInAction::OnMenuAboutToShow);
 
   SetControlledRenderer();
 }
 
 void QmitkDataNodeOpenInAction::OnMenuAboutToShow()
 {
   menu()->clear();
   QAction* action;
 
   for (const auto& renderer : m_ControlledRenderer)
   {
     action = menu()->addAction(QString::fromStdString(renderer->GetName()));
     connect(action, &QAction::triggered, this, &QmitkDataNodeOpenInAction::OnActionTriggered);
   }
 }
 
-void QmitkDataNodeOpenInAction::OnActionTriggered(bool checked)
+void QmitkDataNodeOpenInAction::OnActionTriggered(bool /*checked*/)
 {
   auto dataNode = GetSelectedNode();
   if (dataNode.IsNull())
   {
     return;
   }
 
   QAction* senderAction = qobject_cast<QAction*>(QObject::sender());
   if (nullptr == senderAction)
   {
     return;
   }
 
   std::string selectedRenderer = senderAction->text().toStdString();
   mitk::BaseRenderer* renderer = mitk::BaseRenderer::GetByName(selectedRenderer);
   if (nullptr == renderer)
   {
     return;
   }
 
   auto image = dynamic_cast<mitk::Image*>(dataNode->GetData());
   if (nullptr == image)
   {
     return;
   }
 
   mitk::RenderingManager::GetInstance()->InitializeView(renderer->GetRenderWindow(), image->GetTimeGeometry());
 }
 
 void QmitkDataNodeOpenInAction::SetControlledRenderer()
 {
   const mitk::RenderingManager::RenderWindowVector allRegisteredRenderWindows =
     mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
   mitk::BaseRenderer *baseRenderer = nullptr;
   m_ControlledRenderer.clear();
   for (const auto &renderWindow : allRegisteredRenderWindows)
   {
     baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow);
     if (nullptr != baseRenderer)
     {
       m_ControlledRenderer.push_back(baseRenderer);
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/CMakeLists.txt b/Plugins/org.mitk.gui.qt.semanticrelations/CMakeLists.txt
index 595c24082e..2ffd63c2e3 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/CMakeLists.txt
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/CMakeLists.txt
@@ -1,7 +1,7 @@
 project(org_mitk_gui_qt_semanticrelations)
 
 mitk_create_plugin(
   EXPORT_DIRECTIVE MITK_GUI_SEMANTICRELATIONS_EXPORT
   EXPORTED_INCLUDE_SUFFIXES src
-  MODULE_DEPENDS MitkPersistence MitkSemanticRelationsUI MitkRenderWindowManager MitkRegistrationOntology
+  MODULE_DEPENDS MitkPersistence MitkSemanticRelationsUI MitkRenderWindowManager
 )
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 0e980bbea9..4d9f80a60c 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.cpp
@@ -1,179 +1,189 @@
 /*===================================================================
 
 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 <mitkDICOMHelper.h>
 #include <mitkNodePredicates.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkUIDGeneratorBoost.h>
 
-// mitk core
-#include <mitkPropertyNameHelper.h>
-
 // mitk gui common plugin
 #include <mitkDataNodeSelection.h>
 
+// mitk core
+#include <mitkTemporoSpatialStringProperty.h>
+
 // qt
 #include <QMessageBox>
 
 // namespace that contains the concrete action
 namespace AddToSemanticRelationsAction
 {
   void Run(mitk::SemanticRelationsIntegration* semanticRelationsIntegration, const mitk::DataStorage* dataStorage, const mitk::DataNode* dataNode)
   {
     if (nullptr == dataNode)
     {
       return;
     }
 
     if (mitk::NodePredicates::GetImagePredicate()->CheckNode(dataNode))
     {
       AddImage(semanticRelationsIntegration, dataNode);
     }
     else if (mitk::NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
     {
       AddSegmentation(semanticRelationsIntegration, dataStorage, dataNode);
     }
   }
 
   void AddImage(mitk::SemanticRelationsIntegration* semanticRelationsIntegration, const mitk::DataNode* image)
   {
     if (nullptr == image)
     {
       return;
     }
 
     try
     {
       // add the image to the semantic relations storage
       semanticRelationsIntegration->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"
+      QMessageBox msgBox(QMessageBox::Warning,
+        "Could not add the selected image.",
+        "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::SemanticRelationsIntegration* semanticRelationsIntegration, 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
-    // DICOM tag is "PatientName"
-    std::string caseIDPropertyKey = mitk::GeneratePropertyNameForDICOMTag(0x0010, 0x0010);
-    // DICOM tag is "SeriesInstanceUID"
-    std::string nodeIDPropertyKey = mitk::GeneratePropertyNameForDICOMTag(0x0020, 0x000e);
-
-    mitk::BaseProperty* caseIDProperty = baseData->GetProperty(caseIDPropertyKey.c_str());
-    mitk::BaseProperty* nodeIDProperty = baseData->GetProperty(nodeIDPropertyKey.c_str());
+    auto caseIDPropertyName = mitk::GetCaseIDDICOMProperty();
+    auto nodeIDPropertyName = mitk::GetNodeIDDICOMProperty();
+    mitk::BaseProperty* caseIDProperty = baseData->GetProperty(caseIDPropertyName.c_str());
+    mitk::BaseProperty* nodeIDProperty = baseData->GetProperty(nodeIDPropertyName.c_str());
     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(caseIDPropertyKey.c_str(), caseIDTag);
+      mitk::SemanticTypes::CaseID caseID;
+      mitk::SemanticTypes::ID nodeID;
+      try
+      {
+        caseID = mitk::GetCaseIDFromDataNode(parentNodes->front());
+        nodeID = mitk::GetIDFromDataNode(parentNodes->front());
+      }
+      catch (const mitk::SemanticRelationException& e)
+      {
+        std::stringstream exceptionMessage; exceptionMessage << e;
+        QMessageBox msgBox(QMessageBox::Warning,
+          "Could not add the selected segmentation.",
+          "The program wasn't able to correctly add the selected segmentation.\n"
+          "Reason:\n" + QString::fromStdString(exceptionMessage.str()));
+        msgBox.exec();
+        return;
+      }
 
+      // transfer DICOM tags to the segmentation node
+      baseData->SetProperty(caseIDPropertyName,
+        mitk::TemporoSpatialStringProperty::New(caseID));
       // 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(nodeIDPropertyKey.c_str(), nodeIDTag);
+      baseData->SetProperty(nodeIDPropertyName,
+        mitk::TemporoSpatialStringProperty::New(nodeID + mitk::UIDGeneratorBoost::GenerateUID()));
     }
 
     try
     {
       // add the segmentation with its parent image to the semantic relations storage
       semanticRelationsIntegration->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"
+      QMessageBox msgBox(QMessageBox::Warning,
+        "Could not add the selected segmentation.",
+        "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)
   , QmitkAbstractSemanticRelationsAction(workbenchPartSite)
 {
   setText(tr("Add to semantic relations"));
   InitializeAction();
 }
 
 QmitkDataNodeAddToSemanticRelationsAction::QmitkDataNodeAddToSemanticRelationsAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractSemanticRelationsAction(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   setText(tr("Add to semantic relations"));
   InitializeAction();
 }
 
 QmitkDataNodeAddToSemanticRelationsAction::~QmitkDataNodeAddToSemanticRelationsAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeAddToSemanticRelationsAction::InitializeAction()
 {
   connect(this, &QAction::triggered, this, &QmitkDataNodeAddToSemanticRelationsAction::OnActionTriggered);
 }
 
-void QmitkDataNodeAddToSemanticRelationsAction::OnActionTriggered(bool checked)
+void QmitkDataNodeAddToSemanticRelationsAction::OnActionTriggered(bool /*checked*/)
 {
   if (nullptr == m_SemanticRelationsIntegration)
   {
     return;
   }
 
   if (m_DataStorage.IsExpired())
   {
     return;
   }
 
   auto dataNode = GetSelectedNode();
   AddToSemanticRelationsAction::Run(m_SemanticRelationsIntegration.get(), m_DataStorage.Lock(), dataNode);
 }
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 a613dd26fc..2a61c5d1fe 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.h
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.h
@@ -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.
 
 ===================================================================*/
 
 #ifndef QMITKDATANODEADDTOSEMANTICRELATIONSACTION_H
 #define QMITKDATANODEADDTOSEMANTICRELATIONSACTION_H
 
 #include <org_mitk_gui_qt_semanticrelations_Export.h>
 
 // mitk gui qt application plugin
 #include "QmitkAbstractSemanticRelationsAction.h"
 
 // qt
-#include <QAction.h>
+#include <QAction>
 
 namespace AddToSemanticRelationsAction
 {
   MITK_GUI_SEMANTICRELATIONS_EXPORT void Run(mitk::SemanticRelationsIntegration* semanticRelationsIntegration, const mitk::DataStorage* dataStorage, const mitk::DataNode* image);
   
   void AddImage(mitk::SemanticRelationsIntegration* semanticRelationsIntegration, const mitk::DataNode* image);
   void AddSegmentation(mitk::SemanticRelationsIntegration* semanticRelationsIntegration, const mitk::DataStorage* dataStorage, const mitk::DataNode* segmentation);
 }
 
 class MITK_GUI_SEMANTICRELATIONS_EXPORT QmitkDataNodeAddToSemanticRelationsAction : public QAction, public QmitkAbstractSemanticRelationsAction
 {
   Q_OBJECT
 
 public:
 
   QmitkDataNodeAddToSemanticRelationsAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite);
   QmitkDataNodeAddToSemanticRelationsAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite);
 
   virtual ~QmitkDataNodeAddToSemanticRelationsAction() override;
 
 private Q_SLOTS:
 
   void OnActionTriggered(bool);
 
 protected:
 
   virtual void InitializeAction() override;
 
 };
 
 #endif // QMITKDATANODEADDTOSEMANTICRELATIONSACTION_H
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeRemoveFromSemanticRelationsAction.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeRemoveFromSemanticRelationsAction.cpp
index 93e13d0576..a1b0a04f33 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeRemoveFromSemanticRelationsAction.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeRemoveFromSemanticRelationsAction.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.
 
 ===================================================================*/
 
 // semantic relations plugin
 #include "QmitkDataNodeRemoveFromSemanticRelationsAction.h"
 
 // semantic relations module
 #include <mitkNodePredicates.h>
 #include <mitkSemanticRelationException.h>
 
 // mitk gui common plugin
 #include <mitkDataNodeSelection.h>
 
 // qt
 #include <QMessageBox>
 
 // namespace that contains the concrete action
 namespace RemoveFromSemanticRelationsAction
 {
   void Run(mitk::SemanticRelationsIntegration* semanticRelationsIntegration, const mitk::DataNode* dataNode)
   {
     if (nullptr == dataNode)
     {
       return;
     }
 
     if (mitk::NodePredicates::GetImagePredicate()->CheckNode(dataNode))
     {
       RemoveImage(semanticRelationsIntegration, dataNode);
     }
     else if (mitk::NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
     {
       RemoveSegmentation(semanticRelationsIntegration, dataNode);
     }
   }
 
   void RemoveImage(mitk::SemanticRelationsIntegration* semanticRelationsIntegration, const mitk::DataNode* image)
   {
     if (nullptr == image)
     {
       return;
     }
 
     try
     {
       // remove the image from the semantic relations storage
       semanticRelationsIntegration->RemoveImage(image);
     }
     catch (const mitk::SemanticRelationException& e)
     {
       std::stringstream exceptionMessage; exceptionMessage << e;
       QMessageBox msgBox;
       msgBox.setWindowTitle("Could not remove the selected image.");
       msgBox.setText("The program wasn't able to correctly remove the selected image.\n"
         "Reason:\n" + QString::fromStdString(exceptionMessage.str()));
       msgBox.setIcon(QMessageBox::Warning);
       msgBox.exec();
       return;
     }
   }
 
   void RemoveSegmentation(mitk::SemanticRelationsIntegration* semanticRelationsIntegration, const mitk::DataNode* segmentation)
   {
     if (nullptr == segmentation)
     {
       return;
     }
 
     try
     {
       // remove the segmentation from the semantic relations storage
       semanticRelationsIntegration->RemoveSegmentation(segmentation);
     }
     catch (const mitk::SemanticRelationException& e)
     {
       std::stringstream exceptionMessage; exceptionMessage << e;
       QMessageBox msgBox;
       msgBox.setWindowTitle("Could not remove the selected segmentation.");
       msgBox.setText("The program wasn't able to correctly remove the selected segmentation.\n"
         "Reason:\n" + QString::fromStdString(exceptionMessage.str()));
       msgBox.setIcon(QMessageBox::Warning);
       msgBox.exec();
       return;
     }
   }
 }
 
 QmitkDataNodeRemoveFromSemanticRelationsAction::QmitkDataNodeRemoveFromSemanticRelationsAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractSemanticRelationsAction(workbenchPartSite)
 {
   setText(tr("Remove from semantic relations"));
   InitializeAction();
 }
 
 QmitkDataNodeRemoveFromSemanticRelationsAction::QmitkDataNodeRemoveFromSemanticRelationsAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractSemanticRelationsAction(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   setText(tr("Remove from semantic relations"));
   InitializeAction();
 }
 
 QmitkDataNodeRemoveFromSemanticRelationsAction::~QmitkDataNodeRemoveFromSemanticRelationsAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeRemoveFromSemanticRelationsAction::InitializeAction()
 {
   connect(this, &QAction::triggered, this, &QmitkDataNodeRemoveFromSemanticRelationsAction::OnActionTriggered);
 }
 
-void QmitkDataNodeRemoveFromSemanticRelationsAction::OnActionTriggered(bool checked)
+void QmitkDataNodeRemoveFromSemanticRelationsAction::OnActionTriggered(bool /*checked*/)
 {
   auto dataNode = GetSelectedNode();
   RemoveFromSemanticRelationsAction::Run(m_SemanticRelationsIntegration.get(), dataNode);
 }
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeRemoveFromSemanticRelationsAction.h b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeRemoveFromSemanticRelationsAction.h
index 4e19e664fa..0a3071f614 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeRemoveFromSemanticRelationsAction.h
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeRemoveFromSemanticRelationsAction.h
@@ -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.
 
 ===================================================================*/
 
 #ifndef QMITKDATANODEREMOVEFROMSEMANTICRELATIONSACTION_H
 #define QMITKDATANODEREMOVEFROMSEMANTICRELATIONSACTION_H
 
 #include <org_mitk_gui_qt_semanticrelations_Export.h>
 
 // mitk gui qt application plugin
 #include "QmitkAbstractSemanticRelationsAction.h"
 
 // qt
-#include <QAction.h>
+#include <QAction>
 
 namespace RemoveFromSemanticRelationsAction
 {
   MITK_GUI_SEMANTICRELATIONS_EXPORT void Run(mitk::SemanticRelationsIntegration* semanticRelationsIntegration, const mitk::DataNode* dataNode);
 
   void RemoveImage(mitk::SemanticRelationsIntegration* semanticRelationsIntegration, const mitk::DataNode* image);
   void RemoveSegmentation(mitk::SemanticRelationsIntegration* semanticRelationsIntegration, const mitk::DataNode* segmentation);
 }
 
 class MITK_GUI_SEMANTICRELATIONS_EXPORT QmitkDataNodeRemoveFromSemanticRelationsAction : public QAction, public QmitkAbstractSemanticRelationsAction
 {
   Q_OBJECT
 
 public:
 
   QmitkDataNodeRemoveFromSemanticRelationsAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite);
   QmitkDataNodeRemoveFromSemanticRelationsAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite);
 
   virtual ~QmitkDataNodeRemoveFromSemanticRelationsAction() override;
 
 private Q_SLOTS:
 
   void OnActionTriggered(bool);
 
 protected:
 
   virtual void InitializeAction() override;
 
 };
 
 #endif // QMITKDATANODEREMOVEFROMSEMANTICRELATIONSACTION_H
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetControlPointAction.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetControlPointAction.cpp
index 61305de34c..825a5abf7f 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetControlPointAction.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetControlPointAction.cpp
@@ -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.
 
 ===================================================================*/
 
 // semantic relations plugin
 #include "QmitkDataNodeSetControlPointAction.h"
 
 // semantic relations module
 #include <mitkDICOMHelper.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkSemanticRelationsInference.h>
 #include <mitkUIDGeneratorBoost.h>
 
 // semantic relations UI module
 #include "QmitkControlPointDialog.h"
 
 // mitk gui common plugin
 #include <mitkDataNodeSelection.h>
 
 // qt
 #include <QInputDialog>
 
 QmitkDataNodeSetControlPointAction::QmitkDataNodeSetControlPointAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractSemanticRelationsAction(workbenchPartSite)
 {
   setText(tr("Set control point"));
   m_Parent = parent;
   InitializeAction();
 }
 
 QmitkDataNodeSetControlPointAction::QmitkDataNodeSetControlPointAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractSemanticRelationsAction(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   setText(tr("Set control point"));
   m_Parent = parent;
   InitializeAction();
 }
 
 QmitkDataNodeSetControlPointAction::~QmitkDataNodeSetControlPointAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeSetControlPointAction::InitializeAction()
 {
   connect(this, &QAction::triggered, this, &QmitkDataNodeSetControlPointAction::OnActionTriggered);
 }
 
-void QmitkDataNodeSetControlPointAction::OnActionTriggered(bool checked)
+void QmitkDataNodeSetControlPointAction::OnActionTriggered(bool /*checked*/)
 {
   if (nullptr == m_SemanticRelationsIntegration)
   {
     return;
   }
 
   auto dataNode = GetSelectedNode();
   if (dataNode.IsNull())
   {
     return;
   }
 
   QmitkControlPointDialog* inputDialog = new QmitkControlPointDialog(m_Parent);
   inputDialog->setWindowTitle("Set control point");
   inputDialog->SetCurrentDate(mitk::SemanticRelationsInference::GetControlPointOfImage(dataNode));
 
   int dialogReturnValue = inputDialog->exec();
   if (QDialog::Rejected == dialogReturnValue)
   {
     return;
   }
 
   const QDate& userSelectedDate = inputDialog->GetCurrentDate();
   mitk::SemanticTypes::ControlPoint controlPoint;
   controlPoint.UID = mitk::UIDGeneratorBoost::GenerateUID();
   controlPoint.date = boost::gregorian::date(userSelectedDate.year(),
                                              userSelectedDate.month(),
                                              userSelectedDate.day());
 
   try
   {
     m_SemanticRelationsIntegration->UnlinkImageFromControlPoint(dataNode);
-    m_SemanticRelationsIntegration->SetControlPointOfData(dataNode, controlPoint);
+    m_SemanticRelationsIntegration->SetControlPointOfImage(dataNode, controlPoint);
   }
   catch (const mitk::SemanticRelationException&)
   {
     return;
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetControlPointAction.h b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetControlPointAction.h
index 2c2345cd2f..625e707e92 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetControlPointAction.h
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetControlPointAction.h
@@ -1,49 +1,49 @@
 /*===================================================================
 
 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 QMITKDATANODESETCONTROLPOINTACTION_H
 #define QMITKDATANODESETCONTROLPOINTACTION_H
 
 // mitk gui qt semanticrelations plugin
 #include "QmitkAbstractSemanticRelationsAction.h"
 
 // qt
-#include <QAction.h>
+#include <QAction>
 
 class QmitkDataNodeSetControlPointAction : public QAction, public QmitkAbstractSemanticRelationsAction
 {
   Q_OBJECT
 
 public:
 
   QmitkDataNodeSetControlPointAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite);
   QmitkDataNodeSetControlPointAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite);
 
   virtual ~QmitkDataNodeSetControlPointAction() override;
 
 private Q_SLOTS:
 
   void OnActionTriggered(bool);
 
 protected:
 
   virtual void InitializeAction() override;
 
   QWidget* m_Parent;
 
 };
 
 #endif // QMITKDATANODESETCONTROLPOINTACTION_H
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetInformationTypeAction.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetInformationTypeAction.cpp
index be533df52c..64ea29b0e6 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetInformationTypeAction.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetInformationTypeAction.cpp
@@ -1,91 +1,91 @@
 /*===================================================================
 
 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 "QmitkDataNodeSetInformationTypeAction.h"
 
 // semantic relations module
 #include <mitkSemanticRelationException.h>
 #include <mitkSemanticRelationsInference.h>
 
 // mitk gui common plugin
 #include <mitkDataNodeSelection.h>
 
 // qt
 #include <QInputDialog>
 
 QmitkDataNodeSetInformationTypeAction::QmitkDataNodeSetInformationTypeAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractSemanticRelationsAction(workbenchPartSite)
 {
   setText(tr("Set information type"));
   m_Parent = parent;
   InitializeAction();
 }
 
 QmitkDataNodeSetInformationTypeAction::QmitkDataNodeSetInformationTypeAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractSemanticRelationsAction(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   setText(tr("Set information type"));
   m_Parent = parent;
   InitializeAction();
 }
 
 QmitkDataNodeSetInformationTypeAction::~QmitkDataNodeSetInformationTypeAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeSetInformationTypeAction::InitializeAction()
 {
   connect(this, &QAction::triggered, this, &QmitkDataNodeSetInformationTypeAction::OnActionTriggered);
 }
 
-void QmitkDataNodeSetInformationTypeAction::OnActionTriggered(bool checked)
+void QmitkDataNodeSetInformationTypeAction::OnActionTriggered(bool /*checked*/)
 {
   if (nullptr == m_SemanticRelationsIntegration)
   {
     return;
   }
 
   auto dataNode = GetSelectedNode();
   if (dataNode.IsNull())
   {
     return;
   }
 
   QInputDialog* inputDialog = new QInputDialog(m_Parent);
   inputDialog->setWindowTitle(tr("Set information type of selected node"));
   inputDialog->setLabelText(tr("Information type:"));
   inputDialog->setTextValue(QString::fromStdString(mitk::SemanticRelationsInference::GetInformationTypeOfImage(dataNode)));
   inputDialog->setMinimumSize(250, 100);
 
   int dialogReturnValue = inputDialog->exec();
   if (QDialog::Rejected == dialogReturnValue)
   {
     return;
   }
 
   try
   {
     m_SemanticRelationsIntegration->SetInformationType(dataNode, inputDialog->textValue().toStdString());
   }
   catch (const mitk::SemanticRelationException&)
   {
     return;
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetInformationTypeAction.h b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetInformationTypeAction.h
index 8fa6294631..618b5d7f55 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetInformationTypeAction.h
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetInformationTypeAction.h
@@ -1,49 +1,49 @@
 /*===================================================================
 
 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 QMITKDATANODESETINFORMATIONTYPEACTION_H
 #define QMITKDATANODESETINFORMATIONTYPEACTION_H
 
 // mitk gui qt application plugin
 #include "QmitkAbstractSemanticRelationsAction.h"
 
 // qt
-#include <QAction.h>
+#include <QAction>
 
 class QmitkDataNodeSetInformationTypeAction : public QAction, public QmitkAbstractSemanticRelationsAction
 {
   Q_OBJECT
 
 public:
 
   QmitkDataNodeSetInformationTypeAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite);
   QmitkDataNodeSetInformationTypeAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite);
 
   virtual ~QmitkDataNodeSetInformationTypeAction() override;
 
 private Q_SLOTS:
 
   void OnActionTriggered(bool);
 
 protected:
 
   virtual void InitializeAction() override;
 
   QWidget* m_Parent;
 
 };
 
 #endif // QMITKDATANODESETINFORMATIONTYPEACTION_H
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeUnlinkFromLesionAction.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeUnlinkFromLesionAction.cpp
index 6d000d82c4..c01e1301b0 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeUnlinkFromLesionAction.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeUnlinkFromLesionAction.cpp
@@ -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.
 
 ===================================================================*/
 
 // semantic relations plugin
 #include "QmitkDataNodeUnlinkFromLesionAction.h"
 
 // semantic relations module
 #include <mitkNodePredicates.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkUIDGeneratorBoost.h>
 
 // mitk gui common plugin
 #include <mitkDataNodeSelection.h>
 
 // qt
 #include <QMessageBox>
 
 // namespace that contains the concrete action
 namespace UnlinkFromLesionAction
 {
   void Run(mitk::SemanticRelationsIntegration* semanticRelationsIntegration, const mitk::DataNode* dataNode)
   {
     if (nullptr == dataNode)
     {
       return;
     }
 
     if (mitk::NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
     {
       try
       {
         semanticRelationsIntegration->UnlinkSegmentationFromLesion(dataNode);
       }
       catch (const mitk::SemanticRelationException& e)
       {
         std::stringstream exceptionMessage; exceptionMessage << e;
         QMessageBox msgBox(QMessageBox::Warning,
           "Could not unlink the selected segmentation.",
           "The program wasn't able to correctly unlink the selected segmentation.\n"
           "Reason:\n" + QString::fromStdString(exceptionMessage.str()));
         msgBox.exec();
       }
     }
     else
     {
       QMessageBox msgBox(QMessageBox::Warning,
         "Could not unlink the selected data node.",
         "Please chose a valid segmentation to unlink from its represented lesion!");
       msgBox.exec();
     }
   }
 }
 
 QmitkDataNodeUnlinkFromLesionAction::QmitkDataNodeUnlinkFromLesionAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractSemanticRelationsAction(workbenchPartSite)
 {
   setText(tr("Unlink from lesion"));
   InitializeAction();
 }
 
 QmitkDataNodeUnlinkFromLesionAction::QmitkDataNodeUnlinkFromLesionAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractSemanticRelationsAction(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   setText(tr("Unlink from lesion"));
   InitializeAction();
 }
 
 QmitkDataNodeUnlinkFromLesionAction::~QmitkDataNodeUnlinkFromLesionAction()
 {
   // nothing here
 }
 
 void QmitkDataNodeUnlinkFromLesionAction::InitializeAction()
 {
   connect(this, &QAction::triggered, this, &QmitkDataNodeUnlinkFromLesionAction::OnActionTriggered);
 }
 
-void QmitkDataNodeUnlinkFromLesionAction::OnActionTriggered(bool checked)
+void QmitkDataNodeUnlinkFromLesionAction::OnActionTriggered(bool /*checked*/)
 {
   if (nullptr == m_SemanticRelationsIntegration)
   {
     return;
   }
 
   auto dataNode = GetSelectedNode();
   UnlinkFromLesionAction::Run(m_SemanticRelationsIntegration.get(), dataNode);
 }
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeUnlinkFromLesionAction.h b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeUnlinkFromLesionAction.h
index 10523c2bcc..452d8b39fa 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeUnlinkFromLesionAction.h
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeUnlinkFromLesionAction.h
@@ -1,54 +1,54 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QMITKDATANODEUNLINKFROMLESIONACTION_H
 #define QMITKDATANODEUNLINKFROMLESIONACTION_H
 
 #include <org_mitk_gui_qt_semanticrelations_Export.h>
 
 // mitk gui qt semanticrelations plugin
 #include "QmitkAbstractSemanticRelationsAction.h"
 
 // qt
-#include <QAction.h>
+#include <QAction>
 
 namespace UnlinkFromLesionAction
 {
   MITK_GUI_SEMANTICRELATIONS_EXPORT void Run(const mitk::DataNode* dataNode, mitk::SemanticRelationsIntegration* semanticRelationsIntegration);
 }
 
 class MITK_GUI_SEMANTICRELATIONS_EXPORT QmitkDataNodeUnlinkFromLesionAction : public QAction, public QmitkAbstractSemanticRelationsAction
 {
   Q_OBJECT
 
 public:
 
   QmitkDataNodeUnlinkFromLesionAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite);
   QmitkDataNodeUnlinkFromLesionAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite);
 
   virtual ~QmitkDataNodeUnlinkFromLesionAction() override;
 
 private Q_SLOTS:
 
   void OnActionTriggered(bool);
 
 protected:
 
   virtual void InitializeAction() override;
 
 };
 
 #endif // QMITKDATANODEUNLINKFROMLESIONACTION_H
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLesionInfoWidget.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLesionInfoWidget.cpp
index 615d5e589f..bc3dde28dc 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLesionInfoWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLesionInfoWidget.cpp
@@ -1,444 +1,445 @@
 /*===================================================================
 
 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 "QmitkLesionInfoWidget.h"
 #include "QmitkSemanticRelationsNodeSelectionDialog.h"
 #include "QmitkDataNodeAddToSemanticRelationsAction.h"
 
 // semantic relations UI module
 #include <QmitkLesionTextDialog.h>
 
 // semantic relations module
 #include <mitkLesionManager.h>
 #include <mitkNodePredicates.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkSemanticRelationsInference.h>
 
 // registration ontology module
-#include <mitkLesionPropagation.h>
+//#include <mitkLesionPropagation.h>
 
 // qt
 #include <QCompleter>
 #include <QListWidget>
 #include <QMenu>
 #include <QMessageBox>
 #include <QString>
 
 QmitkLesionInfoWidget::QmitkLesionInfoWidget(mitk::DataStorage* dataStorage, QWidget* parent /*= nullptr*/)
   : QWidget(parent)
   , m_DataStorage(dataStorage)
   , m_SemanticRelationsDataStorageAccess(std::make_unique<mitk::SemanticRelationsDataStorageAccess>(dataStorage))
   , m_SemanticRelationsIntegration(std::make_unique<mitk::SemanticRelationsIntegration>())
 {
   Initialize();
 }
 
 QmitkLesionInfoWidget::~QmitkLesionInfoWidget()
 {
   // nothing here
 }
 
 void QmitkLesionInfoWidget::Initialize()
 {
   m_Controls.setupUi(this);
 
   m_Controls.lesionTreeView->setAlternatingRowColors(true);
   m_Controls.lesionTreeView->setSelectionMode(QAbstractItemView::SingleSelection);
   m_Controls.lesionTreeView->setSelectionBehavior(QAbstractItemView::SelectRows);
   m_Controls.lesionTreeView->setContextMenuPolicy(Qt::CustomContextMenu);
 
   m_StorageModel = new QmitkLesionTreeModel(m_Controls.lesionTreeView);
   if (m_DataStorage.IsExpired())
   {
     return;
   }
 
   auto dataStorage = m_DataStorage.Lock();
   m_StorageModel->SetDataStorage(dataStorage);
   m_Controls.lesionTreeView->setModel(m_StorageModel);
 
   SetUpConnections();
 }
 
 void QmitkLesionInfoWidget::SetUpConnections()
 {
   connect(m_StorageModel, &QmitkLesionTreeModel::ModelUpdated, this, &QmitkLesionInfoWidget::OnModelUpdated);
 
   // connect buttons to modify semantic relations
   connect(m_Controls.addLesionPushButton, &QPushButton::clicked, this, &QmitkLesionInfoWidget::OnAddLesionButtonClicked);
 
   // connect each list widget with a custom slots
   connect(m_Controls.lesionTreeView->selectionModel(), &QItemSelectionModel::currentChanged, this, &QmitkLesionInfoWidget::OnSelectionChanged);
 
   // connect context menu entries
   connect(m_Controls.lesionTreeView, &QTreeView::customContextMenuRequested, this, &QmitkLesionInfoWidget::OnLesionListContextMenuRequested);
 }
 
 void QmitkLesionInfoWidget::SetCaseID(const mitk::SemanticTypes::CaseID& caseID)
 {
   m_CaseID = caseID;
   m_StorageModel->SetCaseID(caseID);
 }
 
 void QmitkLesionInfoWidget::SetDataNodeSelection(const QList<mitk::DataNode::Pointer>& dataNodeSelection)
 {
   m_StorageModel->SetDataNodeSelection(dataNodeSelection);
 }
 
 //////////////////////////////////////////////////////////////////////////
 // Implementation of the QT_SLOTS
 //////////////////////////////////////////////////////////////////////////
 void QmitkLesionInfoWidget::OnModelUpdated()
 {
   m_Controls.lesionTreeView->expandAll();
   int columns = m_Controls.lesionTreeView->model()->columnCount();
   for (int i = 0; i < columns; ++i)
   {
     m_Controls.lesionTreeView->resizeColumnToContents(i);
   }
 }
 
 void QmitkLesionInfoWidget::OnAddLesionButtonClicked()
 {
   if (m_CaseID.empty())
   {
-    QMessageBox msgBox;
-    msgBox.setWindowTitle("No case ID set.");
-    msgBox.setText("In order to add a lesion, please specify the current case / patient.");
-    msgBox.setIcon(QMessageBox::Warning);
+    QMessageBox msgBox(QMessageBox::Warning,
+      "No case ID set.",
+      "In order to add a lesion, please specify the current case / patient.");
     msgBox.exec();
     return;
   }
 
   mitk::SemanticTypes::Lesion newLesion = mitk::GenerateNewLesion();
   try
   {
     m_SemanticRelationsIntegration->AddLesion(m_CaseID, newLesion);
   }
   catch (mitk::SemanticRelationException& e)
   {
     MITK_INFO << "Could not add a new lesion. " << e;
   }
 }
 
-void QmitkLesionInfoWidget::OnSelectionChanged(const QModelIndex& current, const QModelIndex& previous)
+void QmitkLesionInfoWidget::OnSelectionChanged(const QModelIndex& current, const QModelIndex& /*previous*/)
 {
   // only the UID is needed to identify a representing lesion
   QVariant data = m_StorageModel->data(current, Qt::UserRole);
   if (!data.canConvert<QmitkLesionTreeItem*>())
   {
     return;
   }
 
   auto lesion = data.value<QmitkLesionTreeItem*>()->GetData().GetLesion();
   if (false == mitk::SemanticRelationsInference::InstanceExists(m_CaseID, lesion))
   {
     // no UID of a existing lesion found; cannot create a lesion
     return;
   }
 
   // if selected data nodes are set, reset to empty list to
   // hide "selected data nodes presence background highlighting" in the model
   if (!m_StorageModel->GetSelectedDataNodes().isEmpty())
   {
     m_StorageModel->SetDataNodeSelection(QList<mitk::DataNode::Pointer>());
   }
 
   emit LesionSelectionChanged(lesion);
 }
 
 void QmitkLesionInfoWidget::OnLesionListContextMenuRequested(const QPoint& pos)
 {
   if (nullptr == m_SemanticRelationsIntegration)
   {
     return;
   }
 
   if (m_CaseID.empty())
   {
     QMessageBox msgBox(QMessageBox::Warning,
       "No case ID set.",
       "In order to access the context menu entries a case ID has to be set.");
     msgBox.exec();
     return;
   }
 
   QModelIndex index = m_Controls.lesionTreeView->indexAt(pos);
   if (!index.isValid())
   {
     // no item clicked; cannot retrieve the current lesion
     return;
   }
 
   QVariant data = m_StorageModel->data(index, Qt::UserRole);
   mitk::SemanticTypes::Lesion selectedLesion;
   if (data.canConvert<QmitkLesionTreeItem*>())
   {
     selectedLesion = data.value<QmitkLesionTreeItem*>()->GetData().GetLesion();
   }
   else
   {
     return;
   }
 
   QMenu* menu = new QMenu(m_Controls.lesionTreeView);
 
   QAction* linkToSegmentation = new QAction("Link to segmentation", this);
   linkToSegmentation->setEnabled(true);
   connect(linkToSegmentation, &QAction::triggered, [this, selectedLesion] { OnLinkToSegmentation(selectedLesion); });
   menu->addAction(linkToSegmentation);
 
   QAction* setLesionName = new QAction("Set lesion name", this);
   setLesionName->setEnabled(true);
   connect(setLesionName, &QAction::triggered, [this, selectedLesion] { OnSetLesionName(selectedLesion); });
   menu->addAction(setLesionName);
 
   QAction* setLesionClass = new QAction("Set lesion class", this);
   setLesionClass->setEnabled(true);
   connect(setLesionClass, &QAction::triggered, [this, selectedLesion] { OnSetLesionClass(selectedLesion); });
   menu->addAction(setLesionClass);
 
   QAction* propageLesionToImage = new QAction("Propagate lesion to image", this);
   propageLesionToImage->setEnabled(true);
   connect(propageLesionToImage, &QAction::triggered, [this, selectedLesion] { OnPropagateLesion(selectedLesion); });
   menu->addAction(propageLesionToImage);
 
   QAction* removeLesion = new QAction("Remove lesion", this);
   removeLesion->setEnabled(true);
   connect(removeLesion, &QAction::triggered, [this, selectedLesion] { OnRemoveLesion(selectedLesion); });
   menu->addAction(removeLesion);
 
   menu->popup(QCursor::pos());
 }
 
 void QmitkLesionInfoWidget::OnLinkToSegmentation(mitk::SemanticTypes::Lesion selectedLesion)
 {
   if (m_DataStorage.IsExpired())
   {
     return;
   }
 
   auto dataStorage = m_DataStorage.Lock();
 
   QmitkSemanticRelationsNodeSelectionDialog* dialog = new QmitkSemanticRelationsNodeSelectionDialog(this, "Select segmentation to link to the selected lesion.", "");
   dialog->setWindowTitle("Select segmentation node");
   dialog->SetDataStorage(dataStorage);
   dialog->SetNodePredicate(mitk::NodePredicates::GetSegmentationPredicate());
   dialog->SetSelectOnlyVisibleNodes(true);
   dialog->SetCaseID(m_CaseID);
 
   int dialogReturnValue = dialog->exec();
   if (QDialog::Rejected == dialogReturnValue)
   {
     return;
   }
 
   auto nodes = dialog->GetSelectedNodes();
   mitk::DataNode::Pointer selectedDataNode = nullptr;
   if (!nodes.isEmpty())
   {
     // only single selection allowed
     selectedDataNode = nodes.front();
   }
 
   if (nullptr == selectedDataNode
     || false == mitk::NodePredicates::GetSegmentationPredicate()->CheckNode(selectedDataNode))
   {
     QMessageBox msgBox(QMessageBox::Warning,
       "No valid segmentation node selected.",
       "In order to link the selected lesion to a segmentation, please specify a valid segmentation node.");
     msgBox.exec();
     return;
   }
 
   mitk::BaseData* baseData = selectedDataNode->GetData();
   if (nullptr == baseData)
   {
     QMessageBox msgBox(QMessageBox::Warning,
       "No valid base data.",
       "In order to link the selected lesion to a segmentation, please specify a valid segmentation node.");
     msgBox.exec();
     return;
   }
 
   try
   {
     m_SemanticRelationsIntegration->LinkSegmentationToLesion(selectedDataNode, selectedLesion);
   }
   catch (const mitk::SemanticRelationException& e)
   {
 
     std::stringstream exceptionMessage;
     exceptionMessage << e;
     QMessageBox msgBox(QMessageBox::Warning,
       "Could not link the selected lesion.",
       "The program wasn't able to correctly link the selected lesion with the selected segmentation.\n"
       "Reason:\n" + QString::fromStdString(exceptionMessage.str()));
     msgBox.exec();
   }
 }
 
 void QmitkLesionInfoWidget::OnSetLesionName(mitk::SemanticTypes::Lesion selectedLesion)
 {
   // use the lesion information to set the input text for the dialog
   QmitkLesionTextDialog* inputDialog = new QmitkLesionTextDialog(this);
   inputDialog->setWindowTitle("Set lesion name");
   inputDialog->SetLineEditText(selectedLesion.name);
 
   int dialogReturnValue = inputDialog->exec();
   if (QDialog::Rejected == dialogReturnValue)
   {
     return;
   }
 
   selectedLesion.name = inputDialog->GetLineEditText().toStdString();
   m_SemanticRelationsIntegration->OverwriteLesion(m_CaseID, selectedLesion);
 }
 
 void QmitkLesionInfoWidget::OnSetLesionClass(mitk::SemanticTypes::Lesion selectedLesion)
 {
   // use the lesion information to set the input text for the dialog
   QmitkLesionTextDialog* inputDialog = new QmitkLesionTextDialog(this);
   inputDialog->setWindowTitle("Set lesion class");
   inputDialog->SetLineEditText(selectedLesion.lesionClass.classType);
 
   // prepare the completer for the dialogs input text field
   mitk::LesionClassVector allLesionClasses = mitk::SemanticRelationsInference::GetAllLesionClassesOfCase(m_CaseID);
 
   QStringList wordList;
   for (const auto& lesionClass : allLesionClasses)
   {
     wordList << QString::fromStdString(lesionClass.classType);
   }
   QCompleter* completer = new QCompleter(wordList, this);
   completer->setCaseSensitivity(Qt::CaseInsensitive);
   inputDialog->GetLineEdit()->setCompleter(completer);
 
   int dialogReturnValue = inputDialog->exec();
   if (QDialog::Rejected == dialogReturnValue)
   {
     return;
   }
 
   // retrieve the new input lesion class type and check for an already existing lesion class types
   std::string newLesionClassType = inputDialog->GetLineEditText().toStdString();
   mitk::SemanticTypes::LesionClass existingLesionClass = mitk::FindExistingLesionClass(newLesionClassType, allLesionClasses);
   if (existingLesionClass.UID.empty())
   {
     // could not find lesion class information for the new lesion class type
     // create a new lesion class for the selected lesion
     existingLesionClass = mitk::GenerateNewLesionClass(newLesionClassType);
   }
 
   selectedLesion.lesionClass = existingLesionClass;
   m_SemanticRelationsIntegration->OverwriteLesion(m_CaseID, selectedLesion);
 }
 
 void QmitkLesionInfoWidget::OnPropagateLesion(mitk::SemanticTypes::Lesion selectedLesion)
 {
   if (m_DataStorage.IsExpired())
   {
     return;
   }
 
   auto dataStorage = m_DataStorage.Lock();
 
   QmitkSemanticRelationsNodeSelectionDialog* dialog = new QmitkSemanticRelationsNodeSelectionDialog(this, "Select data node to propagate the selected lesion.", "");
   dialog->setWindowTitle("Select image node");
   dialog->SetDataStorage(dataStorage);
   dialog->SetNodePredicate(mitk::NodePredicates::GetImagePredicate());
   dialog->SetSelectOnlyVisibleNodes(true);
   dialog->SetCaseID(m_CaseID);
   dialog->SetLesion(selectedLesion);
 
   int dialogReturnValue = dialog->exec();
   if (QDialog::Rejected == dialogReturnValue)
   {
     return;
   }
 
   auto nodes = dialog->GetSelectedNodes();
   mitk::DataNode::Pointer selectedDataNode = nullptr;
   if (!nodes.isEmpty())
   {
     // only single selection allowed
     selectedDataNode = nodes.front();
   }
 
   if (nullptr == selectedDataNode
     || false == mitk::NodePredicates::GetImagePredicate()->CheckNode(selectedDataNode))
   {
     QMessageBox msgBox(QMessageBox::Warning,
       "No valid image node selected.",
       "In order to propagate the selected lesion to an image, please specify a valid image node.");
     msgBox.exec();
     return;
   }
 
   mitk::BaseData* baseData = selectedDataNode->GetData();
   if (nullptr == baseData)
   {
     QMessageBox msgBox(QMessageBox::Warning,
       "No valid base data.",
       "In order to propagate the selected lesion to an image, please specify a valid image node.");
     msgBox.exec();
     return;
   }
 
   try
   {
+    /*
     mitk::LesionPropagation lesionPropagation(dataStorage);
     auto segmentationMask = lesionPropagation.FindClosestSegmentationMask(m_CaseID, selectedLesion, selectedDataNode);
     if (nullptr == segmentationMask)
     {
       return;
     }
 
     auto propagatedSegmentation = lesionPropagation.PropagateSegmentationMask(m_CaseID, segmentationMask, selectedDataNode);
     AddToSemanticRelationsAction::Run(m_SemanticRelationsIntegration.get(), dataStorage, propagatedSegmentation);
     m_SemanticRelationsIntegration->LinkSegmentationToLesion(propagatedSegmentation, selectedLesion);
+    */
   }
   catch (const mitk::SemanticRelationException& e)
   {
     std::stringstream exceptionMessage;
     exceptionMessage << e;
     QMessageBox msgBox(QMessageBox::Warning,
       "Could not propagate the selected lesion.",
       "The program wasn't able to correctly propagate the selected lesion to the selected image.\n"
       "Reason:\n" + QString::fromStdString(exceptionMessage.str()));
     msgBox.exec();
   }
 }
 
 void QmitkLesionInfoWidget::OnRemoveLesion(mitk::SemanticTypes::Lesion selectedLesion)
 {
   try
   {
     m_SemanticRelationsIntegration->RemoveLesion(m_CaseID, selectedLesion);
   }
   catch (const mitk::SemanticRelationException& e)
   {
 
     std::stringstream exceptionMessage;
     exceptionMessage << e;
     QMessageBox msgBox(QMessageBox::Warning,
       "Could not remove the selected lesion.",
       "The program wasn't able to correctly remove the selected lesion from the semantic relations model.\n"
       "Reason:\n" + QString::fromStdString(exceptionMessage.str()));
     msgBox.exec();
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLesionInfoWidget.h b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLesionInfoWidget.h
index 977fa7471f..437edeb875 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLesionInfoWidget.h
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLesionInfoWidget.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 QMITKLESIONINFOWIDGET_H
 #define QMITKLESIONINFOWIDGET_H
 
 // semantic relations plugin
 #include <ui_QmitkLesionInfoWidgetControls.h>
 
 // semantic relations UI module
 #include <QmitkLesionTreeModel.h>
 
 // semantic relations module
 #include <mitkSemanticRelationsDataStorageAccess.h>
 #include <mitkSemanticRelationsIntegration.h>
 
 // mitk core
 #include <mitkDataStorage.h>
 
 // qt
 #include <QWidget>
 
 /*
 * @brief The QmitkLesionInfoWidget is a widget that shows and modifies the currently available lesion data of the semantic relations model.
 *
 *   The widget provides a dialogs to add nodes from the data storage to the semantic relations model.
 *   It provides functionality to create new lesions and link them with segmentation nodes.
 *
 *   The QmitkLesionInfoWidget provides three QListWidgets, that show the lesion data and the referenced segmentation data, as
 *   well as the connected image data, depending on the selected lesion.
 */
 class QmitkLesionInfoWidget : public QWidget
 {
   Q_OBJECT
 
 public:
 
   static const QBrush DEFAULT_BACKGROUND_COLOR;
   static const QBrush SELECTED_BACKGROUND_COLOR;
   static const QBrush CONNECTED_BACKGROUND_COLOR;
 
-  QmitkLesionInfoWidget::QmitkLesionInfoWidget(mitk::DataStorage* dataStorage, QWidget* parent = nullptr);
+  QmitkLesionInfoWidget(mitk::DataStorage* dataStorage, QWidget* parent = nullptr);
   ~QmitkLesionInfoWidget();
 
   void SetCaseID(const mitk::SemanticTypes::CaseID& caseID);
 
   void SetDataNodeSelection(const QList<mitk::DataNode::Pointer>& dataNodeSelection);
 
 Q_SIGNALS:
 
   void LesionSelectionChanged(const mitk::SemanticTypes::Lesion&);
 
 private Q_SLOTS:
 
   void OnModelUpdated();
   /*
   * @brief Generates a new, empty lesion to add to the semantic relations model for the current case ID.
   */
   void OnAddLesionButtonClicked();
 
   // slots for the mouse click events of tree view's selection model
   void OnSelectionChanged(const QModelIndex& current, const QModelIndex& previous);
 
   void OnLesionListContextMenuRequested(const QPoint&);
 
   // slots for the context menu actions of the lesion list widget
   void OnLinkToSegmentation(mitk::SemanticTypes::Lesion);
   void OnSetLesionName(mitk::SemanticTypes::Lesion);
   void OnSetLesionClass(mitk::SemanticTypes::Lesion);
   void OnPropagateLesion(mitk::SemanticTypes::Lesion);
   void OnRemoveLesion(mitk::SemanticTypes::Lesion);
 
 private:
 
   void Initialize();
   void SetUpConnections();
 
   Ui::QmitkLesionInfoWidgetControls m_Controls;
   QmitkLesionTreeModel* m_StorageModel;
 
   mitk::SemanticTypes::CaseID m_CaseID;
 
   mitk::WeakPointer<mitk::DataStorage> m_DataStorage;
   std::unique_ptr<mitk::SemanticRelationsDataStorageAccess> m_SemanticRelationsDataStorageAccess;
   std::unique_ptr<mitk::SemanticRelationsIntegration> m_SemanticRelationsIntegration;
 
 };
 
 #endif // QMITKLESIONINFOWIDGET_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 8166a94d17..2c5a87bcf4 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.cpp
@@ -1,280 +1,273 @@
 /*===================================================================
 
 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 "QmitkDataNodeAddToSemanticRelationsAction.h"
 #include "QmitkDataNodeRemoveFromSemanticRelationsAction.h"
 
 // semantic relations module
 #include <mitkDICOMHelper.h>
 #include <mitkNodePredicates.h>
-#include <mitkSemanticRelationException.h>
 #include <mitkSemanticRelationsInference.h>
 #include <mitkRelationStorage.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);
 
   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();
 
   const auto& allCaseIDs = mitk::RelationStorage::GetAllCaseIDs();
   for (const auto& caseID : allCaseIDs)
   {
     AddToComboBox(caseID);
   }
 }
 
 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 (mitk::SemanticRelationsInference::InstanceExists(dataNode))
   {
     // no observer needed for the integration; simply use a temporary instance for removing
     mitk::SemanticRelationsIntegration semanticRelationsIntegration;
     RemoveFromSemanticRelationsAction::Run(&semanticRelationsIntegration, 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)
+void QmitkSemanticRelationsView::OnNodesAdded(std::vector<mitk::DataNode*> nodes)
 {
   mitk::SemanticTypes::CaseID caseID = "";
   for (mitk::DataNode* dataNode : nodes)
   {
     // no observer needed for the integration; simply use a temporary instance for adding
     mitk::SemanticRelationsIntegration semanticRelationsIntegration;
     AddToSemanticRelationsAction::Run(&semanticRelationsIntegration, 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 = mitk::RelationStorage::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(mitk::WorkbenchUtil::IRenderWindowPartStrategy::BRING_TO_FRONT | mitk::WorkbenchUtil::IRenderWindowPartStrategy::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();
+  unsigned 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(mitk::WorkbenchUtil::IRenderWindowPartStrategy::BRING_TO_FRONT | mitk::WorkbenchUtil::IRenderWindowPartStrategy::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);
     }
   }
 }
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 68341a9722..725696107d 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.h
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkSemanticRelationsView.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 QMITKSEMANTICRELATIONSVIEW_H
 #define QMITKSEMANTICRELATIONSVIEW_H
 
 // semantic relations plugin
 #include "ui_QmitkSemanticRelationsControls.h"
 #include "QmitkLesionInfoWidget.h"
 #include "QmitkSemanticRelationsContextMenu.h"
 
 // semantic relations module
 #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.
 */
 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;
+  virtual void RenderWindowPartDeactivated(mitk::IRenderWindowPart*) override { }
 
 private Q_SLOTS:
 
   void OnLesionSelectionChanged(const mitk::SemanticTypes::Lesion&);
   void OnDataNodeSelectionChanged(const QList<mitk::DataNode::Pointer>&);
   void OnDataNodeDoubleClicked(const mitk::DataNode*);
   void OnCaseIDSelectionChanged(const QString&);
 
-  void OnNodesAdded(QmitkDnDDataNodeWidget*, std::vector<mitk::DataNode*>);
+  void OnNodesAdded(std::vector<mitk::DataNode*>);
   void OnNodeRemoved(const mitk::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 AddToComboBox(const mitk::SemanticTypes::CaseID& caseID);
   void RemoveFromComboBox(const mitk::SemanticTypes::CaseID& caseID);
 
   void OpenInEditor(const mitk::DataNode* dataNode);
   void JumpToPosition(const mitk::DataNode* dataNode);
 
   Ui::QmitkSemanticRelationsControls m_Controls;
   QmitkLesionInfoWidget* m_LesionInfoWidget;
   QmitkPatientTableInspector* m_PatientTableInspector;
   QmitkDnDDataNodeWidget* m_DnDDataNodeWidget;
 
   QmitkSemanticRelationsContextMenu* m_ContextMenu;
 };
 
 #endif // QMITKSEMANTICRELATIONSVIEW_H