diff --git a/Modules/CppRestSdk/src/mitkRESTClient.cpp b/Modules/CppRestSdk/src/mitkRESTClient.cpp
index 4b580b3d24..b12abdec29 100644
--- a/Modules/CppRestSdk/src/mitkRESTClient.cpp
+++ b/Modules/CppRestSdk/src/mitkRESTClient.cpp
@@ -1,146 +1,146 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkRESTClient.h"
 #include "mitkRESTUtil.h"
 
 #include <mitkCommon.h>
 
 mitk::RESTClient::RESTClient(utility::string_t url)
 {
   m_Client = new MitkClient(url);
 }
 
 mitk::RESTClient::~RESTClient()
 {
   delete m_Client;
 }
 
 pplx::task<web::json::value> mitk::RESTClient::PUT(utility::string_t uri, web::json::value content)
 {
   MITK_DEBUG << "Calling PUT with " << utility::conversions::to_utf8string(uri) << " on client "
     << mitk::RESTUtil::convertToUtf8(m_Client->base_uri().to_string());
 
   MitkRequest putRequest(MitkRESTMethods::PUT);
   putRequest.set_request_uri(uri);
   putRequest.set_body(content);
 
   return m_Client->request(putRequest).then([=](MitkResponse response)
   {
     auto status = response.status_code();
     MITK_INFO << " status: " << status;
 
     if (status != web::http::status_codes::OK) {
       mitkThrow() << "response was not OK";
     }
 
     return response.extract_json().get();
   });
 }
 
 pplx::task<web::json::value> mitk::RESTClient::Get(utility::string_t uri)
 {
-  MITK_DEBUG << "Calling GET with " << utility::conversions::to_utf8string(uri) << " on client "
+  MITK_INFO << "Calling GET with " << utility::conversions::to_utf8string(uri) << " on client "
     << mitk::RESTUtil::convertToUtf8(m_Client->base_uri().to_string());
 	
   MitkRequest getRequest(MitkRESTMethods::GET);
   getRequest.set_request_uri(uri);
 
   return m_Client->request(getRequest).then([=](MitkResponse response)
   {
     auto status = response.status_code();
     MITK_INFO << " status: " << status;
 
     if (status != web::http::status_codes::OK) {
       mitkThrow() << "response was not OK";
     }
 
     return response.extract_json().get();
   });
 }
 
 pplx::task<void> mitk::RESTClient::Get(utility::string_t filePath, utility::string_t uri)
 {
   MITK_DEBUG << "Calling GET with " << utility::conversions::to_utf8string(uri) << " on client "
     << mitk::RESTUtil::convertToUtf8(m_Client->base_uri().to_string()) << " save into "
     << mitk::RESTUtil::convertToUtf8(filePath);
 
   auto fileBuffer = std::make_shared<concurrency::streams::streambuf<uint8_t>>();
 
   return concurrency::streams::file_buffer<uint8_t>::open(filePath, std::ios::out).then([=](concurrency::streams::streambuf<uint8_t> outFile) -> pplx::task<MitkResponse>
   {
     *fileBuffer = outFile;
 
     return m_Client->request(MitkRESTMethods::GET, uri);
   })
     // Write the response body into the file buffer.
     .then([=](MitkResponse response) -> pplx::task<size_t>
   {
     auto status = response.status_code();
     MITK_DEBUG << "Status code: " << status;
 
     if (status != web::http::status_codes::OK) {
       mitkThrow() << "GET ended up with response " << mitk::RESTUtil::convertToUtf8(response.to_string());
     }
 
     return response.body().read_to_end(*fileBuffer);
   })
     // Close the file buffer.
     .then([=](size_t)
   {
     return fileBuffer->close();
   });
 }
 
 
 pplx::task<void> mitk::RESTClient::Post(utility::string_t uri, utility::string_t filePath)
 {
   // this is the working stow-rs request which supports just one dicom file packed into a multipart message
   std::basic_ifstream<unsigned char> input(filePath, std::ios::binary);
 
   std::vector<unsigned char> result;
   std::vector<unsigned char> buffer((std::istreambuf_iterator<unsigned char>(input)), (std::istreambuf_iterator<unsigned char>()));
 
   // reuse 'content-type' variable or struct to be more flexible, in future more than one file should also be supported..
   std::string head = "";
   head += "\r\n--boundary";
   head += "\r\nContent-Type: " + mitk::RESTUtil::convertToUtf8(U("application/dicom")) + "\r\n\r\n";
 
   std::vector<unsigned char> bodyVector(head.begin(), head.end());
 
   std::string tail = "";
   tail += "\r\n--boundary--";
 
   result.insert(result.end(), bodyVector.begin(), bodyVector.end());
   result.insert(result.end(), buffer.begin(), buffer.end());
   result.insert(result.end(), tail.begin(), tail.end());
 
   MitkRequest postRequest(MitkRESTMethods::POST);
   postRequest.set_request_uri(uri);
   postRequest.headers().add(U("Content-Type"), "multipart/related; type=\"application/dicom\"; boundary=boundary");
   postRequest.set_body(result);
 
   MITK_INFO << "Request: " << mitk::RESTUtil::convertToUtf8(postRequest.to_string());
   return m_Client->request(postRequest).then([](MitkResponse response)
   {
     auto status = response.status_code();
     if (status != web::http::status_codes::OK) {
       mitkThrow() << "POST ended up with response " << mitk::RESTUtil::convertToUtf8(response.to_string());
     }
     MITK_INFO << "Response: " << mitk::RESTUtil::convertToUtf8(response.to_string());
   });
 
 }
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.cpp b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.cpp
index 6e7f54e3d4..762cbc874a 100644
--- a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.cpp
@@ -1,579 +1,593 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "SegmentationReworkView.h"
 
 #include <itkFileTools.h>
 
 // Qt
 #include <QMessageBox>
 #include <QProgressBar>
 
 #include <mitkIOUtil.h>
 #include <QmitkNewSegmentationDialog.h>
 #include <mitkSegTool2D.h>
 #include <mitkToolManagerProvider.h>
 #include <mitkOverwriteSliceImageFilter.h>
 #include <mitkSegmentationInterpolationController.h>
 #include <mitkImagePixelWriteAccessor.h>
 #include <mitkExtractSliceFilter.h>
 #include <mitkVtkImageOverwrite.h>
 
 #include <mitkDICOMQIIOMimeTypes.h>
 #include <mitkDICOMDCMTKTagScanner.h>
 
 const std::string SegmentationReworkView::VIEW_ID = "org.mitk.views.segmentationreworkview";
 
 void SegmentationReworkView::SetFocus() {}
 
 void SegmentationReworkView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   m_Parent = parent;
   counter = 0;
 
   qRegisterMetaType< std::vector<std::string> >("std::vector<std::string>");
 
   //m_Controls.verticalWidget->setVisible(false);
   m_Controls.cleanDicomBtn->setVisible(false);
   m_Controls.individualWidget_2->setVisible(false);
 
   m_Controls.sliderWidget->setMinimum(1);
   m_Controls.sliderWidget->setMaximum(100);
   m_Controls.sliderWidget->setTickInterval(1);
   m_Controls.sliderWidget->setSingleStep(1);
   m_Controls.radioA->setChecked(true);
 
   connect(m_Controls.buttonUpload, &QPushButton::clicked, this, &SegmentationReworkView::UploadNewSegmentation);
   connect(m_Controls.buttonNewSeg, &QPushButton::clicked, this, &SegmentationReworkView::CreateNewSegmentationC);
   connect(m_Controls.cleanDicomBtn, &QPushButton::clicked, this, &SegmentationReworkView::CleanDicomFolder);
   connect(m_Controls.restartConnection, &QPushButton::clicked, this, &SegmentationReworkView::RestartConnection);
   connect(m_Controls.checkIndiv, &QCheckBox::stateChanged, this, &SegmentationReworkView::OnIndividualCheckChange);
   connect(m_Controls.sliderWidget, &ctkSliderWidget::valueChanged, this, &SegmentationReworkView::OnSliderWidgetChanged);
 
   m_DownloadBaseDir = mitk::IOUtil::GetTempPathA() + "segrework";
   MITK_INFO << "using download base dir: " << m_DownloadBaseDir;
   m_UploadBaseDir = mitk::IOUtil::GetTempPathA() + "uploadSeg";
 
   if (!itksys::SystemTools::FileIsDirectory(m_DownloadBaseDir))
   {
     itk::FileTools::CreateDirectory(m_DownloadBaseDir);
   }
 
   if (!itksys::SystemTools::FileIsDirectory(m_UploadBaseDir))
   {
     itk::FileTools::CreateDirectory(m_UploadBaseDir);
   }
 
   utility::string_t port = U("2020");
   utility::string_t address = U("http://127.0.0.1:");
   address.append(port);
 
   m_HttpHandler = std::unique_ptr<SegmentationReworkREST>(new SegmentationReworkREST(address));
 
   connect(m_HttpHandler.get(),
     &SegmentationReworkREST::InvokeUpdateChartWidget,
     this,
     &SegmentationReworkView::UpdateChartWidget);
   connect(this, &SegmentationReworkView::InvokeLoadData, this, &SegmentationReworkView::LoadData);
 
   connect(this, &SegmentationReworkView::InvokeProgress, this, &SegmentationReworkView::AddProgress);
 
   m_HttpHandler->SetPutCallback(std::bind(&SegmentationReworkView::RESTPutCallback, this, std::placeholders::_1));
   m_HttpHandler->SetGetImageSegCallback(std::bind(&SegmentationReworkView::RESTGetCallback, this, std::placeholders::_1));
   m_HttpHandler->SetGetAddSeriesCallback(std::bind(&SegmentationReworkView::RESTGetCallbackGeneric, this, std::placeholders::_1));
   m_HttpHandler->Open().wait();
 
   MITK_INFO << "Listening for requests at: " << utility::conversions::to_utf8string(address);
 
   //utility::string_t pacsURL = U("http://jip-dktk/dcm4chee-arc/aets/DCM4CHEE");
   utility::string_t pacsURL = U("http://193.174.48.78:8090/dcm4chee-arc/aets/DCM4CHEE");
   utility::string_t restURL = U("http://localhost:8000");
 
   m_DICOMWeb = new mitk::DICOMWeb(pacsURL);
   MITK_INFO << "requests to pacs are sent to: " << utility::conversions::to_utf8string(pacsURL);
   m_Controls.dcm4cheeURL->setText({ (utility::conversions::to_utf8string(pacsURL).c_str()) });
 
   m_RestService = new mitk::RESTClient(restURL);
 }
 
 void SegmentationReworkView::OnSliderWidgetChanged(double value)
 {
   std::map<double, double>::iterator it;
   unsigned int count = 0;
   for (it = m_ScoreMap.begin(); it != m_ScoreMap.end(); it++)
   {
     if (it->second < value)
     {
       count++;
     }
   }
   QString labelsToDelete = "slices to delete: " + QString::number(count);
   m_Controls.slicesToDeleteLabel->setText(labelsToDelete);
 }
 
 void SegmentationReworkView::AddProgress(int progress, QString status)
 {
   auto futureValue = m_Controls.progressBar->value() + progress;
   if (futureValue >= 100) 
   {
-    m_Controls.progressBar->setValue(100);
+    m_Controls.progressBar->setValue(0);
     m_Controls.progressBar->setFormat("Finished %p%");
   } else 
   {
     m_Controls.progressBar->setFormat(status.append(" %p%"));
     m_Controls.progressBar->setValue(futureValue);
   }
 }
 
 void SegmentationReworkView::RestartConnection()
 {
   auto host = m_Controls.dcm4cheeHostValue->text();
   std::string url = host.toStdString() + "/dcm4chee-arc/aets/DCM4CHEE";
 
   m_DICOMWeb = new mitk::DICOMWeb(utility::conversions::to_string_t(url));
   MITK_INFO << "requests to pacs are sent to: " << url;
   m_Controls.dcm4cheeURL->setText({ (utility::conversions::to_utf8string(url).c_str()) });
 }
 
 void SegmentationReworkView::OnIndividualCheckChange(int state)
 {
   if(state == Qt::Unchecked)
   {
     m_Controls.individualWidget_2->setVisible(false);
   }
   else if (state == Qt::Checked)
   {
     m_Controls.individualWidget_2->setVisible(true);
   }
 }
 
 void SegmentationReworkView::RESTPutCallback(const SegmentationReworkREST::DicomDTO &dto)
 {
   emit InvokeProgress(20, { "display graph and query structured report" });
   SetSimilarityGraph(dto.simScoreArray, dto.minSliceStart);
 
+  m_SRUID = dto.srSeriesUID;
+
   typedef std::map<std::string, std::string> ParamMap;
   ParamMap seriesInstancesParams;
 
   seriesInstancesParams.insert((ParamMap::value_type({"StudyInstanceUID"}, dto.studyUID)));
   seriesInstancesParams.insert((ParamMap::value_type({"SeriesInstanceUID"}, dto.srSeriesUID)));
   seriesInstancesParams.insert((ParamMap::value_type({"includefield"}, {"0040A375"}))); // Current Requested Procedure Evidence Sequence
 
   try {
     m_DICOMWeb->QuidoRSInstances(seriesInstancesParams).then([=](web::json::value jsonResult) 
     {
 
       auto firstResult = jsonResult[0];
       auto actualListKey = firstResult.at(U("0040A375")).as_object().at(U("Value")).as_array()[0].as_object().at(U("00081115")).as_object().at(U("Value")).as_array();
 
       std::string segSeriesUIDA = "";
       std::string segSeriesUIDB = "";
       std::string imageSeriesUID = "";
 
       for (unsigned int index = 0; index < actualListKey.size(); index++) {
         auto element = actualListKey[index].as_object();
         // get SOP class UID
         auto innerElement = element.at(U("00081199")).as_object().at(U("Value")).as_array()[0];
         auto sopClassUID = innerElement.at(U("00081150")).as_object().at(U("Value")).as_array()[0].as_string();
 
         auto seriesUID = utility::conversions::to_utf8string(element.at(U("0020000E")).as_object().at(U("Value")).as_array()[0].as_string());
 
         if (sopClassUID == U("1.2.840.10008.5.1.4.1.1.66.4")) // SEG
         {
           if (segSeriesUIDA.length() == 0)
           {
             segSeriesUIDA = seriesUID;
           }
           else
           {
             segSeriesUIDB = seriesUID;
           }
         }
         else if (sopClassUID == U("1.2.840.10008.5.1.4.1.1.2"))  // CT
         {
           imageSeriesUID = seriesUID;
         }
       }
 
       emit InvokeProgress(10, {"load composite context of structured report"});
       MITK_INFO << "image series UID " << imageSeriesUID;
       MITK_INFO << "seg A series UID " << segSeriesUIDA;
       MITK_INFO << "seg B series UID " << segSeriesUIDB;
 
       MITK_INFO << "Load related dicom series ...";
 
       std::string folderPathSeries = mitk::IOUtil::CreateTemporaryDirectory("XXXXXX", m_DownloadBaseDir) +"/";
 
       std::string pathSegA = mitk::IOUtil::CreateTemporaryDirectory("XXXXXX", m_DownloadBaseDir) + "/";
       std::string pathSegB = mitk::IOUtil::CreateTemporaryDirectory("XXXXXX", m_DownloadBaseDir) + "/";
 
       auto folderPathSegA = utility::conversions::to_string_t(pathSegA);
       auto folderPathSegB = utility::conversions::to_string_t(pathSegB);
 
       m_CurrentStudyUID = dto.studyUID;
 
       std::vector<pplx::task<std::string>> tasks;
       auto imageSeriesTask = m_DICOMWeb->WadoRS(utility::conversions::to_string_t(folderPathSeries), dto.studyUID, imageSeriesUID);
       auto segATask = m_DICOMWeb->WadoRS(folderPathSegA, dto.studyUID, segSeriesUIDA);
       auto segBTask = m_DICOMWeb->WadoRS(folderPathSegB, dto.studyUID, segSeriesUIDB);
       tasks.push_back(imageSeriesTask);
       tasks.push_back(segATask);
       tasks.push_back(segBTask);
 
       auto joinTask = pplx::when_all(begin(tasks), end(tasks));
       auto filePathList = joinTask.then([&](std::vector<std::string> filePathList) {
         emit InvokeProgress(50, {"load dicom files from disk"});
         InvokeLoadData(filePathList);
-        auto algorithmNameA = GetAlgorithmOfSegByPath(filePathList[0]);
-        auto algorithmNameB = GetAlgorithmOfSegByPath(filePathList[1]);
-        emit InvokeProgress(20, { "load meta data from disk" });
-        m_Controls.labelSegA->setText(m_Controls.labelSegA->text() + " " + algorithmNameA.c_str());
-        m_Controls.labelSegA->setText(m_Controls.labelSegB->text() + " " + algorithmNameB.c_str());
       });
 
       //ParamMap seriesInstancesParams;
 
       //seriesInstancesParams.insert((ParamMap::value_type({ "StudyInstanceUID" }, dto.studyUID)));
       //seriesInstancesParams.insert((ParamMap::value_type({ "SeriesInstanceUID" }, segSeriesUIDA)));
 
       //m_DICOMWeb->QuidoRSInstances(seriesInstancesParams).then([=](web::json::value jsonResult) {
       //  emit InvokeProgress(10, {"display SEG A data"});
       //  auto seriesDescription = QString(utility::conversions::to_utf8string(jsonResult[0][U("0008103E")][U("Value")][0].as_string()).c_str());
       //  m_Controls.labelSegA->setText(m_Controls.labelSegA->text() + " " + seriesDescription);
       //});
 
       //seriesInstancesParams["SeriesInstanceUID"] = segSeriesUIDB;
       //m_DICOMWeb->QuidoRSInstances(seriesInstancesParams).then([=](web::json::value jsonResult) {
       //  emit InvokeProgress(10, { "display SEG B data" });
       //  auto seriesDescription = QString(utility::conversions::to_utf8string(jsonResult[0][U("0008103E")][U("Value")][0].as_string()).c_str());
       //  m_Controls.labelSegB->setText(m_Controls.labelSegB->text() + " " + seriesDescription );
       //});
     });
 
   }
   catch (mitk::Exception&  e) {
     MITK_ERROR << e.what();
   }
 }
 
 void SegmentationReworkView::RESTGetCallbackGeneric(const SegmentationReworkREST::DicomDTO &dto)
 {
   std::vector<pplx::task<std::string>> tasks;
 
   if (dto.seriesUIDList.size() > 0) {
     for (std::string segSeriesUID : dto.seriesUIDList)
     {
       std::string folderPathSeries = mitk::IOUtil::CreateTemporaryDirectory("XXXXXX", m_DownloadBaseDir) + "/";
       try {
         auto seriesTask = m_DICOMWeb->WadoRS(utility::conversions::to_string_t(folderPathSeries), dto.studyUID, segSeriesUID);
         tasks.push_back(seriesTask);
       } catch (const mitk::Exception &exception) 
       {
         MITK_INFO << exception.what();
         return;
       }
     }
   }
 
   try 
   {
     auto joinTask = pplx::when_all(begin(tasks), end(tasks));
     auto filePathList = joinTask.then([&](std::vector<std::string> filePathList) { InvokeLoadData(filePathList); });
   }
   catch (const mitk::Exception& exception) 
   {
     MITK_INFO << exception.what();
     return;
   }
 }
 
 void SegmentationReworkView::RESTGetCallback(const SegmentationReworkREST::DicomDTO &dto) 
 {
   std::string folderPathSeries = mitk::IOUtil::CreateTemporaryDirectory("XXXXXX", m_DownloadBaseDir) + "/";
 
   MITK_INFO << folderPathSeries;
 
   std::string pathSeg = mitk::IOUtil::CreateTemporaryDirectory("XXXXXX", m_DownloadBaseDir) + "/";
   auto folderPathSeg = utility::conversions::to_string_t(pathSeg);
 
   MITK_INFO << pathSeg;
 
   try {
     std::vector<pplx::task<std::string>> tasks;
     auto imageSeriesTask = m_DICOMWeb->WadoRS(utility::conversions::to_string_t(folderPathSeries), dto.studyUID, dto.imageSeriesUID);
 
     tasks.push_back(imageSeriesTask);
 
     if (dto.seriesUIDList.size() > 0) {
       for (std::string segSeriesUID : dto.seriesUIDList)
       {
         auto segTask = m_DICOMWeb->WadoRS(folderPathSeg, dto.studyUID, segSeriesUID);
         tasks.push_back(segTask);
       }
     }
     else {
       auto segATask = m_DICOMWeb->WadoRS(folderPathSeg, dto.studyUID, dto.segSeriesUIDA);
       tasks.push_back(segATask);
     }
 
 
     auto joinTask = pplx::when_all(begin(tasks), end(tasks));
     auto filePathList = joinTask.then([&](std::vector<std::string> filePathList) { InvokeLoadData(filePathList); });
   }
   catch (const mitk::Exception &exception) {
     MITK_INFO << exception.what();
   }
 }
 
 std::string SegmentationReworkView::GetAlgorithmOfSegByPath(std::string path)
 {
   auto scanner = mitk::DICOMDCMTKTagScanner::New();
 
   mitk::DICOMTagPath algorithmName;
-  algorithmName.AddSelection(0x0062, 0x0002, 0).AddSelection(0xfffe, 0xe000, 0).AddElement(0x0062, 0x0009);
+  algorithmName.AddAnySelection(0x0062, 0x0002).AddElement(0x0062, 0x0009);
 
   mitk::StringList files;
   files.push_back(path);
   scanner->SetInputFiles(files);
   scanner->AddTagPath(algorithmName);
 
   scanner->Scan();
 
   mitk::DICOMDatasetAccessingImageFrameList frames = scanner->GetFrameInfoList();
   auto findings = frames.front()->GetTagValueAsString(algorithmName);
-  MITK_INFO << findings.front().value;
+  if (findings.size() != 0)
+    MITK_INFO << findings.front().value;
   return findings.front().value;
 }
 
 void SegmentationReworkView::LoadData(std::vector<std::string> filePathList)
 {
   MITK_INFO << "Loading finished. Pushing data to data storage ...";
   auto ds = GetDataStorage();
   auto dataNodes = mitk::IOUtil::Load(filePathList, *ds);
   // reinit view
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(ds);
 
   // find data nodes
   m_Image = dataNodes->at(0);
   m_Image->SetName("image data");
   m_SegA = dataNodes->at(1);
   m_SegB = dataNodes->at(2);
+
+  auto algorithmNameA = GetAlgorithmOfSegByPath(filePathList[1]);
+  auto algorithmNameB = GetAlgorithmOfSegByPath(filePathList[2]);
+  m_SegA->SetName(algorithmNameA);
+  m_SegB->SetName(algorithmNameB);
+  m_Controls.labelSegA->setText(m_Controls.labelSegA->text() + " " + algorithmNameA.c_str());
+  m_Controls.labelSegB->setText(m_Controls.labelSegB->text() + " " + algorithmNameB.c_str());
+  emit InvokeProgress(20, { "" });
 }
 
 void SegmentationReworkView::UpdateChartWidget()
 {
   m_Controls.chartWidget->Show();
 }
 
 void SegmentationReworkView::SetSimilarityGraph(std::vector<double> simScoreArray, int sliceMinStart)
 {
   std::string label = "similarity graph";
   if (m_Controls.chartWidget->GetData()->size() > 0)
   {
     m_Controls.chartWidget->Clear();
   }
 
   double sliceIndex = sliceMinStart;
   for (double score : simScoreArray)
   {
     m_ScoreMap.insert(std::map<double, double>::value_type(sliceIndex, score));
     sliceIndex++;
   }
 
   m_Controls.chartWidget->AddData2D(m_ScoreMap, label);
   m_Controls.chartWidget->SetChartType(label, QmitkChartWidget::ChartType::line);
   m_Controls.chartWidget->SetXAxisLabel("slice number");
   m_Controls.chartWidget->SetYAxisLabel("similarity in percent");
 }
 
 void SegmentationReworkView::UploadNewSegmentation()
 {
   AddProgress(10, { "save SEG to temp folder" });
   std::string folderPathSeg = mitk::IOUtil::CreateTemporaryDirectory("XXXXXX", m_UploadBaseDir) + "/";
 
   const std::string savePath = folderPathSeg + m_SegC->GetName() + ".dcm";
   const std::string mimeType = mitk::MitkDICOMQIIOMimeTypes::DICOMSEG_MIMETYPE_NAME();
   mitk::IOUtil::Save(m_SegC->GetData(), mimeType, savePath);
 
   // get Series Instance UID from new SEG
   auto scanner = mitk::DICOMDCMTKTagScanner::New();
   mitk::DICOMTagPath seriesUID(0x0020, 0x000E);
 
   mitk::StringList files;
   files.push_back(savePath);
   scanner->SetInputFiles(files);
   scanner->AddTagPath(seriesUID);
 
   scanner->Scan();
 
   mitk::DICOMDatasetAccessingImageFrameList frames = scanner->GetFrameInfoList();
   auto findings = frames.front()->GetTagValueAsString(seriesUID);
   auto segSeriesUID = findings.front().value;
 
   AddProgress(20, {"push SEG to PACS"});
   auto filePath = utility::conversions::to_string_t(savePath);
   try {
     m_DICOMWeb->StowRS(filePath, m_CurrentStudyUID).then([=] {
-      emit AddProgress(40, {"persist reworked SEG to evaluation database"});
+      emit InvokeProgress(40, {"persist reworked SEG to evaluation database"}); 
 
-      MitkUriBuilder queryBuilder(U("tasks/evaluations"));
-      queryBuilder.append_path(U("3/")); // replace with evaluation UID
+      MitkUriBuilder queryBuilder(U("tasks/evaluations/"));
+      queryBuilder.append_query(U("srUID"), utility::conversions::to_string_t(m_SRUID));
+      //queryBuilder.append_path(U("71/"));
       m_RestService->Get(queryBuilder.to_string()).then([=](web::json::value result) {
-        auto updatedContent = result;
+        MITK_INFO << "after GET";
+        MITK_INFO << utility::conversions::to_utf8string(result.to_string());
+        auto updatedContent = result.as_array()[0];
         updatedContent[U("reworkedSegmentationUID")] = web::json::value::string(utility::conversions::to_string_t(segSeriesUID));
+     
+        auto id = updatedContent.at(U("id")).as_integer();
+        MITK_INFO << id;
+        auto idParam = std::to_string(id).append("/");
+
+        MitkUriBuilder queryBuilder(U("tasks/evaluations"));
+        queryBuilder.append_path(utility::conversions::to_string_t(idParam));
+
         m_RestService->PUT(queryBuilder.to_string(), updatedContent).then([=](web::json::value result) {
-          MITK_INFO << utility::conversions::to_utf8string(result.to_string());
           MITK_INFO << "successfully stored";
-          emit AddProgress(30, { "" });
+          emit InvokeProgress(30, { "successfully stored" });
         });
-
       });
-
     });
   }
   catch (const std::exception &exception)
   {
     std::cout << exception.what() << std::endl;
   }
 }
 
 std::vector<unsigned int> SegmentationReworkView::CreateSegmentation(mitk::Image::Pointer baseSegmentation, double threshold)
 {
   MITK_INFO << "handle individual segmentation creation";
   std::map<double, double>::iterator it;
 
   std::vector<unsigned int> sliceIndices;
 
   unsigned int count = 0;
   for (it = m_ScoreMap.begin(); it != m_ScoreMap.end(); it++)
   {
     if (it->second < threshold)
     {
       auto index = it->first;
       try 
       {
         mitk::ImagePixelWriteAccessor<unsigned short, 3> imageAccessor(baseSegmentation);
         for (unsigned int x = 0; x < baseSegmentation->GetDimension(0); x++)
         {
           for (unsigned int y = 0; y < baseSegmentation->GetDimension(1); y++)
           {
             imageAccessor.SetPixelByIndex({ { x, y, int(index) } }, 0);
           }
         }
       }
       catch (mitk::Exception& e) {
         MITK_ERROR << e.what();
       }
 
       count++;
       sliceIndices.push_back(index);
       MITK_INFO << "slice " << it->first <<  " removed ";
 	   }
   }
   MITK_INFO << "slices deleted " << count;
   return sliceIndices;
 }
 
 void SegmentationReworkView::CreateNewSegmentationC() 
 {
   mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
   toolManager->InitializeTools();
   toolManager->SetReferenceData(m_Image);
   
   mitk::Image::Pointer baseImage;
   if (m_Controls.radioA->isChecked()) {
     baseImage = dynamic_cast<mitk::Image*>(m_SegA->GetData())->Clone();
   }
   else if (m_Controls.radioB->isChecked()) {
     baseImage = dynamic_cast<mitk::Image*>(m_SegB->GetData())->Clone();
   }
 
   if (m_Controls.checkIndiv->isChecked())
   {
     auto sliceIndices = CreateSegmentation(baseImage, m_Controls.sliderWidget->value());
   }
 
   QmitkNewSegmentationDialog* dialog = new QmitkNewSegmentationDialog(m_Parent); // needs a QWidget as parent, "this" is not QWidget
 
   int dialogReturnValue = dialog->exec();
   if (dialogReturnValue == QDialog::Rejected)
   {
     // user clicked cancel or pressed Esc or something similar
     return;
   }
 
   // ask the user about an organ type and name, add this information to the image's (!) propertylist
   // create a new image of the same dimensions and smallest possible pixel type
   mitk::Tool* firstTool = toolManager->GetToolById(0);
   if (firstTool)
   {
     try
     {
       std::string newNodeName = dialog->GetSegmentationName().toStdString();
       if (newNodeName.empty())
       {
         newNodeName = "no_name";
       }
 
       mitk::DataNode::Pointer newSegmentation = firstTool->CreateSegmentationNode(baseImage, newNodeName, dialog->GetColor());
       // initialize showVolume to false to prevent recalculating the volume while working on the segmentation
       newSegmentation->SetProperty("showVolume", mitk::BoolProperty::New(false));
       if (!newSegmentation)
       {
         return; // could be aborted by user
       }
 
       if (mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetWorkingData(0))
       {
         mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetWorkingData(0)->SetSelected(false);
       }
       newSegmentation->SetSelected(true);
       this->GetDataStorage()->Add(newSegmentation, toolManager->GetReferenceData(0)); // add as a child, because the segmentation "derives" from the original
      
       m_SegC = newSegmentation;
 
       auto referencedImages = m_Image->GetData()->GetProperty("files");
       m_SegC->GetData()->SetProperty("referenceFiles", referencedImages);
 
     }
     catch (std::bad_alloc)
     {
       QMessageBox::warning(nullptr, tr("Create new segmentation"), tr("Could not allocate memory for new segmentation"));
     }
   }
   else {
     MITK_INFO << "no tools...";
   }
 }
 
 void SegmentationReworkView::CleanDicomFolder() 
 {
   if (m_SegA || m_SegB || m_SegC) {
     QMessageBox::warning(nullptr, tr("Clean dicom folder"), tr("Please remove the data in data storage before cleaning the download folder"));
     return;
   }
 
   //std::experimental::filesystem::remove_all(m_DownloadBaseDir);
   // TODO : use POCO
   //itk::FileTools::CreateDirectory(m_DownloadBaseDir);
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.h b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.h
index 171a13dfb1..9eaf7ee2de 100644
--- a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.h
+++ b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.h
@@ -1,105 +1,106 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef SegmentationReworkView_h
 #define SegmentationReworkView_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_SegmentationReworkViewControls.h"
 
 #include "SegmentationReworkREST.h"
 #include <mitkDICOMWeb.h>
 #include <mitkImage.h>
 #include <mitkLabelSetImage.h>
 
 /**
   \brief SegmentationReworkView
 
   \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
   \sa QmitkAbstractView
   \ingroup ${plugin_target}_internal
 */
 class SegmentationReworkView : public QmitkAbstractView
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
   static const std::string VIEW_ID;
 
   void RESTPutCallback(const SegmentationReworkREST::DicomDTO& dto);
   void RESTGetCallback(const SegmentationReworkREST::DicomDTO& dto);
   void RESTGetCallbackGeneric(const SegmentationReworkREST::DicomDTO& dto);
 
   void UpdateChartWidget();
   void ClearChartWidget();
   void LoadData(std::vector<std::string> filePathList);
   void OnSliderWidgetChanged(double value);
   void AddProgress(int, QString status);
 
 signals:
   void InvokeLoadData(std::vector<std::string> filePathList);
   void InvokeProgress(int, QString status);
 
 protected:
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   virtual void SetFocus() override;
 
   /// \brief Called when the user clicks the GUI button
   void CreateNewSegmentationC();
 
   void CleanDicomFolder();
   void UploadNewSegmentation();
   void RestartConnection();
   void OnIndividualCheckChange(int state);
 
   Ui::SegmentationReworkViewControls m_Controls;
 
 private:
 
   std::vector<unsigned int> CreateSegmentation(mitk::Image::Pointer baseSegmentation, double threshold);
   void InterpolateSegmentation(mitk::Image::Pointer baseSegmentation, std::vector<unsigned int> sliceIndices);
 
   std::string GetAlgorithmOfSegByPath(std::string path);
 
   void SetSimilarityGraph(std::vector<double> simScoreArray, int sliceMinStart);
   std::unique_ptr<SegmentationReworkREST> m_HttpHandler;
   mitk::DICOMWeb* m_DICOMWeb;
   mitk::RESTClient* m_RestService;
 
   std::string m_CurrentStudyUID;
+  std::string m_SRUID;
 
   std::string m_DownloadBaseDir;
   std::string m_UploadBaseDir;
 
   mitk::DataNode::Pointer m_Image;
   mitk::DataNode::Pointer m_SegA;
   mitk::DataNode::Pointer m_SegB;
   mitk::DataNode::Pointer m_SegC;
   std::map<double, double> m_ScoreMap;
   std::string m_GroundTruth;
 
   QWidget* m_Parent;
   int counter;
 };
 
 #endif // SegmentationReworkView_h
diff --git a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkViewControls.ui b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkViewControls.ui
index 3af39f0897..cac8ae1eda 100644
--- a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkViewControls.ui
@@ -1,263 +1,266 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>SegmentationReworkViewControls</class>
  <widget class="QWidget" name="SegmentationReworkViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>465</width>
     <height>821</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>QmitkTemplate</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <layout class="QFormLayout" name="formLayout">
      <item row="0" column="0">
       <widget class="QLabel" name="dcm4cheeHostLabel">
        <property name="text">
         <string>dcm4chee host</string>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="QLineEdit" name="dcm4cheeHostValue">
        <property name="placeholderText">
         <string>example input: http://193.174.48.78:8090</string>
        </property>
       </widget>
      </item>
      <item row="1" column="1">
       <widget class="QPushButton" name="restartConnection">
        <property name="text">
         <string>restart dcm4chee connection</string>
        </property>
       </widget>
      </item>
      <item row="2" column="1">
       <widget class="QProgressBar" name="progressBar">
        <property name="value">
         <number>0</number>
        </property>
        <property name="alignment">
         <set>Qt::AlignCenter</set>
        </property>
        <property name="textVisible">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
-   <item>
-    <widget class="QLabel" name="dcm4cheeURL">
-     <property name="text">
-      <string/>
-     </property>
-    </widget>
-   </item>
    <item>
     <widget class="QWidget" name="verticalWidget" native="true">
      <layout class="QVBoxLayout" name="verticalLayout_3">
+      <item>
+       <widget class="QLabel" name="dcm4cheeURL">
+        <property name="text">
+         <string/>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignCenter</set>
+        </property>
+       </widget>
+      </item>
       <item>
        <widget class="QLabel" name="labelSegA">
         <property name="text">
          <string>Segmentation A:</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QLabel" name="labelSegB">
         <property name="text">
          <string>Segmentation B:</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QLabel" name="label">
         <property name="text">
          <string>ground truth:</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QmitkChartWidget" name="chartWidget" native="true">
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>400</height>
          </size>
         </property>
         <property name="maximumSize">
          <size>
           <width>16777215</width>
           <height>400</height>
          </size>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QGroupBox" name="verticalGroupBox">
         <property name="flat">
          <bool>false</bool>
         </property>
         <layout class="QVBoxLayout" name="verticalLayout_2">
          <item>
           <widget class="QGroupBox" name="groupBox">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>0</width>
              <height>60</height>
             </size>
            </property>
            <property name="title">
             <string>Select segmentation basis</string>
            </property>
            <property name="flat">
             <bool>true</bool>
            </property>
            <layout class="QHBoxLayout" name="horizontalLayout">
             <property name="sizeConstraint">
              <enum>QLayout::SetDefaultConstraint</enum>
             </property>
             <item>
              <widget class="QRadioButton" name="radioA">
               <property name="text">
                <string>A</string>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QRadioButton" name="radioB">
               <property name="text">
                <string>B</string>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QCheckBox" name="checkIndiv">
               <property name="text">
                <string>Individual</string>
               </property>
              </widget>
             </item>
            </layout>
           </widget>
          </item>
          <item>
           <widget class="QWidget" name="individualWidget_2" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <layout class="QHBoxLayout" name="individualWidget">
             <item>
              <widget class="QLabel" name="slicesToDeleteLabel">
               <property name="text">
                <string>Slices to delete:</string>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QLabel" name="thresholdValue">
               <property name="text">
                <string/>
               </property>
              </widget>
             </item>
             <item>
              <widget class="ctkSliderWidget" name="sliderWidget" native="true"/>
             </item>
            </layout>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="buttonNewSeg">
            <property name="text">
             <string>Create new Segmentation</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="Line" name="line">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="buttonUpload">
            <property name="toolTip">
             <string>Do image processing</string>
            </property>
            <property name="text">
             <string>Upload Segmentation</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <spacer name="spacer1">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Expanding</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>220</height>
       </size>
      </property>
     </spacer>
    </item>
    <item>
     <widget class="QPushButton" name="cleanDicomBtn">
      <property name="text">
       <string>clean dicom download folder</string>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
    <class>QmitkChartWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkChartWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>ctkSliderWidget</class>
    <extends>QWidget</extends>
    <header location="global">ctksliderwidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>