diff --git a/Modules/RESTService/src/mitkRESTManager.cpp b/Modules/RESTService/src/mitkRESTManager.cpp
index e63bf16b06..c1be099a79 100644
--- a/Modules/RESTService/src/mitkRESTManager.cpp
+++ b/Modules/RESTService/src/mitkRESTManager.cpp
@@ -1,222 +1,222 @@
 /*===================================================================
 
 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 <mitkRESTManager.h>
 #include <mitkRESTClient.h>
 #include <mitkRESTServer.h>
 #include <mitkIRESTObserver.h>
 
 #include <mitkExceptionMacro.h>
 #include <mitkLogMacros.h>
 
 mitk::RESTManager::RESTManager()
 {
 }
 
 mitk::RESTManager::~RESTManager()
 {
 }
 
 pplx::task<web::json::value> mitk::RESTManager::SendRequest(const web::uri &uri,
                                                             const RequestType &type,
                                                             const web::json::value *content,
                                                             const std::map<utility::string_t, utility::string_t> headers,
                                                             const utility::string_t &filePath)
 {
   pplx::task<web::json::value> answer;
   auto client = new RESTClient;
-  MITK_INFO << "within rest manager";
+
   switch (type)
   {
     case RequestType::Get:
       answer = !filePath.empty()
         ? client->Get(uri, filePath, headers)
         : client->Get(uri, headers);
       break;
 
     case RequestType::Post:
       if (nullptr == content)
         MITK_WARN << "Content for put is empty, this will create an empty resource";
 
       answer = client->Post(uri, content);
       break;
 
     case RequestType::Put:
 
       if (nullptr == content)
         MITK_WARN << "Content for put is empty, this will empty the ressource";
 
       answer = client->Put(uri, content);
       break;
 
     default:
       mitkThrow() << "Request Type not supported";
   }
 
   return answer;
 }
 
 void mitk::RESTManager::ReceiveRequest(const web::uri &uri, mitk::IRESTObserver *observer)
 {
   // New instance of RESTServer in m_ServerMap, key is port of the request
   auto port = uri.port();
 
   // Checking if port is free to add a new Server
   if (0 == m_ServerMap.count(port))
   {
     this->AddObserver(uri, observer);
     // creating server instance
     auto server = new RESTServer(uri.authority());
     // add reference to server instance to map
     m_ServerMap[port] = server;
     // start Server
     server->OpenListener();
   }
   // If there is already a server under this port
   else
   {
     this->RequestForATakenPort(uri, observer);
   }
 }
 
 web::http::http_response mitk::RESTManager::Handle(const web::uri &uri,
                                                    const web::json::value &body,
                                                    const web::http::method &method)
 {
   // Checking if there is an observer for the port and path
   auto key = std::make_pair(uri.port(), uri.path());
   if (0 != m_Observers.count(key))
   {
     return m_Observers[key]->Notify(uri, body, method);
   }
   // No observer under this port, return null which results in status code 404 (s. RESTServer)
   else
   {
     MITK_WARN << "No Observer can handle the data";
     web::http::http_response response(web::http::status_codes::BadGateway);
     response.set_body(L"No one can handle the request under the given port.");
     return response;
   }
 }
 
 void mitk::RESTManager::HandleDeleteObserver(IRESTObserver *observer, const web::uri &uri)
 {
   for (auto it = m_Observers.begin(); it != m_Observers.end();)
   {
     mitk::IRESTObserver *obsMap = it->second;
     // Check wether observer is at this place in map
     if (observer == obsMap)
     {
       // Check wether it is the right uri to be deleted
       if (uri.is_empty() || uri.path() == it->first.second)
       {
         int port = it->first.first;
         bool noObserverForPort = this->DeleteObserver(it);
         if (noObserverForPort)
         {
           //  there isn't an observer at this port, delete m_ServerMap entry for this port
           // close listener
           m_ServerMap[port]->CloseListener();
           delete m_ServerMap[port];
           // delete server from map
           m_ServerMap.erase(port);
         }
       }
       else
       {
         ++it;
       }
     }
     else
     {
       ++it;
     }
   }
 }
 
 const std::map<int, mitk::RESTServer *> &mitk::RESTManager::GetServerMap()
 {
   return m_ServerMap;
 }
 
 std::map<std::pair<int, utility::string_t>, mitk::IRESTObserver *> &mitk::RESTManager::GetObservers()
 {
   return m_Observers;
 }
 
 void mitk::RESTManager::AddObserver(const web::uri &uri, IRESTObserver *observer)
 {
   // new observer has to be added
   std::pair<int, utility::string_t> key(uri.port(), uri.path());
   m_Observers[key] = observer;
 }
 
 void mitk::RESTManager::RequestForATakenPort(const web::uri &uri, IRESTObserver *observer)
 {
   // Same host, means new observer but not a new server instance
   if (uri.authority() == m_ServerMap[uri.port()]->GetUri())
   {
     // new observer has to be added
     std::pair<int, utility::string_t> key(uri.port(), uri.path());
     // only add a new observer if there isn't already an observer for this uri
     if (0 == m_Observers.count(key))
     {
       this->AddObserver(uri, observer);
     }
     else
     {
       MITK_ERROR << "Threre is already a observer handeling this data";
     }
   }
   // Error, since another server can't be added under this port
   else
   {
     MITK_ERROR << "There is already another server listening under this port";
   }
 }
 
 bool mitk::RESTManager::DeleteObserver(std::map<std::pair<int, utility::string_t>, IRESTObserver *>::iterator &it)
 {
   int port = it->first.first;
 
   it = m_Observers.erase(it);
 
   for (auto observer : m_Observers)
   {
     if (port == observer.first.first)
     {
       // there still exists an observer for this port
       return false;
     }
   }
 
   return true;
 }
 
 void mitk::RESTManager::SetServerMap(const int port, RESTServer *server)
 {
   m_ServerMap[port] = server;
 }
 
 void mitk::RESTManager::DeleteFromServerMap(const int port)
 {
   m_ServerMap.erase(port);
 }
 
 void mitk::RESTManager::SetObservers(const std::pair<int, utility::string_t> key, IRESTObserver *observer)
 {
   m_Observers[key] = observer;
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/ReworkRequestHandler.cpp b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/ReworkRequestHandler.cpp
index 5a5e1204c8..c803f849f5 100644
--- a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/ReworkRequestHandler.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/ReworkRequestHandler.cpp
@@ -1,243 +1,244 @@
 /*===================================================================
 
 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 <mitkIOUtil.h>
 #include <mitkRESTUtil.h>
 
 #include "DICOMweb.h"
 #include "ReworkRequestHandler.h"
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usModuleInitialization.h>
 
 US_INITIALIZE_MODULE
 
 ReworkRequestHandler::ReworkRequestHandler()
 {
   m_DicomWeb = DICOMweb(L"http://193.174.48.78:8090/dcm4chee-arc/aets/DCM4CHEE/");
 }
 
 ReworkRequestHandler::ReworkRequestHandler(std::string downloadDir)
   : m_DownloadDir{downloadDir}
 {
   auto *context = us::GetModuleContext();
   auto managerRef = context->GetServiceReference<mitk::IRESTManager>();
   if (managerRef)
   {
     auto managerService = context->GetService(managerRef);
     if (managerService)
     {
       m_ManagerService = managerService;
     }
   }
   m_DicomWeb = DICOMweb(L"http://193.174.48.78:8090/dcm4chee-arc/aets/DCM4CHEE/");
 }
 
 ReworkRequestHandler::~ReworkRequestHandler() {}
 
 ReworkRequestHandler::DicomDTO ReworkRequestHandler::ExtractDTO(const web::json::value &data)
 {
   DicomDTO dto;
   auto messageTypeKey = data.at(L"messageType");
   if (messageTypeKey.as_string() == L"downloadData")
   {
     MITK_INFO << "within extract dto";
 
     auto imageStudyUIDKey = data.at(L"studyUID");
     auto srSeriesUIDKey = data.at(L"srSeriesUID");
 
     auto groundTruthKey = data.at(L"groundTruth");
 
     auto simScoreKey = data.at(L"simScoreArray");
     auto minSliceStartKey = data.at(L"minSliceStart");
 
     dto.srSeriesUID = srSeriesUIDKey.as_string();
     dto.groundTruth = groundTruthKey.as_string();
     dto.studyUID = imageStudyUIDKey.as_string();
     dto.minSliceStart = minSliceStartKey.as_integer();
 
     std::vector<double> vec;
     web::json::array simArray = simScoreKey.as_array();
 
     for (web::json::value score : simArray)
     {
       vec.push_back(score.as_double() * 100);
     }
 
     dto.simScoreArray = vec;
   }
   return dto;
 }
 
 web::http::http_response ReworkRequestHandler::Notify(const web::uri &uri,
                                                       const web::json::value &data,
                                                       const web::http::method &method)
 {
   MITK_INFO << "Incoming notify";
   if (method == web::http::methods::GET)
   {
     return HandleGet(uri, data);
   }
   else if (method == web::http::methods::PUT)
   {
     return HandlePut(uri, data);
   }
   else if (method == web::http::methods::OPTIONS)
   {
     return HandleOptions(uri, data);
   }
 
   web::http::http_response response(web::http::status_codes::BadGateway);
   response.set_body(L"No one can handle http method from request"); // TODO: include method name
   return response;
 }
 
 web::http::http_response ReworkRequestHandler::HandlePut(const web::uri &uri, const web::json::value &data)
 {
   emit InvokeProgress(20, {"display graph and query structured report"});
 
   if (data == web::json::value())
   {
     MITK_INFO << "no data in body";
     web::http::http_response response(web::http::status_codes::BadRequest);
     response.set_body(L"No data in body of request"); // TODO: include method name
     return response;
   }
   MITK_INFO << mitk::RESTUtil::convertToUtf8(data.to_string());
   DicomDTO dto = ExtractDTO(data);
   MITK_INFO << mitk::RESTUtil::convertToUtf8(dto.imageSeriesUID);
+
   emit InvokeSimilarityGraph(dto.simScoreArray, dto.minSliceStart);
   emit InvokeUpdateDcmMeta(dto);
 
   mitk::RESTUtil::ParamMap seriesInstancesParams;
 
   seriesInstancesParams.insert(mitk::RESTUtil::ParamMap::value_type(L"StudyInstanceUID", dto.studyUID));
   seriesInstancesParams.insert(mitk::RESTUtil::ParamMap::value_type(L"SeriesInstanceUID", dto.srSeriesUID));
   seriesInstancesParams.insert(
     mitk::RESTUtil::ParamMap::value_type(L"includefield",
                                          L"0040A375")); // Current Requested Procedure Evidence Sequence
   try
   {
     auto requestURI = m_DicomWeb.CreateQIDOUri(seriesInstancesParams);
     MITK_INFO << "send qido request";
     m_ManagerService->SendRequest(requestURI).then([=](web::json::value jsonResult) {
       auto firstResult = jsonResult[0];
       auto actualListKey = firstResult.at(L"0040A375")
                              .as_object()
                              .at(L"Value")
                              .as_array()[0]
                              .as_object()
                              .at(L"00081115")
                              .as_object()
                              .at(L"Value")
                              .as_array();
 
       MITK_INFO << "received qido response";
       utility::string_t segSeriesUIDA = {};
       utility::string_t segSeriesUIDB = {};
       utility::string_t imageSeriesUID = {};
 
       for (unsigned int index = 0; index < actualListKey.size(); index++)
       {
         auto element = actualListKey[index].as_object();
         // get SOP class UID
         auto innerElement = element.at(L"00081199").as_object().at(L"Value").as_array()[0];
         auto sopClassUID = innerElement.at(L"00081150").as_object().at(L"Value").as_array()[0].as_string();
 
         auto seriesUID = element.at(L"0020000E").as_object().at(L"Value").as_array()[0].as_string();
 
         if (sopClassUID == L"1.2.840.10008.5.1.4.1.1.66.4") // SEG
         {
           if (segSeriesUIDA.length() == 0)
           {
             segSeriesUIDA = seriesUID;
           }
           else
           {
             segSeriesUIDB = seriesUID;
           }
         }
         else if (sopClassUID == L"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 " << mitk::RESTUtil::convertToUtf8(imageSeriesUID);
       MITK_INFO << "seg A series UID " << mitk::RESTUtil::convertToUtf8(segSeriesUIDA);
       MITK_INFO << "seg B series UID " << mitk::RESTUtil::convertToUtf8(segSeriesUIDB);
 
       MITK_INFO << "Load related dicom series ...";
 
       std::string folderPathSeries = mitk::IOUtil::CreateTemporaryDirectory("XXXXXX", m_DownloadDir) + "/";
 
       std::string pathSegA = mitk::IOUtil::CreateTemporaryDirectory("XXXXXX", m_DownloadDir) + "/";
       std::string pathSegB = mitk::IOUtil::CreateTemporaryDirectory("XXXXXX", m_DownloadDir) + "/";
 
       auto folderPathSegA = utility::conversions::to_string_t(pathSegA);
       auto folderPathSegB = utility::conversions::to_string_t(pathSegB);
 
       std::vector<pplx::task<std::string>> tasks;
 
       auto imageSeriesTask =
         m_DicomWeb.SendWADO(utility::conversions::to_string_t(folderPathSeries), dto.studyUID, imageSeriesUID);
       auto segATask = m_DicomWeb.SendWADO(folderPathSegA, dto.studyUID, segSeriesUIDA);
       auto segBTask = m_DicomWeb.SendWADO(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"});
         emit InvokeLoadData(filePathList);
       });
     });
   }
   catch (mitk::Exception &e)
   {
     MITK_ERROR << e.what();
   }
   web::http::http_response response(web::http::status_codes::InternalError);
   response.set_body(L"Something went wrong while processing the request."); // TODO: include method name
   return response;
 }
 
 web::http::http_response ReworkRequestHandler::HandlePost(const web::uri &uri, const web::json::value &data)
 {
   return web::http::http_response(web::http::status_codes::NotImplemented);
 }
 
 web::http::http_response ReworkRequestHandler::HandleGet(const web::uri &uri, const web::json::value &data)
 {
   MITK_INFO << "GET incoming";
   return web::http::http_response(web::http::status_codes::NotImplemented);
 }
 
 web::http::http_response ReworkRequestHandler::HandleOptions(const web::uri &uri, const web::json::value &data)
 {
   MITK_INFO << "OPTIONS incoming";
 
   web::http::http_response response(web::http::status_codes::OK);
 
   response.headers().add(L"Access-Control-Allow-Methods", "PUT");
   response.headers().add(L"Access-Control-Allow-Headers", "Content-Type");
   response.headers().add(L"Access-Control-Allow-Origin", "http://localhost:8002");
 
   return response;
 }
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 c4a384f7b0..586ac00f95 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,569 +1,533 @@
 /*===================================================================
 
 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 <QmitkNewSegmentationDialog.h>
 #include <mitkExtractSliceFilter.h>
 #include <mitkIOUtil.h>
 #include <mitkImagePixelWriteAccessor.h>
 #include <mitkOverwriteSliceImageFilter.h>
 #include <mitkSegTool2D.h>
 #include <mitkSegmentationInterpolationController.h>
 #include <mitkToolManagerProvider.h>
 #include <mitkVtkImageOverwrite.h>
 
 #include <mitkIRESTManager.h>
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleRegistry.h>
 #include <usServiceTracker.h>
 
 #include "DICOMweb.h"
 #include "ReworkRequestHandler.h"
 
 #include <mitkDICOMDCMTKTagScanner.h>
 #include <mitkDICOMQIIOMimeTypes.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>");
   qRegisterMetaType<std::vector<double>>("std::vector<double>");
   qRegisterMetaType<ReworkRequestHandler::DicomDTO>("DicomDTO");
 
   // 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::OnRestartConnection);
   connect(m_Controls.testConnection, &QPushButton::clicked, this, &SegmentationReworkView::TestConnection);
   connect(m_Controls.checkIndiv, &QCheckBox::stateChanged, this, &SegmentationReworkView::OnIndividualCheckChange);
   connect(
     m_Controls.sliderWidget, &ctkSliderWidget::valueChanged, this, &SegmentationReworkView::OnSliderWidgetChanged);
 
   m_DownloadBaseDir = mitk::IOUtil::GetTempPath() + "segrework";
   MITK_INFO << "using download base dir: " << m_DownloadBaseDir;
   m_UploadBaseDir = mitk::IOUtil::GetTempPath() + "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);
-
   m_RequestHandler = new ReworkRequestHandler(m_DownloadBaseDir);
 
   connect(this, &SegmentationReworkView::InvokeLoadData, this, &SegmentationReworkView::LoadData);
   connect(this, &SegmentationReworkView::InvokeProgress, this, &SegmentationReworkView::AddProgress);
   connect(m_RequestHandler, &ReworkRequestHandler::InvokeProgress, this, &SegmentationReworkView::AddProgress);
   connect(
     m_RequestHandler, &ReworkRequestHandler::InvokeSimilarityGraph, this, &SegmentationReworkView::SetSimilarityGraph);
   connect(m_RequestHandler, &ReworkRequestHandler::InvokeUpdateDcmMeta, this, &SegmentationReworkView::UpdateDcmMeta);
   connect(m_RequestHandler, &ReworkRequestHandler::InvokeLoadData, this, &SegmentationReworkView::LoadData);
 
-  // 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();
-
-  m_DicomWeb = DICOMweb(L"http://193.174.48.78:8090/dcm4chee-arc/aets/DCM4CHEE/");
+  utility::string_t pacsURL = U("http://193.174.48.78:8090");
+  RestartConnection(pacsURL);
 
   us::ModuleContext *context = us::ModuleRegistry::GetModule(1)->GetModuleContext();
   auto managerRef = context->GetServiceReference<mitk::IRESTManager>();
   if (managerRef)
   {
     auto managerService = context->GetService(managerRef);
     if (managerService)
     {
       m_ManagerService = managerService;
     }
   }
 
   m_ManagerService->ReceiveRequest(U("http://127.0.0.1:2020"), m_RequestHandler);
   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 restURL = U("http://localhost:8000");
-
-  // m_HttpHandler->SetAllowOrigin("https://10.128.129.136");
-  // RestartConnection("http://e230-pc03.inet.dkfz-heidelberg.de:8090");
-  // m_HttpHandler->SetAllowOrigin("https://10.128.129.136");
-
-  // RestartConnection("http://10.128.129.136:8080");
-  // 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);
 
   std::map<double, double> thresholdMap;
 
   for (it = m_ScoreMap.begin(); it != m_ScoreMap.end(); it++)
   {
     thresholdMap.insert(std::map<double, double>::value_type(it->first, value));
   }
 
   m_Controls.chartWidget->RemoveData(m_thresholdLabel);
   m_Controls.chartWidget->AddData2D(thresholdMap, m_thresholdLabel);
   m_Controls.chartWidget->SetChartType(m_thresholdLabel, QmitkChartWidget::ChartType::line);
   m_Controls.chartWidget->Show();
 }
 
 void SegmentationReworkView::AddProgress(int progress, QString status)
 {
   auto futureValue = m_Controls.progressBar->value() + progress;
   if (futureValue >= 100)
   {
     m_Controls.progressBar->setValue(0);
     m_Controls.progressBar->setFormat("");
   }
   else
   {
     m_Controls.progressBar->setFormat(status.append(" %p%"));
     m_Controls.progressBar->setValue(futureValue);
   }
 }
 
 void SegmentationReworkView::UpdateDcmMeta(ReworkRequestHandler::DicomDTO dto)
 {
   m_CurrentStudyUID = mitk::RESTUtil::convertToUtf8(dto.studyUID);
   m_SRUID = mitk::RESTUtil::convertToUtf8(dto.srSeriesUID);
   m_GroundTruth = mitk::RESTUtil::convertToUtf8(dto.groundTruth);
 }
 
 pplx::task<bool> SegmentationReworkView::TestConnection()
 {
   mitk::RESTUtil::ParamMap seriesInstancesParams;
 
   seriesInstancesParams.insert(mitk::RESTUtil::ParamMap::value_type(U("limit"), U("1")));
   m_Controls.connectionStatus->setText(QString("Testing connection ..."));
 
   auto requestURI = m_DicomWeb.CreateQIDOUri(seriesInstancesParams);
 
   return m_ManagerService->SendRequest(requestURI).then([=](pplx::task<web::json::value> resultTask) {
     try
     {
       auto result = resultTask.get();
       if (!result.is_null())
       {
         m_Controls.connectionStatus->setText(QString("Connection works!"));
         return true;
       }
       else
       {
         m_Controls.connectionStatus->setText(QString("Trouble with connection. Not valid!"));
         return false;
       }
     }
     catch (mitk::Exception &e)
     {
       MITK_WARN << e.what();
       m_Controls.connectionStatus->setText(QString("No connection possible."));
       return false;
     }
   });
 }
 
 void SegmentationReworkView::OnRestartConnection()
 {
-  RestartConnection();
+  RestartConnection(utility::string_t(m_Controls.dcm4cheeHostValue->text().toStdWString()));
 }
 
-void SegmentationReworkView::RestartConnection(std::string newHost)
+void SegmentationReworkView::RestartConnection(utility::string_t newHost)
 {
   auto hostBefore = m_Controls.dcm4cheeURL->text();
-  std::string host;
+  utility::string_t host;
   if (newHost.empty())
   {
-    host = m_Controls.dcm4cheeHostValue->text().toStdString();
-  }
-  else
-  {
-    host = newHost;
+    return;
   }
 
-  std::string url = host + "/dcm4chee-arc/aets/DCM4CHEE";
+  utility::string_t url = newHost + L"/dcm4chee-arc/aets/DCM4CHEE";
 
   if (!host.empty())
   {
-    MITK_INFO << "Restarting connection to " << url << " ...";
+    MITK_INFO << "Restarting connection to " << mitk::RESTUtil::convertToUtf8(url) << " ...";
     m_Controls.connectionStatus->setText(QString("Restarting connection..."));
     m_Controls.dcm4cheeURL->setText({(utility::conversions::to_utf8string(url).c_str())});
-    // try
-    //{
-    //  m_ManagerService->
-    //  m_DICOMWeb = new mitk::DICOMWeb(utility::conversions::to_string_t(url));
-    //}
-    // catch (std::exception &e)
-    //{
-    //  MITK_WARN << e.what();
-    //  m_Controls.dcm4cheeURL->setText(hostBefore);
-    //  m_Controls.connectionStatus->setText(QString("Invalid host!"));
-    //  return;
-    //}
+
+    m_DicomWeb = DICOMweb(url);
 
     if (!TestConnection().get())
     {
       MITK_INFO << "Restart did not work..";
       m_Controls.connectionStatus->setText(QString("No PACS server available under given host!"));
     }
     else
     {
-      MITK_INFO << "requests to pacs are sent to: " << url;
+      MITK_INFO << "requests to pacs are sent to: " << mitk::RESTUtil::convertToUtf8(url);
     }
   }
   else
   {
     m_Controls.connectionStatus->setText(QString("Host must not be empty!"));
   }
 }
 
 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);
   }
 }
 
 std::string SegmentationReworkView::GetAlgorithmOfSegByPath(std::string path)
 {
   auto scanner = mitk::DICOMDCMTKTagScanner::New();
 
   mitk::DICOMTagPath algorithmName;
   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);
   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.labelSegAValue->setText(algorithmNameA.c_str());
   m_Controls.labelSegBValue->setText(algorithmNameB.c_str());
   m_Controls.labelGroundTruthValue->setText(m_GroundTruth.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";
   m_thresholdLabel = "threshold";
   // m_Controls.chartWidget->Clear();
 
   double sliceIndex = sliceMinStart;
   for (double score : simScoreArray)
   {
     m_ScoreMap.insert(std::map<double, double>::value_type(sliceIndex, score));
     sliceIndex++;
   }
 
   std::map<double, double> thresholdMap;
 
   m_Controls.chartWidget->AddData2D(m_ScoreMap, label);
   m_Controls.chartWidget->AddData2D(thresholdMap, m_thresholdLabel);
   m_Controls.chartWidget->SetChartType(label, QmitkChartWidget::ChartType::line);
   m_Controls.chartWidget->SetChartType(m_thresholdLabel, QmitkChartWidget::ChartType::line);
   m_Controls.chartWidget->SetXAxisLabel("slice number");
   m_Controls.chartWidget->SetYAxisLabel("similarity in percent");
   m_Controls.chartWidget->SetTitle("Similartiy Score for Segmentation Comparison");
+  m_Controls.chartWidget->Show();
 }
 
 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.SendSTOW(filePath, mitk::RESTUtil::convertToTString(m_CurrentStudyUID)).then([=] {
       emit InvokeProgress(80, {"persist reworked SEG to evaluation database"});
 
       // MitkUriBuilder queryBuilder(U("tasks/evaluations/"));
       // queryBuilder.append_query(U("srUID"), utility::conversions::to_string_t(m_SRUID));
 
       // m_RestService->Get(queryBuilder.to_string()).then([=](web::json::value 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 << "successfully stored";
       //    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 d2a882575a..c84854c726 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,106 +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 <mitkImage.h>
 #include <mitkLabelSetImage.h>
 #include <mitkIRESTManager.h>
 
 #include "ReworkRequestHandler.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 UpdateChartWidget();
   void ClearChartWidget();
   void LoadData(std::vector<std::string> filePathList);
   void OnSliderWidgetChanged(double value);
   void AddProgress(int, QString status);
   void UpdateDcmMeta(ReworkRequestHandler::DicomDTO dto);
 
 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(std::string = "");
+  void RestartConnection(utility::string_t newHost);
   void OnRestartConnection();
   pplx::task<bool> TestConnection();
   void OnIndividualCheckChange(int state);
 
   Ui::SegmentationReworkViewControls m_Controls;
 
 private:
   std::vector<unsigned int> CreateSegmentation(mitk::Image::Pointer baseSegmentation, double threshold);
 
   std::string GetAlgorithmOfSegByPath(std::string path);
 
   void SetSimilarityGraph(std::vector<double> simScoreArray, int sliceMinStart);
 
   mitk::IRESTManager* m_ManagerService;
   ReworkRequestHandler* m_RequestHandler;
 
   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;
   std::string m_thresholdLabel;
   DICOMweb m_DicomWeb;
 
   QWidget *m_Parent;
   int counter;
 };
 
 #endif // SegmentationReworkView_h