diff --git a/Modules/DICOMweb/src/mitkDICOMweb.cpp b/Modules/DICOMweb/src/mitkDICOMweb.cpp
index a7ec34f47a..47e2399c53 100644
--- a/Modules/DICOMweb/src/mitkDICOMweb.cpp
+++ b/Modules/DICOMweb/src/mitkDICOMweb.cpp
@@ -1,218 +1,218 @@
/*===================================================================
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 "mitkDICOMweb.h"
mitk::DICOMweb::DICOMweb() {}
mitk::DICOMweb::DICOMweb(utility::string_t baseURI) : m_BaseURI(baseURI)
{
MITK_INFO << "base uri: " << mitk::RESTUtil::convertToUtf8(m_BaseURI);
InitializeRESTManager();
}
utility::string_t mitk::DICOMweb::CreateQIDOUri(mitk::RESTUtil::ParamMap map)
{
MitkUriBuilder queryBuilder(m_BaseURI + U("rs/instances"));
for (auto const &element : map)
{
queryBuilder.append_query(element.first, element.second);
}
return queryBuilder.to_string();
}
utility::string_t mitk::DICOMweb::CreateWADOUri(utility::string_t studyUID,
utility::string_t seriesUID,
utility::string_t instanceUID)
{
MitkUriBuilder builder(m_BaseURI + U("wado"));
builder.append_query(U("requestType"), U("WADO"));
builder.append_query(U("studyUID"), studyUID);
builder.append_query(U("seriesUID"), seriesUID);
builder.append_query(U("objectUID"), instanceUID);
builder.append_query(U("contentType"), U("application/dicom"));
return builder.to_string();
}
utility::string_t mitk::DICOMweb::CreateSTOWUri(utility::string_t studyUID)
{
MitkUriBuilder builder(m_BaseURI + U("rs/studies"));
builder.append_path(studyUID);
return builder.to_string();
}
pplx::task<void> mitk::DICOMweb::SendSTOW(utility::string_t filePath, utility::string_t studyUID)
{
auto uri = CreateSTOWUri(studyUID);
// this is the working stow-rs request which supports just one dicom file packed into a multipart message
std::ifstream input(filePath, std::ios::binary);
if (!input)
{
MITK_WARN << "could not read file to POST";
return pplx::task<void>();
}
std::vector<unsigned char> result;
std::vector<unsigned char> buffer;
// Stop eating new lines in binary mode!!!
input.unsetf(std::ios::skipws);
input.seekg(0, std::ios::end);
const std::streampos fileSize = input.tellg();
input.seekg(0, std::ios::beg);
MITK_INFO << fileSize << " bytes will be sent.";
buffer.reserve(fileSize); // file size
std::copy(
std::istream_iterator<unsigned char>(input), std::istream_iterator<unsigned char>(), std::back_inserter(buffer));
// in future more than one file should also be supported..
std::string head = "";
head += "\r\n--boundary";
head += "\r\nContent-Type: " + mitk::RESTUtil::convertToUtf8(U("application/dicom")) + "\r\n\r\n";
std::vector<unsigned char> bodyVector(head.begin(), head.end());
std::string tail = "";
tail += "\r\n--boundary--";
result.insert(result.end(), bodyVector.begin(), bodyVector.end());
result.insert(result.end(), buffer.begin(), buffer.end());
result.insert(result.end(), tail.begin(), tail.end());
mitk::RESTUtil::ParamMap headers;
headers.insert(mitk::RESTUtil::ParamMap::value_type(
U("Content-Type"), U("multipart/related; type=\"application/dicom\"; boundary=boundary")));
try
{
return m_RESTManager->SendRequest(uri, mitk::IRESTManager::RequestType::Post, &result, headers)
.then([=](web::json::value result) {
MITK_INFO << "after send";
- MITK_INFO << mitk::RESTUtil::convertToUtf8(result.to_string());
+ MITK_INFO << mitk::RESTUtil::convertToUtf8(result.serialize());
result.is_null();
});
}
catch (std::exception &e)
{
MITK_WARN << e.what();
}
return pplx::task<void>();
}
pplx::task<void> mitk::DICOMweb::SendWADO(utility::string_t filePath,
utility::string_t studyUID,
utility::string_t seriesUID,
utility::string_t instanceUID)
{
auto uri = CreateWADOUri(studyUID, seriesUID, instanceUID);
// don't want return something
auto content = web::json::value();
return m_RESTManager->SendRequest(uri, mitk::IRESTManager::RequestType::Get, &content, {}, filePath)
.then([=](web::json::value result) {
result.is_null();
});
}
pplx::task<std::string> mitk::DICOMweb::SendWADO(utility::string_t folderPath,
utility::string_t studyUID,
utility::string_t seriesUID)
{
mitk::RESTUtil::ParamMap seriesInstances;
seriesInstances.insert(mitk::RESTUtil::ParamMap::value_type(U("StudyInstanceUID"), studyUID));
seriesInstances.insert(mitk::RESTUtil::ParamMap::value_type(U("SeriesInstanceUID"), seriesUID));
return SendQIDO(seriesInstances).then([=](web::json::value jsonResult) -> pplx::task<std::string> {
auto jsonListResult = jsonResult;
auto resultArray = jsonListResult.as_array();
auto firstFileName = std::string();
std::vector<pplx::task<void>> tasks;
for (unsigned short i = 0; i < resultArray.size(); i++)
{
try
{
auto firstResult = resultArray[i];
auto sopInstanceUIDKey = firstResult.at(U("00080018"));
auto sopInstanceObject = sopInstanceUIDKey.as_object();
auto valueKey = sopInstanceObject.at(U("Value"));
auto valueArray = valueKey.as_array();
auto sopInstanceUID = valueArray[0].as_string();
auto fileName = utility::string_t(sopInstanceUID).append(U(".dcm"));
// save first file name as result to load series
if (i == 0)
{
firstFileName = utility::conversions::to_utf8string(fileName);
}
auto filePath = utility::string_t(folderPath).append(fileName);
auto task = SendWADO(filePath, studyUID, seriesUID, sopInstanceUID);
tasks.push_back(task);
}
catch (const web::json::json_exception &e)
{
MITK_ERROR << e.what();
}
}
auto joinTask = pplx::when_all(begin(tasks), end(tasks));
auto returnTask = joinTask.then([=](void) -> std::string {
auto folderPathUtf8 = utility::conversions::to_utf8string(folderPath);
auto result = folderPathUtf8 + firstFileName;
return result;
});
return returnTask;
});
}
pplx::task<web::json::value> mitk::DICOMweb::SendQIDO(mitk::RESTUtil::ParamMap map)
{
auto uri = CreateQIDOUri(map);
mitk::RESTUtil::ParamMap headers;
headers.insert(mitk::RESTUtil::ParamMap::value_type(U("Accept"), U("application/json")));
auto content = web::json::value();
return m_RESTManager->SendRequest(uri, mitk::IRESTManager::RequestType::Get, &content, headers);
}
void mitk::DICOMweb::InitializeRESTManager()
{
auto *context = us::GetModuleContext();
auto managerRef = context->GetServiceReference<mitk::IRESTManager>();
if (managerRef)
{
auto managerService = context->GetService(managerRef);
if (managerService)
{
m_RESTManager = managerService;
}
}
}