diff --git a/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingThread.cpp b/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingThread.cpp
index 72a2724c0d..82c669ad98 100644
--- a/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingThread.cpp
+++ b/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingThread.cpp
@@ -1,207 +1,197 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkRegionGrowingThread.h"
 
 #include "MitkRegionIterator.h"
 
 // MITK
 #include <mitkImageAccessByItk.h>
 #include <mitkImageCast.h>
 #include <mitkProperties.h>
 
 // itk
 #include <itkConnectedThresholdImageFilter.h>
 #include <itkMaskImageFilter.h>
 #include <itkRegionOfInterestImageFilter.h>
 
 QmitkRegionGrowingThread::QmitkRegionGrowingThread() 
   : m_ThresholdMethod(ThresholdMethod::easy)
   , m_Image(nullptr)
   , m_PointSet(nullptr)
 {
   // nothing here
 }
 
 void QmitkRegionGrowingThread::run()
 {
   // actually perform region growing. Here we have both an image and some seed points
   AccessByItk_1(m_Image, ItkImageProcessing, m_Image->GetGeometry())
 }
 
 void QmitkRegionGrowingThread::SetImage(mitk::Image *image)
 {
   m_Image = image;
 }
 
 void QmitkRegionGrowingThread::ResetResults()
 {
   m_RegionGrowingResultVector.clear();
 }
 
 QmitkRegionGrowingThread::ThresholdMethod QmitkRegionGrowingThread::GetThresholdMethod()
 {
   return m_ThresholdMethod;
 }
 
 void QmitkRegionGrowingThread::SetThresholdMethod(QmitkRegionGrowingThread::ThresholdMethod thresholdMethod)
 {
   m_ThresholdMethod = thresholdMethod;
 }
 
 mitk::PointSet::Pointer QmitkRegionGrowingThread::GetPointSet()
 {
   return m_PointSet;
 }
 
 void QmitkRegionGrowingThread::SetPointSet(mitk::PointSet::Pointer pointSet)
 {
   m_PointSet = pointSet;
 }
 
-QVector<mitk::DataNode::Pointer> QmitkRegionGrowingThread::GetRegionGrowingResultVector()
+QVector<mitk::Image::Pointer> QmitkRegionGrowingThread::GetRegionGrowingResultVector()
 {
   return m_RegionGrowingResultVector;
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void QmitkRegionGrowingThread::ItkImageProcessing(itk::Image<TPixel, VImageDimension> *itkImage,
   mitk::BaseGeometry *imageGeometry)
 {
   typedef itk::Image<TPixel, VImageDimension> InputImageType;
 
   typedef typename InputImageType::RegionType              RegionType;
   typedef typename InputImageType::RegionType::IndexType   IndexType;
   typedef typename InputImageType::RegionType::SizeType    SizeType;
 
   // instantiate an ITK region growing filter, set its parameters
   typedef itk::ConnectedThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
   typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
 
   // determine a thresholding interval
   IndexType seedIndex;
 
   mitk::PointSet::PointsContainer *points = m_PointSet->GetPointSet()->GetPoints();
   int iteration = 0;
   //m_Controls->progressBar->setMaximum(points->Size());
   for (mitk::PointSet::PointsConstIterator pointsIterator = points->Begin(); pointsIterator != points->End();
     ++pointsIterator)
   {
     //m_Controls->progressBar->setValue((int)iteration++);
     emit UpdateProgressBar(iteration++);
 
     // first test if this point is inside the image at all
     if (!imageGeometry->IsInside(pointsIterator.Value()))
     {
       continue;
     }
 
     // convert world coordinates to image indices
     imageGeometry->WorldToIndex(pointsIterator.Value(), seedIndex);
 
     //=================================================
 
     MitkRegionIterator<InputImageType, IndexType> mitkRegionIterator(itkImage, 1);
     int thresholdRange = 0;
 
     //=================================================
 
     // get the pixel value at this point
     TPixel currentPixelValue = itkImage->GetPixel(seedIndex);
 
     switch (m_ThresholdMethod)
     {
     case 0:
       thresholdRange = 130;
       break;
     case 1:
       mitkRegionIterator.SetRadius(4);
       mitkRegionIterator.SetSpacing(
         itkImage->GetSpacing()[0],
         itkImage->GetSpacing()[1],
         itkImage->GetSpacing()[2]);
       thresholdRange = mitkRegionIterator.GetThresholdByStdDivMethod(seedIndex);
       break;
     }
 
     TPixel min = currentPixelValue - thresholdRange;
     TPixel max = currentPixelValue + thresholdRange;
 
     // adjust pixel to be inside the image pixel type range
     if (currentPixelValue < min)
     {
       min = std::numeric_limits<TPixel>::min();
     }
     if (currentPixelValue > max)
     {
       max = std::numeric_limits<TPixel>::max();
     }
 
     MITK_DEBUG << "Threshold range: " << thresholdRange;
     MITK_DEBUG << "Values between min: " << min << " and max: " << max;
 
     regionGrower->SetInput(itkImage);
 
     // set thresholds and execute filter
     regionGrower->AddSeed(seedIndex);
     regionGrower->SetLower(min);
     regionGrower->SetUpper(max);
 
     regionGrower->SetConnectivity(RegionGrowingFilterType::FaceConnectivity);
 
     int regionGrowingDiameter = 20;
     // define region for region growing
     IndexType centerIndex = seedIndex;
     centerIndex[0] -= regionGrowingDiameter / 2;
     centerIndex[1] -= regionGrowingDiameter / 2;
     centerIndex[2] -= regionGrowingDiameter / 4;
 
     // set maximum region for region growing
     SizeType size;
     size.Fill(regionGrowingDiameter);
     size[0] = regionGrowingDiameter;
     size[1] = regionGrowingDiameter;
     size[2] = regionGrowingDiameter / 2;
 
     RegionType regionOfInterest(centerIndex, size);
     regionOfInterest.Crop(itkImage->GetLargestPossibleRegion());
 
     typedef itk::RegionOfInterestImageFilter<InputImageType, InputImageType> ROIFilterType;
     ROIFilterType::Pointer roiFilter = ROIFilterType::New();
 
     roiFilter->SetRegionOfInterest(regionOfInterest);
     roiFilter->SetInput(regionGrower->GetOutput());
     roiFilter->Update();
 
     mitk::Image::Pointer resultImage;
     mitk::CastToMitkImage(roiFilter->GetOutput(), resultImage);
-    mitk::DataNode::Pointer newNode = mitk::DataNode::New();
-    newNode->SetData(resultImage);
-
-    // set some properties
-    newNode->SetProperty("binary", mitk::BoolProperty::New(true));
-    newNode->SetProperty("name", mitk::StringProperty::New("dumb segmentation"));
-    newNode->SetProperty("color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
-    newNode->SetProperty("volumerendering", mitk::BoolProperty::New(true));
-    newNode->SetProperty("layer", mitk::IntProperty::New(1));
-    newNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
-
-    m_RegionGrowingResultVector.append(newNode);
+
+    m_RegionGrowingResultVector.append(resultImage);
     regionGrower->ClearSeeds();
   }
 
   emit UpdateProgressBar(static_cast<int>(points->Size()));
 }
diff --git a/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingThread.h b/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingThread.h
index 2ac42f59cb..6e9d35ea4f 100644
--- a/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingThread.h
+++ b/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingThread.h
@@ -1,74 +1,74 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QMITKREGIONGROWINGTHREAD_H
 #define QMITKREGIONGROWINGTHREAD_H
 
-#include <mitkDataNode.h>
+#include <mitkImage.h>
 #include <mitkPointSet.h>
 
 // QT
 #include <QVector>
 #include <QThread>
 
 // itk
 #include <itkImage.h>
 
 class QmitkRegionGrowingThread : public QThread
 {
   Q_OBJECT
 
 Q_SIGNALS:
 
   void UpdateProgressBar(int value);
 
 public:
 
   QmitkRegionGrowingThread();
 
   /**
   \brief ITK image processing function
   This function is templated like an ITK image. The MITK-Macro AccessByItk determines the actual pixel type and
   dimensionality of
   a given MITK image and calls this function for further processing (in our case region growing)
   */
   template <typename TPixel, unsigned int VImageDimension>
   void ItkImageProcessing(itk::Image<TPixel, VImageDimension> *itkImage, mitk::BaseGeometry *imageGeometry);
 
   /* brief Method called once the thread is executed. */
   void run() override;
 
   void SetImage(mitk::Image *image);
   void ResetResults();
 
   mitk::PointSet::Pointer GetPointSet();
   void SetPointSet(mitk::PointSet::Pointer pointSet);
 
   enum ThresholdMethod { easy, stddiv } m_ThresholdMethod;
 
   ThresholdMethod GetThresholdMethod();
   void SetThresholdMethod(ThresholdMethod thresholdMethod);
 
-  QVector<mitk::DataNode::Pointer> GetRegionGrowingResultVector();
+  QVector<mitk::Image::Pointer> GetRegionGrowingResultVector();
 
   mitk::Image* m_Image;
   mitk::PointSet::Pointer m_PointSet;
 
-  QVector<mitk::DataNode::Pointer> m_RegionGrowingResultVector;
+  QVector<mitk::Image::Pointer> m_RegionGrowingResultVector;
 
 };
 
 #endif //QMITKREGIONGROWINGTHREAD_H
diff --git a/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.cpp b/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.cpp
index f54c61f7af..3f9db4964b 100644
--- a/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.cpp
+++ b/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.cpp
@@ -1,285 +1,391 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // mitk gui qt regiongrowing plugin
 #include "QmitkRegionGrowingView.h"
 #include "MitkRegionIterator.h"
 
+// semantic relations
+#include <mitkDICOMHelper.h>
+#include <mitkLesionManager.h>
+#include <mitkSemanticRelationException.h>
+#include <mitkSemanticRelationsInference.h>
+#include <QmitkDataNodeAddToSemanticRelationsAction.h>
+
 // Blueberry
-#include <berryISelectionService.h>
-#include <berryIWorkbenchWindow.h>
+//#include <berryISelectionService.h>
+//#include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkPointListWidget.h"
 #include "QmitkRenderWindow.h"
 
 // MITK
-#include "mitkColorProperty.h"
-#include "mitkITKImageImport.h"
-#include "mitkProperties.h"
+#include <mitkDICOMQIPropertyHelper.h>
+#include <mitkColorProperty.h>
+#include <mitkLabelSetImage.h>
+#include <mitkProperties.h>
 
 // ITK
 #include "itksys/SystemTools.hxx"
 
 // Qt
 #include <QMessageBox>
 
 const std::string QmitkRegionGrowingView::VIEW_ID = "org.mitk.views.example.regiongrowing";
 
 QmitkRegionGrowingView::QmitkRegionGrowingView()
   : m_PointListWidget(nullptr)
+  , m_SemanticRelationsIntegration(std::make_unique<mitk::SemanticRelationsIntegration>())
 {
   m_RegionGrowingThread = new QmitkRegionGrowingThread();
 }
 
 QmitkRegionGrowingView::~QmitkRegionGrowingView()
 {
   if (!m_RegionGrowingThread->isFinished())
   {
     m_RegionGrowingThread->terminate();
     m_RegionGrowingThread->wait();
   }
   m_RegionGrowingThread->deleteLater();
 }
 
 void QmitkRegionGrowingView::SetFocus()
 {
   m_Controls->buttonPerformImageProcessing->setFocus();
 }
 
 void QmitkRegionGrowingView::CreateQtPartControl(QWidget *parent)
 {
   m_Controls = new Ui::QmitkRegionGrowingViewControls;
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls->setupUi(parent);
 
   //add different methods for threshold determination
   m_Controls->comboBoxThresholdMethod->addItem("easy");
   m_Controls->comboBoxThresholdMethod->addItem("stddiv");
 
   this->connectSignals();
 
   // create a QmitkPointListWidget and add it to the widget created from .ui file
   m_PointListWidget = new QmitkPointListWidget(parent);
   m_Controls->verticalLayout->addWidget(m_PointListWidget, 1);
 
   // retrieve a possibly existing IRenderWindowPart
   if (mitk::IRenderWindowPart *renderWindowPart = GetRenderWindowPart())
   {
     // let the point set widget know about the render window part (crosshair updates)
     RenderWindowPartActivated(renderWindowPart);
   }
 
   this->setupPointSetNode();
 
   m_Controls->buttonPerformImageProcessing->setEnabled(false);
   m_Controls->pushButtonAddPointList->setEnabled(false);
   m_Controls->progressBar->setMinimum(0);
   m_Controls->progressBar->setMaximum(0);
   m_Controls->progressBar->hide();
 }
 
 void QmitkRegionGrowingView::connectSignals()
 {
   connect(m_Controls->buttonPerformImageProcessing, SIGNAL(clicked()), this, SLOT(OnStartRegionGrowing()));
   connect(m_Controls->checkBoxCustomRange, SIGNAL(clicked(bool)), this, SLOT(OnUseCustomRange(bool)));
   connect(m_Controls->pushButtonClearPointList, SIGNAL(clicked()), this, SLOT(OnClearPointSet()));
   connect(m_Controls->comboBoxThresholdMethod, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSetThresholdMethod(int)));
   connect(m_Controls->pushButtonAddPointList, SIGNAL(clicked()), this, SLOT(OnAddPointSet()));
   connect((QObject*) m_RegionGrowingThread, SIGNAL(finished()), this, SLOT(OnRegionGrowingThreadFinished()), Qt::QueuedConnection);
   connect((QObject*) m_RegionGrowingThread, SIGNAL(UpdateProgressBar(int)), this, SLOT(OnUpdateProgressBar(int)), Qt::QueuedConnection);
 }
 
 void QmitkRegionGrowingView::setupPointSetNode()
 {
   mitk::DataNode::Pointer pointSetNode = GetDataStorage()->GetNamedNode("seed points for region growing");
 
   if (pointSetNode == nullptr)
   {
     // create a new DataNode containing a PointSet with some interaction
     pointSetNode = mitk::DataNode::New();
     pointSetNode->SetData(mitk::PointSet::New());
     pointSetNode->SetName("seed points for region growing");
     pointSetNode->SetProperty("helper object", mitk::BoolProperty::New(true));
     pointSetNode->SetProperty("layer", mitk::IntProperty::New(1024));
 
     // add the pointset to the data storage (for rendering and access by other modules)
     GetDataStorage()->Add(pointSetNode);
   }
   // tell the GUI widget about the point set
   m_PointListWidget->SetPointSetNode(pointSetNode);
 }
 
 void QmitkRegionGrowingView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
                                                 const QList<mitk::DataNode::Pointer> &nodes)
 {
   // iterate all selected objects, adjust warning visibility
   for (const auto& node : nodes)
   {
     if (node.IsNotNull() && dynamic_cast<mitk::Image *>(node->GetData()) && !m_RegionGrowingThread->isRunning())
     {
       m_Controls->labelWarning->setVisible(false);
       m_Controls->buttonPerformImageProcessing->setEnabled(true);
       return;
     }
     else if (node.IsNotNull() && dynamic_cast<mitk::PointSet *>(node->GetData()))
     {
       m_Controls->pushButtonAddPointList->setEnabled(true);
       return;
     }
   }
   m_Controls->labelWarning->setVisible(true);
   m_Controls->buttonPerformImageProcessing->setEnabled(false);
   m_Controls->pushButtonAddPointList->setEnabled(false);
 }
 
 void QmitkRegionGrowingView::RenderWindowPartActivated(mitk::IRenderWindowPart *renderWindowPart)
 {
   // let the point set widget know about the slice navigation controllers
   // in the active render window part (crosshair updates)
   for (auto* renderWindow : renderWindowPart->GetQmitkRenderWindows().values())
   {
     m_PointListWidget->AddSliceNavigationController(renderWindow->GetSliceNavigationController());
   }
 }
 
 void QmitkRegionGrowingView::RenderWindowPartDeactivated(mitk::IRenderWindowPart *renderWindowPart)
 {
   for (auto* renderWindow : renderWindowPart->GetQmitkRenderWindows().values())
   {
     m_PointListWidget->RemoveSliceNavigationController(renderWindow->GetSliceNavigationController());
   }
 }
 
 void QmitkRegionGrowingView::OnStartRegionGrowing()
 {
   m_Controls->buttonPerformImageProcessing->setEnabled(false);
 
   m_Controls->progressBar->show();
   m_Controls->progressBar->setValue(0);
 
   mitk::PointSet::PointsContainer *points = m_PointListWidget->GetPointSet()->GetPointSet()->GetPoints();
   m_Controls->progressBar->setMaximum(points->Size());
 
   QList<mitk::DataNode::Pointer> nodes = GetDataManagerSelection();
   if (nodes.empty())
   {
     return;
   }
 
-  mitk::DataNode *node = nodes.front();
+  m_SelectedNode = nodes.front();
 
-  if (nullptr == node)
+  if (nullptr == m_SelectedNode)
   {
     // Nothing selected. Inform the user and return
-    QMessageBox::information(nullptr, "Template", "Please load and select an image before starting image processing.");
+    QMessageBox::information(nullptr, "Region growing view", "Please load and select an image before starting image processing.");
     return;
   }
 
   // a node itself is not very useful, we need its data item (the image)
-  mitk::BaseData *data = node->GetData();
+  mitk::BaseData *data = m_SelectedNode->GetData();
   if (nullptr != data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image *image = dynamic_cast<mitk::Image*>(data);
     if (nullptr != image)
     {
       // So we have an image. Let's see if the user has set some seed points already
       if (m_PointListWidget->GetPointSet()->GetSize() == 0)
       {
         // no points there. Not good for region growing
         QMessageBox::information(nullptr,
-                                 "Region growing functionality",
+                                 "Region growing view",
                                  "Please set some seed points inside the image first.\n"
                                  "(hold Shift key and click left mouse button inside the image.)");
         return;
       }
 
       m_RegionGrowingThread->SetImage(image);
       m_RegionGrowingThread->ResetResults();
       m_RegionGrowingThread->SetPointSet(m_PointListWidget->GetPointSet());
       m_RegionGrowingThread->start();
     }
   }
 }
 
 void QmitkRegionGrowingView::OnUseCustomRange(bool useCustomRange)
 {
   m_Controls->spinBoxMax->setEnabled(useCustomRange);
   m_Controls->spinBoxMin->setEnabled(useCustomRange);
 }
 
 void QmitkRegionGrowingView::OnAddPointSet()
 {
   QList<mitk::DataNode::Pointer> pointSetNodeList = GetDataManagerSelection();
-
   mitk::DataNode::Pointer pointSetNode = pointSetNodeList.first();
-
-  // tell the GUI widget about the point set
   m_PointListWidget->SetPointSetNode(pointSetNode);
 }
 
 void QmitkRegionGrowingView::OnClearPointSet()
 {
   QMessageBox::StandardButton reply;
-  reply = QMessageBox::question(nullptr, "Test", "Are you sure?", QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
+  reply = QMessageBox::question(nullptr, "Clear point set", "Are you sure?", QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
   if (reply == QMessageBox::Yes)
   {
     m_PointListWidget->GetPointSet()->Clear();
   }
   else
   {
-    //Clearing point set canceled
+    // Clearing point set canceled
   }
 }
 
 void QmitkRegionGrowingView::OnSetThresholdMethod(int index)
 {
   int currentIndex = m_Controls->comboBoxThresholdMethod->currentIndex();
 
   switch (currentIndex)
   {
   case 0:
     m_RegionGrowingThread->SetThresholdMethod(QmitkRegionGrowingThread::ThresholdMethod::easy);
     break;
   case 1:
     m_RegionGrowingThread->SetThresholdMethod(QmitkRegionGrowingThread::ThresholdMethod::stddiv);
     break;
   default:
     m_RegionGrowingThread->SetThresholdMethod(QmitkRegionGrowingThread::ThresholdMethod::easy);
     break;
   }
 }
 
 void QmitkRegionGrowingView::OnUpdateProgressBar(int value)
 {
   m_Controls->progressBar->setValue(value);
 }
 
 void QmitkRegionGrowingView::OnRegionGrowingThreadFinished()
 {
-  QVector<mitk::DataNode::Pointer> regionGrowingResultVector = m_RegionGrowingThread->GetRegionGrowingResultVector();
+  QVector<mitk::Image::Pointer> regionGrowingResultVector = m_RegionGrowingThread->GetRegionGrowingResultVector();
 
   for (const auto& regionGrowingResult : regionGrowingResultVector)
   {
-    // add result to data tree
-    GetDataStorage()->Add(regionGrowingResult);
-    mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+    CreateNewSegmentation(regionGrowingResult);
   }
 
   m_Controls->progressBar->hide();
   m_Controls->buttonPerformImageProcessing->setEnabled(true);
 }
+
+void QmitkRegionGrowingView::CreateNewSegmentation(mitk::Image::Pointer segmentation)
+{
+
+
+  if (nullptr == m_SelectedNode)
+  {
+    return;
+  }
+
+  mitk::BaseData* targetImageData = m_SelectedNode->GetData();
+  if (nullptr == targetImageData)
+  {
+    return;
+  }
+
+  if (nullptr == segmentation)
+  {
+    return;
+  }
+
+  // create new empty segmentation
+  auto labelSetImage = mitk::LabelSetImage::New();
+  // copy image data (e.g. pixel information)
+  labelSetImage->InitializeByLabeledImage(segmentation);
+
+  // copy DICOM information from the target image to the new segmentation
+  mitk::DICOMQIPropertyHandler::DeriveDICOMSourceProperties(targetImageData, labelSetImage);
+
+
+  auto newSegmentationNode = mitk::DataNode::New();
+  newSegmentationNode->SetData(labelSetImage);
+  newSegmentationNode->SetProperty("binary", mitk::BoolProperty::New(true));
+  newSegmentationNode->SetProperty("color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
+  newSegmentationNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
+
+  // add result to data tree
+  GetDataStorage()->Add(newSegmentationNode, m_SelectedNode);
+
+  AddNewSegmentationToSemanticRelations(newSegmentationNode);
+}
+
+void QmitkRegionGrowingView::AddNewSegmentationToSemanticRelations(mitk::DataNode* newSegmentationNode)
+{
+  // if the segmentation is not contained in the semantic relations, add it
+  if (!mitk::SemanticRelationsInference::InstanceExists(newSegmentationNode))
+  {
+    AddToSemanticRelationsAction::Run(m_SemanticRelationsIntegration.get(), GetDataStorage(), newSegmentationNode);
+  }
+
+  // segmentation has been added, IDs have to be valid now
+  mitk::SemanticTypes::CaseID caseID = "";
+  mitk::SemanticTypes::ID segmentationID = "";
+  try
+  {
+    caseID = mitk::GetCaseIDFromDataNode(m_SelectedNode);
+    segmentationID = mitk::GetIDFromDataNode(newSegmentationNode);
+  }
+  catch (mitk::SemanticRelationException& e)
+  {
+    std::stringstream exceptionMessage; exceptionMessage << e;
+    QMessageBox msgBox(QMessageBox::Warning,
+      "Could not retrieve the segmentation node IDs.",
+      "The program wasn't able to correctly process a new segmentation.\n"
+      "Reason:\n" + QString::fromStdString(exceptionMessage.str()));
+    msgBox.exec();
+  }
+
+  // create name using the newly generated segmentation ID
+  newSegmentationNode->SetProperty("name", mitk::StringProperty::New(segmentationID));
+
+  // create a new lesion and link segmentation
+  mitk::SemanticTypes::Lesion newLesion = mitk::GenerateNewLesion();
+  newLesion.name = segmentationID;
+  try
+  {
+    m_SemanticRelationsIntegration->AddLesion(caseID, newLesion);
+  }
+  catch (mitk::SemanticRelationException& e)
+  {
+    std::stringstream exceptionMessage; exceptionMessage << e;
+    QMessageBox msgBox(QMessageBox::Warning,
+      "Could not create a new lesion to link the new segmentation.",
+      "The program wasn't able to correctly add a new lesion.\n"
+      "Reason:\n" + QString::fromStdString(exceptionMessage.str()));
+    msgBox.exec();
+  }
+
+  try
+  {
+    m_SemanticRelationsIntegration->LinkSegmentationToLesion(newSegmentationNode, newLesion);
+  }
+  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();
+  }
+}
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.h b/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.h
index cacb37914f..3d41047452 100644
--- a/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.h
+++ b/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.h
@@ -1,88 +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 QmitkRegionGrowingView_h
 #define QmitkRegionGrowingView_h
 
+#include "ui_QmitkRegionGrowingViewControls.h"
+
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
-#include "ui_QmitkRegionGrowingViewControls.h"
-
-#include "mitkIRenderWindowPartListener.h"
-#include <itkImage.h>
+#include <mitkDataNode.h>
+#include <mitkImage.h>
+#include <mitkIRenderWindowPartListener.h>
 
 #include "QmitkRegionGrowingThread.h"
 
+// semantic relations
+#include <mitkSemanticRelationsIntegration.h>
+
 class QmitkPointListWidget;
 
 /**
   \brief QmitkRegionGrowingView
 */
 class QmitkRegionGrowingView : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   QmitkRegionGrowingView();
   ~QmitkRegionGrowingView();
 
 protected Q_SLOTS:
 
   /// \brief Called when the user clicks the GUI button
   void OnStartRegionGrowing();
 
   void OnUseCustomRange(bool useCustomRange);
 
   void OnAddPointSet();
 
   void OnClearPointSet();
 
   void OnSetThresholdMethod(int index);
 
 protected:
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   virtual void SetFocus() override;
 
   virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer source,
                                   const QList<mitk::DataNode::Pointer> &nodes) override;
 
   void RenderWindowPartActivated(mitk::IRenderWindowPart *renderWindowPart) override;
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart *renderWindowPart) override;
 
   Ui::QmitkRegionGrowingViewControls* m_Controls;
 
 private Q_SLOTS:
 
   void OnUpdateProgressBar(int value);
   void OnRegionGrowingThreadFinished();
 
 private:
 
   void connectSignals();
   void setupPointSetNode();
 
+  void CreateNewSegmentation(mitk::Image::Pointer segmentation);
+  void AddNewSegmentationToSemanticRelations(mitk::DataNode* newSegmentationNode);
+
+  std::unique_ptr<mitk::SemanticRelationsIntegration> m_SemanticRelationsIntegration;
   QmitkRegionGrowingThread* m_RegionGrowingThread;
-  QmitkPointListWidget *m_PointListWidget;
+  QmitkPointListWidget* m_PointListWidget;
+  mitk::DataNode* m_SelectedNode;
+
 };
 
 #endif // QmitkRegionGrowingView_h