diff --git a/Modules/REST/src/mitkRESTClient.cpp b/Modules/REST/src/mitkRESTClient.cpp
index d949aa0787..2071b386ad 100644
--- a/Modules/REST/src/mitkRESTClient.cpp
+++ b/Modules/REST/src/mitkRESTClient.cpp
@@ -1,199 +1,205 @@
 /*===================================================================
 
 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 <mitkExceptionMacro.h>
 #include <mitkRESTClient.h>
 #include <mitkRESTUtil.h>
 
 #include <cpprest/filestream.h>
 #include <cpprest/http_client.h>
 
 using http_client = web::http::client::http_client;
 using http_request = web::http::http_request;
 using http_response = web::http::http_response;
 using methods = web::http::methods;
 using status_codes = web::http::status_codes;
 using file_buffer = concurrency::streams::file_buffer<uint8_t>;
 using streambuf = concurrency::streams::streambuf<uint8_t>;
 
 mitk::RESTClient::RESTClient() {}
 
 mitk::RESTClient::~RESTClient() {}
 
 pplx::task<web::json::value> mitk::RESTClient::Get(const web::uri &uri,
                                                    const std::map<utility::string_t, utility::string_t> headers)
 {
   auto client = new http_client(uri);
   http_request request;
 
   for (auto param : headers)
   {
     request.headers().add(param.first, param.second);
   }
 
   return client->request(request).then([=](pplx::task<web::http::http_response> responseTask) {
     try
     {
       auto response = responseTask.get();
       auto status = response.status_code();
 
       if (status_codes::OK != status)
         mitkThrow();
 
       auto requestContentType = response.headers().content_type();
 
       if (U("application/json") != requestContentType)
         response.headers().set_content_type(U("application/json"));
 
       return response.extract_json().get();
     }
     catch (...)
     {
       mitkThrow() << "Getting response went wrong";
     }
   });
 }
 
 pplx::task<web::json::value> mitk::RESTClient::Get(const web::uri &uri,
                                                    const utility::string_t &filePath,
                                                    const std::map<utility::string_t, utility::string_t> headers)
 {
   auto client = new http_client(uri);
   auto fileBuffer = std::make_shared<concurrency::streams::streambuf<uint8_t>>();
   http_request request;
 
   for (auto param : headers)
   {
     request.headers().add(param.first, param.second);
   }
 
   // Open file stream for the specified file path
   return file_buffer::open(filePath, std::ios::out)
     .then([=](streambuf outFile) -> pplx::task<http_response> {
       *fileBuffer = outFile;
       return client->request(methods::GET);
     })
     // Write the response body into the file buffer
     .then([=](http_response response) -> pplx::task<size_t> {
       auto status = response.status_code();
 
       if (status_codes::OK != status)
         mitkThrow() << "GET ended up with response " << RESTUtil::convertToUtf8(response.to_string());
 
       return response.body().read_to_end(*fileBuffer);
     })
     // Close the file buffer
     .then([=](size_t) { return fileBuffer->close(); })
     // Return empty JSON object
     .then([=]() { return web::json::value(); });
 }
 
 pplx::task<web::json::value> mitk::RESTClient::Put(const web::uri &uri, const web::json::value *content)
 {
   auto client = new http_client(uri);
   http_request request(methods::PUT);
 
   if (nullptr != content)
     request.set_body(*content);
 
   return client->request(request).then([=](pplx::task<http_response> responseTask) {
     try
     {
       auto response = responseTask.get();
       auto status = response.status_code();
 
       if (status_codes::OK != status)
         mitkThrow();
 
       // Parse content type to application/json if it isn't already. This is
       // important if the content type is e.g. application/dicom+json.
       auto requestContentType = response.headers().content_type();
 
       if (U("application/json") != requestContentType)
         response.headers().set_content_type(U("application/json"));
 
       return response.extract_json().get();
     }
     catch (...)
     {
       mitkThrow() << "Getting response went wrong";
     }
   });
 }
 
 pplx::task<web::json::value> mitk::RESTClient::Post(const web::uri &uri,
                                                     const std::vector<unsigned char> *content,
                                                     const std::map<utility::string_t, utility::string_t> headers)
 {
   auto request = InitRequest(headers);
   request.set_method(methods::POST);
 
   if (nullptr != content)
     request.set_body(*content);
 
   return ExecutePost(uri, request);
 }
 
 pplx::task<web::json::value> mitk::RESTClient::Post(const web::uri &uri,
                                                     const web::json::value *content,
                                                     const std::map<utility::string_t, utility::string_t> headers)
 {
   auto request = InitRequest(headers);
   request.set_method(methods::POST);
 
   if (nullptr != content)
     request.set_body(*content);
 
   return ExecutePost(uri, request);
 }
 
 http_request mitk::RESTClient::InitRequest(const std::map<utility::string_t, utility::string_t> headers)
 {
   http_request request;
 
   for (auto param : headers)
   {
     request.headers().add(param.first, param.second);
   }
   return request;
 }
 
 pplx::task<web::json::value> mitk::RESTClient::ExecutePost(const web::uri &uri, http_request request)
 {
   auto client = new http_client(uri);
   return client->request(request).then([=](pplx::task<http_response> responseTask) {
     try
     {
       auto response = responseTask.get();
       auto status = response.status_code();
 
-      if (status_codes::Created != status)
+      if (status_codes::OK != status)
         mitkThrow();
 
       // Parse content type to application/json if it isn't already. This is
       // important if the content type is e.g. application/dicom+json.
       auto requestContentType = response.headers().content_type();
-      if (U("application/json") != requestContentType)
+      if (requestContentType.find(U("json")))
+      {
         response.headers().set_content_type(U("application/json"));
+        return response.extract_json().get();
+      }
+      else
+      {
+        return web::json::value();
+      }
 
-      return response.extract_json().get();
     }
     catch (...)
     {
       mitkThrow() << "Getting response went wrong";
     }
   });
 }
diff --git a/Plugins/org.mitk.gui.qt.inject/src/internal/InjectView.cpp b/Plugins/org.mitk.gui.qt.inject/src/internal/InjectView.cpp
index d3568aa3c1..447a609fcf 100644
--- a/Plugins/org.mitk.gui.qt.inject/src/internal/InjectView.cpp
+++ b/Plugins/org.mitk.gui.qt.inject/src/internal/InjectView.cpp
@@ -1,279 +1,282 @@
 /*===================================================================
 
 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 "InjectView.h"
 
 #include <Poco/File.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 <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleRegistry.h>
 #include <usServiceTracker.h>
 
 #include <mitkDICOMweb.h>
 
 #include <mitkDICOMDCMTKTagScanner.h>
 #include <mitkDICOMQIIOMimeTypes.h>
 
 const std::string InjectView::VIEW_ID = "org.mitk.views.injectview";
 
 void InjectView::SetFocus() {}
 
 void InjectView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   m_Parent = parent;
 
   qRegisterMetaType<std::vector<std::string>>("std::vector<std::string>");
   qRegisterMetaType<std::vector<double>>("std::vector<double>");
   qRegisterMetaType<InjectRequestHandler::DicomDTO>("DicomDTO");
 
   m_Controls.cleanDicomBtn->setVisible(true);
 
   connect(m_Controls.cleanDicomBtn, &QPushButton::clicked, this, &InjectView::CleanDicomFolder);
   connect(m_Controls.restartConnection, &QPushButton::clicked, this, &InjectView::OnRestartConnection);
   connect(m_Controls.testConnection, &QPushButton::clicked, this, &InjectView::TestConnection);
   
   m_DownloadBaseDir = mitk::IOUtil::GetTempPath() + "segInject";
   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);
   }
 
   m_HostURL = U("http://localhost");
-
   auto host = m_HostURL;
   auto envHostURL = std::getenv("HOST_URL");
-
   if (envHostURL)
   {
-    host = mitk::RESTUtil::convertToTString(std::string(envHostURL));
+    MITK_INFO << "host url " << std::string(envHostURL);
+    m_HostURL = mitk::RESTUtil::convertToTString(std::string(envHostURL));
+    host = m_HostURL;
+  }
+  else
+  {
+    host = host.append(U(":8080"));
   }
 
   m_restURL = host.append(U("/rest-srs"));
-
+  MITK_INFO << "rest url: " << mitk::RESTUtil::convertToUtf8(m_restURL);
   utility::string_t pacsURL = U("http://193.174.48.78:8090");
   auto envPacsURL = std::getenv("PACS_URL");
 
   if (envPacsURL)
   {
     pacsURL = mitk::RESTUtil::convertToTString(std::string(envPacsURL));
   }
 
-
   m_RequestHandler = new InjectRequestHandler(m_DownloadBaseDir, pacsURL);
 
   connect(this, &InjectView::InvokeProgress, this, &InjectView::AddProgress);
   connect(m_RequestHandler, &InjectRequestHandler::InvokeProgress, this, &InjectView::AddProgress);
   connect(
     m_RequestHandler, &InjectRequestHandler::InvokeUpdateDcmMeta, this, &InjectView::InitializeDcmMeta);
   connect(m_RequestHandler, &InjectRequestHandler::InvokeLoadData, this, &InjectView::LoadData);
 
   // Get the micro service
   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;
     }
   }
 
   // Setup PACS connection
   RestartConnection(pacsURL);
 }
 
 void InjectView::Activated()
 {
   MITK_INFO << "activated";
   StartServer();
 }
 
 void InjectView::Deactivated()
 {
   MITK_INFO << "deactivated";
   m_ManagerService->HandleDeleteObserver(m_RequestHandler);
 }
 
 void InjectView::Visible()
 {
 }
 
 void InjectView::Hidden()
 {
 }
 
 void InjectView::StartServer()
 {
   utility::string_t path = U("/inject");
 
   auto pathEnv = std::getenv("SERVER_PATH");
   if (pathEnv)
   {
     path = mitk::RESTUtil::convertToTString(std::string(pathEnv));
   }
 
   utility::string_t port = U(":4040");
-  utility::string_t address = m_HostURL;
+  utility::string_t address = U("http://+");
   address.append(port);
   address.append(path);
   // Setup listening server
   m_ManagerService->ReceiveRequest(address, m_RequestHandler);
   MITK_INFO << "Listening for requests at: " << utility::conversions::to_utf8string(address);
 }
 
 void InjectView::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 InjectView::InitializeDcmMeta(InjectRequestHandler::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> InjectView::TestConnection()
 {
   mitk::RESTUtil::ParamMap seriesInstancesParams;
 
   seriesInstancesParams.insert(mitk::RESTUtil::ParamMap::value_type(U("limit"), U("1")));
   m_Controls.connectionStatus->setText(QString("Testing connection ..."));
 
   return m_DicomWeb.SendQIDO(seriesInstancesParams).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 InjectView::OnRestartConnection()
 {
   RestartConnection(mitk::RESTUtil::convertToTString(m_Controls.dcm4cheeHostValue->text().toStdString()));
 }
 
 void InjectView::RestartConnection(utility::string_t newHost)
 {
   utility::string_t host;
   if (newHost.empty())
   {
     MITK_INFO << "Host was empty";
     m_Controls.connectionStatus->setText(QString("Host must not be empty!"));
     return;
   }
 
   utility::string_t url = newHost + U("/dcm4chee-arc/aets/DCM4CHEE/");
 
   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())});
 
   m_DicomWeb = mitk::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: " << mitk::RESTUtil::convertToUtf8(url);
   }
 }
 
 
 mitk::DataStorage::SetOfObjects::Pointer InjectView::LoadData(std::vector<std::string> filePathList)
 {
   MITK_INFO << "Pushing data to data storage ...";
   auto ds = GetDataStorage();
   auto dataNodes = mitk::IOUtil::Load(filePathList, *ds);
   // reinit view
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(ds);
   return dataNodes;
 }
 
 void InjectView::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;
   }
 
   auto downloadDir = Poco::File(m_DownloadBaseDir);
   downloadDir.remove(true);
 }
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 577f405398..9baa592b50 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,587 +1,588 @@
 /*===================================================================
 
 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 <Poco/File.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 <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleRegistry.h>
 #include <usServiceTracker.h>
 
 #include <mitkDICOMweb.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;
 
   qRegisterMetaType<std::vector<std::string>>("std::vector<std::string>");
   qRegisterMetaType<std::vector<double>>("std::vector<double>");
   qRegisterMetaType<ReworkRequestHandler::DicomDTO>("DicomDTO");
 
   m_Controls.cleanDicomBtn->setVisible(true);
   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);
   }
 
   m_HostURL = U("http://localhost");
-
-  auto host = m_HostURL; 
-
+  auto host = m_HostURL;
   auto envHostURL = std::getenv("HOST_URL");
-
   if (envHostURL)
   {
-    host = mitk::RESTUtil::convertToTString(std::string(envHostURL));
+    MITK_INFO << "host url " << std::string(envHostURL);
+    m_HostURL = mitk::RESTUtil::convertToTString(std::string(envHostURL));
+    host = m_HostURL;
+  }
+  else
+  {
+    host = host.append(U(":8080"));
   }
 
   m_restURL = host.append(U("/rest-srs"));
-
+  MITK_INFO << "rest url: " << mitk::RESTUtil::convertToUtf8(m_restURL);
   utility::string_t pacsURL = U("http://193.174.48.78:8090");
   auto envPacsURL = std::getenv("PACS_URL");
 
   if (envPacsURL)
   {
     pacsURL = mitk::RESTUtil::convertToTString(std::string(envPacsURL));
   }
 
   m_RequestHandler = new ReworkRequestHandler(m_DownloadBaseDir, pacsURL);
 
   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::InitializeDcmMeta);
   connect(m_RequestHandler, &ReworkRequestHandler::InvokeLoadData, this, &SegmentationReworkView::LoadData);
   connect(
     m_RequestHandler, &ReworkRequestHandler::InvokeLoadDataSegRework, this, &SegmentationReworkView::LoadDataSegRework);
 
   // Get the micro service
   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;
     }
   }
-  // Setup Server
-  //StartServer();
-  // Setup PACS connection
+
   RestartConnection(pacsURL);
 }
 
 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;
+
+  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::InitializeDcmMeta(ReworkRequestHandler::DicomDTO dto)
 {
   m_CurrentStudyUID = mitk::RESTUtil::convertToUtf8(dto.studyUID);
   m_SRUID = mitk::RESTUtil::convertToUtf8(dto.srSeriesUID);
   m_GroundTruth = mitk::RESTUtil::convertToUtf8(dto.groundTruth);
 }
 
 void SegmentationReworkView::Activated()
 {
   StartServer();
   MITK_INFO << "activated";
 }
 
 void SegmentationReworkView::Deactivated()
 {
   MITK_INFO << "deactivated";
   m_ManagerService->HandleDeleteObserver(m_RequestHandler);
 }
 
 void SegmentationReworkView::Visible()
 {
   MITK_INFO << "visible";
 }
 
 void SegmentationReworkView::Hidden()
 {
   MITK_INFO << "hidden";
 }
 
 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 ..."));
 
   return m_DicomWeb.SendQIDO(seriesInstancesParams).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(mitk::RESTUtil::convertToTString(m_Controls.dcm4cheeHostValue->text().toStdString()));
 }
 
 void SegmentationReworkView::RestartConnection(utility::string_t newHost)
 {
   utility::string_t host;
   if (newHost.empty())
   {
     MITK_INFO << "Host was empty";
     m_Controls.connectionStatus->setText(QString("Host must not be empty!"));
     return;
   }
 
   utility::string_t url = newHost + U("/dcm4chee-arc/aets/DCM4CHEE/");
 
   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())});
 
   m_DicomWeb = mitk::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: " << mitk::RESTUtil::convertToUtf8(url);
   }
 }
 
 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;
 }
 
 mitk::DataStorage::SetOfObjects::Pointer SegmentationReworkView::LoadData(std::vector<std::string> filePathList)
 {
   MITK_INFO << "Pushing data to data storage ...";
   auto ds = GetDataStorage();
   auto dataNodes = mitk::IOUtil::Load(filePathList, *ds);
   // reinit view
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(ds);
   return dataNodes;
 }
 
 void SegmentationReworkView::LoadDataSegRework(std::vector<std::string> filePathList)
 {
   auto dataNodes = LoadData(filePathList);
 
   // 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::SetSimilarityGraph(std::vector<double> simScoreArray, int sliceMinStart)
 {
   std::string label = "similarity graph";
   m_thresholdLabel = "threshold";
 
   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::StartServer()
 {
   utility::string_t path = U("/inject");
 
   auto pathEnv = std::getenv("SERVER_PATH");
   if (pathEnv)
   {
     path = mitk::RESTUtil::convertToTString(std::string(pathEnv));
   }
 
   utility::string_t port = U(":4040");
-  utility::string_t address = m_HostURL;
+  utility::string_t address = U("http://+");
   address.append(port);
   address.append(path);
   // Setup listening server
   m_ManagerService->ReceiveRequest(address, m_RequestHandler);
   MITK_INFO << "Listening for requests at: " << utility::conversions::to_utf8string(address);
 }
 
 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(50, {"persist reworked SEG to evaluation database"});
 
       mitk::DICOMweb::MitkUriBuilder queryBuilder(m_restURL + U("/tasks/evaluations/"));
       queryBuilder.append_query(U("srUID"), utility::conversions::to_string_t(m_SRUID));
 
       auto content = web::json::value();
 
       m_ManagerService->SendRequest(queryBuilder.to_uri(), mitk::IRESTManager::RequestType::Get, &content)
         .then([=](web::json::value result) {
           MITK_INFO << "after GET";
           MITK_INFO << utility::conversions::to_utf8string(result.serialize());
           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("/");
 
           mitk::DICOMweb::MitkUriBuilder queryBuilder(m_restURL + U("/tasks/evaluations"));
           queryBuilder.append_path(utility::conversions::to_string_t(idParam));
 
           m_ManagerService->SendRequest(queryBuilder.to_uri(), mitk::IRESTManager::RequestType::Put, &updatedContent)
             .then([=](web::json::value result) {
               MITK_INFO << utility::conversions::to_utf8string(result.serialize());
               if (result[U("reworkedSegmentationUID")].as_string() == utility::conversions::to_string_t(segSeriesUID))
               {
                 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);
 
   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;
   }
 
   auto downloadDir = Poco::File(m_DownloadBaseDir);
   downloadDir.remove(true);
 }