diff --git a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkREST.cpp b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkREST.cpp
index 8951228aad..d00a8d4e6d 100644
--- a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkREST.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkREST.cpp
@@ -1,131 +1,156 @@
 /*===================================================================
 
 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 <sstream>
+#include <iostream>
+
 #include "SegmentationReworkREST.h"
 #include <mitkCommon.h>
 #include <mitkRESTUtil.h>
 
 SegmentationReworkREST::SegmentationReworkREST() {}
 
 SegmentationReworkREST::SegmentationReworkREST(utility::string_t url) : mitk::RESTServer(url)
 {
   m_Listener.support(MitkRESTMethods::PUT, std::bind(&SegmentationReworkREST::HandlePut, this, std::placeholders::_1));
   m_Listener.support(MitkRESTMethods::GET, std::bind(&SegmentationReworkREST::HandleGet, this, std::placeholders::_1));
 }
 
 SegmentationReworkREST::~SegmentationReworkREST() {}
 
 void SegmentationReworkREST::HandleGet(MitkRequest message) 
 {
   auto messageString = message.to_string();
   MITK_INFO << "Message GET incoming...";
   MITK_INFO << mitk::RESTUtil::convertToUtf8(messageString);
 
   auto httpParams = web::uri::split_query(message.request_uri().query());
 
   // IHE Invoke Image Display style
   auto requestType = httpParams.find(U("requestType"));
 
-  if (requestType != httpParams.end() && requestType->second == L"IMAGE_SEG")
+  if (requestType != httpParams.end() && requestType->second == U("IMAGE_SEG"))
   {
     try
     {
       auto studyUID = httpParams.at(U("studyUID"));
       auto imageSeriesUID = httpParams.at(U("imageSeriesUID"));
       auto segSeriesUID = httpParams.at(U("segSeriesUID"));
 
       DicomDTO dto;
       dto.imageSeriesUID = mitk::RESTUtil::convertToUtf8(imageSeriesUID);
       dto.studyUID = mitk::RESTUtil::convertToUtf8(studyUID);
       dto.segSeriesUIDA = mitk::RESTUtil::convertToUtf8(segSeriesUID);
 
       m_GetImageSegCallback(dto);
 
       MitkResponse response(MitkRestStatusCodes::OK);
       response.set_body("Sure, i got you.. have an awesome day");
       message.reply(response);
     }
     catch (std::out_of_range& e) {
       message.reply(MitkRestStatusCodes::BadRequest, "oh man, that was not expected: " + std::string(e.what()));
     }
-  }
-  else if (requestType != httpParams.end() && requestType->second == L"SEG_EVALUATION") 
+  } else if (requestType != httpParams.end() && requestType->second == U("SEG_EVALUATION")) 
   {
     // TODO: implement PUT handling as GET
+  } else if (requestType != httpParams.end() && requestType->second == U("IMAGE_SEG_LIST"))
+  {
+    auto studyUID = httpParams.at(U("studyUID"));
+    auto imageSeriesUID = httpParams.at(U("imageSeriesUID"));
+    auto segSeriesUIDList = httpParams.at(U("segSeriesUIDList"));
+
+    DicomDTO dto;
+    dto.imageSeriesUID = mitk::RESTUtil::convertToUtf8(imageSeriesUID);
+    dto.studyUID = mitk::RESTUtil::convertToUtf8(studyUID);
+
+    auto segSeriesUIDListUtf8 = mitk::RESTUtil::convertToUtf8(segSeriesUIDList);
+  
+    std::istringstream f(segSeriesUIDListUtf8);
+    std::string s;
+    while (getline(f, s, ',')) {
+      dto.segSeriesUIDList.push_back(s);
+    }
+
+    m_GetImageSegCallback(dto);
+
+    MitkResponse response(MitkRestStatusCodes::OK);
+    response.set_body("Sure, i got you.. have an awesome day");
+    message.reply(response);
   } else
   {
     message.reply(MitkRestStatusCodes::BadRequest, "Oh man, i can only deal with 'requestType' = 'IMAGE+SEG'...");
   }
 }
 
 void SegmentationReworkREST::HandlePut(MitkRequest message)
 {
   auto messageString = message.to_string();
   MITK_INFO << "Message PUT incoming...";
   MITK_INFO << mitk::RESTUtil::convertToUtf8(messageString);
 
   try
   {
     auto jsonMessage = message.extract_json().get();
 
     auto messageTypeKey = jsonMessage.at(U("messageType"));
     if (messageTypeKey.as_string() == U("downloadData"))
     {
       auto imageStudyUIDKey = jsonMessage.at(U("studyUID"));
       auto srSeriesUIDKey = jsonMessage.at(U("srSeriesUID"));
 
       auto groundTruthKey = jsonMessage.at(U("groundTruth"));
 
       auto simScoreKey = jsonMessage.at(U("simScoreArray"));
       auto minSliceStartKey = jsonMessage.at(U("minSliceStart"));
 
       DicomDTO dto;
       dto.srSeriesUID = mitk::RESTUtil::convertToUtf8(srSeriesUIDKey.as_string());
 
       dto.groundTruth = mitk::RESTUtil::convertToUtf8(groundTruthKey.as_string());
 
       dto.studyUID = mitk::RESTUtil::convertToUtf8(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;
       m_PutCallback(dto);
       emit InvokeUpdateChartWidget();
     }
     else
     {
       message.reply(MitkRestStatusCodes::BadRequest, "Oh man, i can only deal with 'messageType' = 'downloadData'...");
     }
   }
   catch (MitkJsonException &e)
   {
     MITK_ERROR << e.what() << ".. oh man, that was not expected";
     message.reply(MitkRestStatusCodes::BadRequest, "oh man, that was not expected");
     return;
   }
   MitkResponse response(MitkRestStatusCodes::OK);
   response.headers().add(U("Access-Control-Allow-Origin"), U("localhost:9000/*"));
   response.set_body("Sure, i got you.. have an awesome day");
   message.reply(response);
   return;
 }
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkREST.h b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkREST.h
index 2ca3f0f79c..3b02b39b24 100644
--- a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkREST.h
+++ b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkREST.h
@@ -1,72 +1,73 @@
 /*===================================================================
 
 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 SegmentationReworkREST_h
 #define SegmentationReworkREST_h
 
 #include <mitkRESTServer.h>
 
 class SegmentationReworkREST : public mitk::RESTServer
 {
   Q_OBJECT
 
 public:
   struct DicomDTO
   {
     std::string segSeriesUIDA;
     std::string segSeriesUIDB;
     std::string imageSeriesUID;
     std::string studyUID;
     std::string segInstanceUIDA;
     std::string segInstanceUIDB;
     std::string srSeriesUID;
+    std::vector<std::string> segSeriesUIDList;
     std::vector<double> simScoreArray;
     int minSliceStart;
     std::string groundTruth;
   };
 
   SegmentationReworkREST();
   SegmentationReworkREST(utility::string_t url);
   ~SegmentationReworkREST();
 
   void HandlePut(MitkRequest message);
   void HandleGet(MitkRequest message);
 
   void SetPutCallback(std::function<void(DicomDTO &message)> callback)
   { 
 	  m_PutCallback = callback;
   }
 
   void SetGetImageSegCallback(std::function<void(DicomDTO &message)> callback) 
   {
 	  m_GetImageSegCallback = callback;
   }
 
   void SetGetEvalCallback(std::function<void(DicomDTO &message)> callback)
   {
     m_GetEvalCallback = callback;
   }
 
 signals:
   void InvokeUpdateChartWidget();
 
 private:
   std::function<void(DicomDTO &message)> m_PutCallback;
   std::function<void(DicomDTO &message)> m_GetImageSegCallback;
   std::function<void(DicomDTO &message)> m_GetEvalCallback;
 };
 
 #endif // SegmentationReworkREST_h
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 e4d5094965..a3c553a66e 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,350 +1,363 @@
 /*===================================================================
 
 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"
 
 // Qt
 #include <QMessageBox>
 
 #include <mitkIOUtil.h>
 #include "QmitkNewSegmentationDialog.h"
 #include "mitkSegTool2D.h"
 #include "mitkToolManagerProvider.h"
 
 #include "mitkIOMimeTypes.h"
 
 #include <boost/uuid/uuid.hpp>            // uuid class
 #include <boost/uuid/uuid_generators.hpp> // generators
 #include <boost/uuid/uuid_io.hpp> 
 #include <boost/lexical_cast.hpp>
 
 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>");
 
+  m_Controls.chartWidget->setVisible(false);
+
   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);
 
   m_downloadBaseDir = std::experimental::filesystem::path("/temp/");
   m_tempSegDir = std::experimental::filesystem::path("/tempSeg/");
 
   if (!std::experimental::filesystem::exists(m_downloadBaseDir))
   {
     std::experimental::filesystem::create_directory(m_downloadBaseDir);
   }
 
   if (!std::experimental::filesystem::exists(m_tempSegDir))
   {
     std::experimental::filesystem::create_directory(m_tempSegDir);
   }
 
   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);
 
   m_HttpHandler->SetPutCallback(std::bind(&SegmentationReworkView::RESTPutCallback, this, std::placeholders::_1));
   m_HttpHandler->SetGetImageSegCallback(std::bind(&SegmentationReworkView::RESTGetCallback, this, std::placeholders::_1));
   m_HttpHandler->Open().wait();
 
   MITK_INFO << "Listening for requests at: " << utility::conversions::to_utf8string(address);
 
   utility::string_t pacsHost = U("http://193.174.48.78:8090/dcm4chee-arc/aets/DCM4CHEE");
   m_DICOMWeb = new mitk::DICOMWeb(pacsHost);
 }
 
 void SegmentationReworkView::RESTPutCallback(const SegmentationReworkREST::DicomDTO &dto)
 {
   SetSimilarityGraph(dto.simScoreArray, dto.minSliceStart);
 
   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;
         }
       }
 
       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 ...";
       boost::uuids::random_generator generator;
 
       std::string folderPathSeries = std::experimental::filesystem::path(m_downloadBaseDir).append(boost::uuids::to_string(generator())).string() + "/";
       std::experimental::filesystem::create_directory(folderPathSeries);
 
       std::string pathSegA = std::experimental::filesystem::path(m_downloadBaseDir).append(boost::uuids::to_string(generator())).string() + "/";
       std::string pathSegB = std::experimental::filesystem::path(m_downloadBaseDir).append(boost::uuids::to_string(generator())).string() + "/";
 
       auto folderPathSegA = utility::conversions::to_string_t(pathSegA);
       auto folderPathSegB = utility::conversions::to_string_t(pathSegB);
 
       std::experimental::filesystem::create_directory(pathSegA);
       std::experimental::filesystem::create_directory(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) {
         auto fileNameA = std::experimental::filesystem::path(filePathList[1]).filename();
         auto fileNameB = std::experimental::filesystem::path(filePathList[2]).filename();
         m_Controls.labelSegA->setText(m_Controls.labelSegA->text() + " " + QString::fromUtf8(fileNameA.string().c_str()));
         m_Controls.labelSegB->setText(m_Controls.labelSegB->text() + " " + QString::fromUtf8(fileNameB.string().c_str()));
         InvokeLoadData(filePathList);
       });
 
     });
 
   }
   catch (mitk::Exception&  e) {
     MITK_ERROR << e.what();
   }
 }
 
 void SegmentationReworkView::RESTGetCallback(const SegmentationReworkREST::DicomDTO &dto) 
 {
   boost::uuids::random_generator generator;
 
   std::string folderPathSeries = std::experimental::filesystem::path(m_downloadBaseDir).append(boost::uuids::to_string(generator())).string() + "/";
   std::experimental::filesystem::create_directory(folderPathSeries);
 
   std::string pathSeg = std::experimental::filesystem::path(m_downloadBaseDir).append(boost::uuids::to_string(generator())).string() + "/";
   auto folderPathSeg = utility::conversions::to_string_t(pathSeg);
   std::experimental::filesystem::create_directory(pathSeg);
 
   std::vector<pplx::task<std::string>> tasks;
   auto imageSeriesTask = m_DICOMWeb->WadoRS(utility::conversions::to_string_t(folderPathSeries), dto.studyUID, dto.imageSeriesUID);
-  auto segATask = m_DICOMWeb->WadoRS(folderPathSeg, dto.studyUID, dto.segSeriesUIDA);
+  
   tasks.push_back(imageSeriesTask);
-  tasks.push_back(segATask);
+
+  if (dto.segSeriesUIDList.size() > 0) {
+    for (std::string segSeriesUID : dto.segSeriesUIDList)
+    {
+      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); });
 }
 
 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_SegA = dataNodes->at(1);
-  if (dataNodes->size() == 3) {
+  if (dataNodes->size() > 2) {
     m_SegB = dataNodes->at(2);
   }
 }
 
 void SegmentationReworkView::UpdateChartWidget()
 {
   m_Controls.chartWidget->Show();
 }
 
 void SegmentationReworkView::SetSimilarityGraph(std::vector<double> simScoreArray, int sliceMinStart)
 {
   std::map<double, double> map;
 
   double sliceIndex = sliceMinStart;
   for (double score : simScoreArray)
   {
     map.insert(std::map<double, double>::value_type(sliceIndex, score));
     sliceIndex++;
   }
   m_Controls.chartWidget->AddData2D(map, "similarity graph");
   m_Controls.chartWidget->SetChartType("similarity graph", QmitkChartWidget::ChartType::line);
   m_Controls.chartWidget->SetXAxisLabel("slice number");
   m_Controls.chartWidget->SetYAxisLabel("similarity in percent");
 }
 
 void SegmentationReworkView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
   const QList<mitk::DataNode::Pointer> &nodes)
 {
   // iterate all selected objects, adjust warning visibility
   foreach(mitk::DataNode::Pointer node, nodes)
   {
     if (node.IsNotNull() && dynamic_cast<mitk::Image *>(node->GetData()))
     {
       m_Controls.labelWarning->setVisible(false);
       return;
     }
   }
 
   m_Controls.labelWarning->setVisible(true);
 }
 
 void SegmentationReworkView::UploadNewSegmentation()
 {
   boost::uuids::random_generator generator;
 
   std::string folderPathSeg = std::experimental::filesystem::path(m_tempSegDir).append(boost::uuids::to_string(generator())).string() + "/";
   std::experimental::filesystem::create_directory(folderPathSeg);
 
   const std::string savePath = folderPathSeg + m_SegC->GetName() + ".dcm";
   const std::string mimeType = mitk::IOMimeTypes::DICOM_MIMETYPE_NAME();
   mitk::IOUtil::Save(m_SegC->GetData(), mimeType, savePath);
 
   auto filePath = utility::conversions::to_string_t(savePath);
   try {
     m_DICOMWeb->StowRS(filePath, m_CurrentStudyUID).wait();
   }
   catch (const std::exception &exception)
   {
     std::cout << exception.what() << std::endl;
   }
 }
 
 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());
   }
   else if (m_Controls.radioB->isChecked()) {
     baseImage = dynamic_cast<mitk::Image*>(m_SegB->GetData());
   }
 
   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;
     }
     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);
   std::experimental::filesystem::create_directory(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 2622cb320f..b5d162cf03 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,94 +1,96 @@
 /*===================================================================
 
 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 <filesystem>
 
 /**
   \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 RESTGetMultipleSegCallback(const SegmentationReworkREST::DicomDTO& dto);
+
   void UpdateChartWidget();
   void LoadData(std::vector<std::string> filePathList);
 
 signals:
   void InvokeLoadData(std::vector<std::string> filePathList);
 
 protected:
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   virtual void SetFocus() override;
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer source,
                                   const QList<mitk::DataNode::Pointer> &nodes) override;
 
   /// \brief Called when the user clicks the GUI button
   void DoImageProcessing();
   void CreateNewSegmentationC();
 
   void CleanDicomFolder();
   void UploadNewSegmentation();
 
   Ui::SegmentationReworkViewControls m_Controls;
 
 private:
 
   void SetSimilarityGraph(std::vector<double> simScoreArray, int sliceMinStart);
   std::unique_ptr<SegmentationReworkREST> m_HttpHandler;
   mitk::DICOMWeb* m_DICOMWeb;
 
   std::string m_CurrentStudyUID;
 
   std::experimental::filesystem::path m_downloadBaseDir;
   std::experimental::filesystem::path m_tempSegDir;
 
   mitk::DataNode::Pointer m_Image;
   mitk::DataNode::Pointer m_SegA;
   mitk::DataNode::Pointer m_SegB;
   mitk::DataNode::Pointer m_SegC;
   std::string m_GroundTruth;
 
   QWidget* m_Parent;
 };
 
 #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 9723f417a4..983f1e292a 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,197 +1,184 @@
 <?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>673</height>
+    <height>691</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>
-    <widget class="QLabel" name="labelWarning">
-     <property name="enabled">
-      <bool>true</bool>
-     </property>
-     <property name="styleSheet">
-      <string notr="true">QLabel { color: rgb(255, 0, 0) }</string>
-     </property>
-     <property name="text">
-      <string>Please select an image!</string>
-     </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="Line" name="line">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </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="Line" name="line_2">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </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="QPushButton" name="buttonNewSeg">
         <property name="text">
          <string>Create new Segmentation</string>
         </property>
        </widget>
       </item>
      </layout>
     </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>
    <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>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>