diff --git a/Modules/REST/include/mitkIRESTManager.h b/Modules/REST/include/mitkIRESTManager.h
index e09a2be31f..bd32487a68 100644
--- a/Modules/REST/include/mitkIRESTManager.h
+++ b/Modules/REST/include/mitkIRESTManager.h
@@ -1,100 +1,103 @@
/*===================================================================
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 mitkIRESTManager_h
#define mitkIRESTManager_h
#include <mitkServiceInterface.h>
#include <MitkRESTExports.h>
#include <cpprest/json.h>
#include <cpprest/uri.h>
+#include <cpprest/http_client.h>
namespace mitk
{
class IRESTObserver;
class RESTServer;
/**
* @class IRESTManager
* @brief This is a microservice interface for managing REST requests.
*/
class MITKREST_EXPORT IRESTManager
{
public:
virtual ~IRESTManager();
/**
* @brief request type for client requests by calling SendRequest
*/
enum class RequestType
{
Get,
Post,
Put
};
/**
* @brief Executes a HTTP request in the mitkRESTClient class
*
* @param uri defines the URI the request is send to
* @param type the RequestType of the HTTP request (optional)
* @param body the body for the request (optional)
* @return task to wait for
*/
virtual pplx::task<web::json::value> SendRequest(
const web::uri &uri,
const RequestType &type = RequestType::Get,
const web::json::value *body = nullptr,
const std::map<utility::string_t, utility::string_t> headers = {},
const utility::string_t &filePath = {}
) = 0;
/**
* @brief starts listening for requests if there isn't another observer listening and the port is free
*
* @param uri defines the URI for which incoming requests should be send to the observer
* @param observer the observer which handles the incoming requests
*/
virtual void ReceiveRequest(const web::uri &uri, IRESTObserver *observer) = 0;
/**
* @brief Handles incoming requests by notifying the observer which should receive it
*
* @param uri defines the URI of the request
* @param body the body of the request
- * @return the data which is modified by the notified observer
+ * @return the response
*/
- virtual web::json::value Handle(const web::uri &uri, const web::json::value &body) = 0;
+ virtual web::http::http_response Handle(const web::uri &uri,
+ const web::json::value &body,
+ const web::http::method &method) = 0;
/**
* @brief Handles the deletion of an observer for all or a specific uri
*
* @param observer the observer which shouldn't receive requests anymore
* @param uri the uri for which the observer doesn't handle requests anymore (optional)
*/
virtual void HandleDeleteObserver(IRESTObserver *observer, const web::uri &uri = {}) = 0;
virtual const std::map<int, RESTServer *>& GetServerMap() = 0;
virtual const std::map<std::pair<int, utility::string_t>, IRESTObserver *>& GetObservers() = 0;
};
}
MITK_DECLARE_SERVICE_INTERFACE(mitk::IRESTManager, "org.mitk.IRESTManager")
#endif
diff --git a/Modules/REST/include/mitkIRESTObserver.h b/Modules/REST/include/mitkIRESTObserver.h
index 9f78bbdf2b..c5763a89d4 100644
--- a/Modules/REST/include/mitkIRESTObserver.h
+++ b/Modules/REST/include/mitkIRESTObserver.h
@@ -1,50 +1,53 @@
/*===================================================================
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 mitkIRESTObserver_h
#define mitkIRESTObserver_h
#include <MitkRESTExports.h>
#include <cpprest/json.h>
#include <cpprest/uri.h>
+#include <cpprest/http_client.h>
namespace mitk
{
class MITKREST_EXPORT IRESTObserver
{
public:
/**
* @brief Deletes an observer and calls HandleDeleteObserver() in RESTManager class
*
* @see HandleDeleteObserver()
*/
virtual ~IRESTObserver();
/**
* @brief Called if there's an incoming request for the observer, observer implements how to handle request
*
* @param data the data of the incoming request
* @return the modified data
*/
- virtual web::json::value Notify(const web::uri &uri, const web::json::value &data) = 0;
+ virtual web::http::http_response Notify(const web::uri &uri,
+ const web::json::value &data,
+ const web::http::method &method) = 0;
private:
};
}
#endif
diff --git a/Modules/REST/src/mitkRESTClient.cpp b/Modules/REST/src/mitkRESTClient.cpp
index e2327e42ca..ee3afbba22 100644
--- a/Modules/REST/src/mitkRESTClient.cpp
+++ b/Modules/REST/src/mitkRESTClient.cpp
@@ -1,175 +1,183 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkRESTClient.h>
#include <mitkRESTUtil.h>
#include <mitkExceptionMacro.h>
#include <cpprest/http_client.h>
#include <cpprest/filestream.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)
{
+ MITK_INFO << "within client no file path with uri: " << mitk::RESTUtil::convertToUtf8(uri.to_string());
auto client = new http_client(uri);
+ MITK_INFO << "after creating a client";
http_request request;
+ //request.set_request_uri(uri);
for (auto param : headers)
{
request.headers().add(param.first, param.second);
}
+ MITK_INFO << mitk::RESTUtil::convertToUtf8(request.absolute_uri().to_string());
+
return client->request(request).then([=](pplx::task<web::http::http_response> responseTask) {
try
{
auto response = responseTask.get();
auto status = response.status_code();
+ MITK_INFO << status;
+
if (status_codes::OK != status)
mitkThrow();
auto requestContentType = response.headers().content_type();
if (_XPLATSTR("application/json") != requestContentType)
response.headers().set_content_type(_XPLATSTR("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)
{
+ MITK_INFO << "within client with file path";
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 (_XPLATSTR("application/json") != requestContentType)
response.headers().set_content_type(_XPLATSTR("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 web::json::value *content)
{
auto client = new http_client(uri);
http_request request(methods::POST);
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::Created != 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 (_XPLATSTR("application/json") != requestContentType)
response.headers().set_content_type(_XPLATSTR("application/json"));
return response.extract_json().get();
}
catch(...)
{
mitkThrow() << "Getting response went wrong";
}
});
}
diff --git a/Modules/REST/src/mitkRESTServer.cpp b/Modules/REST/src/mitkRESTServer.cpp
index 338c823e48..37ed838d2d 100644
--- a/Modules/REST/src/mitkRESTServer.cpp
+++ b/Modules/REST/src/mitkRESTServer.cpp
@@ -1,112 +1,110 @@
/*===================================================================
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 <mitkRESTServer.h>
#include <mitkIRESTManager.h>
#include <usGetModuleContext.h>
#include <usModuleContext.h>
#include <cpprest/http_listener.h>
-#include <mitkCommon.h>
-#include <mitkRESTUtil.h>
using namespace std::placeholders;
using http_listener = web::http::experimental::listener::http_listener;
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;
namespace mitk
{
class RESTServer::Impl
{
public:
Impl(const web::uri &uri);
~Impl();
- void HandleGet(const http_request &request);
+ void HandleRequest(const http_request &request);
web::http::experimental::listener::http_listener listener;
web::uri uri;
};
RESTServer::Impl::Impl(const web::uri &uri)
: uri{uri}
{
}
RESTServer::Impl::~Impl()
{
}
- void RESTServer::Impl::HandleGet(const http_request &request)
+ void RESTServer::Impl::HandleRequest(const http_request &request)
{
- MITK_INFO << "Incoming Request \n" << mitk::RESTUtil::convertToUtf8(request.to_string());
web::uri_builder builder(this->listener.uri());
builder.append(request.absolute_uri());
auto uriString = builder.to_uri().to_string();
- web::json::value content;
+ http_response response(status_codes::InternalError);
+ response.set_body(L"There went something wrong after receiving the request.");
auto context = us::GetModuleContext();
auto managerRef = context->GetServiceReference<IRESTManager>();
if (managerRef)
{
auto manager = context->GetService(managerRef);
if (manager)
{
auto data = request.extract_json().get();
- content = manager->Handle(builder.to_uri(), data);
+ response = manager->Handle(builder.to_uri(), data, request.method());
}
}
- request.reply(content.is_null()
- ? status_codes::NotFound
- : status_codes::OK);
+ request.reply(response);
}
}
mitk::RESTServer::RESTServer(const web::uri &uri)
: m_Impl{std::make_unique<Impl>(uri)}
{
}
mitk::RESTServer::~RESTServer()
{
}
void mitk::RESTServer::OpenListener()
{
m_Impl->listener = http_listener(m_Impl->uri);
- m_Impl->listener.support(methods::GET, std::bind(&Impl::HandleGet, m_Impl.get(), _1));
+ m_Impl->listener.support(std::bind(&Impl::HandleRequest, m_Impl.get(), _1));
+ m_Impl->listener.support(methods::OPTIONS, std::bind(&Impl::HandleRequest, m_Impl.get(), _1));
m_Impl->listener.open().wait();
}
void mitk::RESTServer::CloseListener()
{
m_Impl->listener.close().wait();
}
web::uri mitk::RESTServer::GetUri()
{
return m_Impl->uri;
}
diff --git a/Modules/REST/test/mitkRESTClientTest.cpp b/Modules/REST/test/mitkRESTClientTest.cpp
index 9c4f7c0123..305706bc46 100644
--- a/Modules/REST/test/mitkRESTClientTest.cpp
+++ b/Modules/REST/test/mitkRESTClientTest.cpp
@@ -1,247 +1,247 @@
/*===================================================================
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 <mitkTestFixture.h>
#include <mitkTestingMacros.h>
#include <mitkIRESTManager.h>
#include <mitkIRESTObserver.h>
#include <mitkRESTClient.h>
#include <usGetModuleContext.h>
#include <usModuleContext.h>
#include <usServiceReference.h>
#include <vtkDebugLeaks.h>
class mitkRESTClientTestSuite : public mitk::TestFixture, mitk::IRESTObserver
{
CPPUNIT_TEST_SUITE(mitkRESTClientTestSuite);
// MITK_TEST(GetRequestValidURI_ReturnsExpectedJSON); GET requests do not support content yet?
MITK_TEST(MultipleGetRequestValidURI_AllTasksFinish);
// MITK_TEST(PutRequestValidURI_ReturnsExpectedJSON); Does not work reliably on dart clients
// MITK_TEST(PostRequestValidURI_ReturnsExpectedJSON); -- " --
MITK_TEST(GetRequestInvalidURI_ThrowsException);
MITK_TEST(PutRequestInvalidURI_ThrowsException);
MITK_TEST(PostRequestInvalidURI_ThrowsException);
CPPUNIT_TEST_SUITE_END();
public:
mitk::IRESTManager *m_Service;
web::json::value m_Data;
- web::json::value Notify(const web::uri &, const web::json::value &) override
+ web::json::value Notify(const web::uri &, const web::json::value &, const web::http::method &) override
{
return m_Data;
}
/**
* @brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used
* members for a new test case. (If the members are not used in a test, the method does not need to be called).
*/
void setUp() override
{
m_Data = web::json::value();
m_Data[_XPLATSTR("userId")] = web::json::value(1);
m_Data[_XPLATSTR("id")] = web::json::value(1);
m_Data[_XPLATSTR("title")] = web::json::value(U("this is a title"));
m_Data[_XPLATSTR("body")] = web::json::value(U("this is a body"));
us::ServiceReference<mitk::IRESTManager> serviceRef =
us::GetModuleContext()->GetServiceReference<mitk::IRESTManager>();
if (serviceRef)
{
m_Service = us::GetModuleContext()->GetService(serviceRef);
}
if (!m_Service)
{
CPPUNIT_FAIL("Getting Service in setUp() failed");
}
m_Service->ReceiveRequest(_XPLATSTR("http://localhost:8080/clienttest"), this);
}
void tearDown() override
{
m_Service->HandleDeleteObserver(this);
}
void GetRequestValidURI_ReturnsExpectedJSON()
{
web::json::value result;
m_Service->SendRequest(_XPLATSTR("http://localhost:8080/clienttest"))
.then([&](pplx::task<web::json::value> resultTask) {
try
{
result = resultTask.get();
}
catch (const mitk::Exception &exception)
{
MITK_ERROR << exception.what();
return;
}
})
.wait();
CPPUNIT_ASSERT_MESSAGE("Result is the expected JSON value", result == m_Data);
}
void MultipleGetRequestValidURI_AllTasksFinish()
{
int count = 0;
// Create multiple tasks e.g. as shown below
std::vector<pplx::task<void>> tasks;
for (int i = 0; i < 20; ++i)
{
pplx::task<void> singleTask =
m_Service->SendRequest(_XPLATSTR("http://localhost:8080/clienttest"))
.then([&](pplx::task<web::json::value> resultTask) {
// Do something when a single task is done
try
{
resultTask.get();
count +=1;
}
catch (const mitk::Exception &exception)
{
MITK_ERROR << exception.what();
return;
}
});
tasks.emplace_back(singleTask);
}
// Create a joinTask which includes all tasks you've created
auto joinTask = pplx::when_all(begin(tasks), end(tasks));
// Run asynchonously
joinTask.then([&](pplx::task<void> resultTask) {
// Do something when all tasks are finished
try
{
resultTask.get();
count += 1;
}
catch (const mitk::Exception &exception)
{
MITK_ERROR << exception.what();
return;
}
}).wait();
CPPUNIT_ASSERT_MESSAGE("Multiple Requests", 21 == count);
}
void PutRequestValidURI_ReturnsExpectedJSON()
{
// optional: link might get invalid or content is changed
web::json::value result;
m_Service
->SendRequest(_XPLATSTR("https://jsonplaceholder.typicode.com/posts/1"), mitk::IRESTManager::RequestType::Put, &m_Data)
.then([&](pplx::task<web::json::value> resultTask) {
try
{
result = resultTask.get();
}
catch (const mitk::Exception &exception)
{
MITK_ERROR << exception.what();
return;
}
})
.wait();
CPPUNIT_ASSERT_MESSAGE(
"Result is the expected JSON value, check if the link is still valid since this is an optional test",
result == m_Data);
}
void PostRequestValidURI_ReturnsExpectedJSON()
{
// optional: link might get invalid or content is changed
web::json::value result;
web::json::value data;
data[_XPLATSTR("userId")] = m_Data[_XPLATSTR("userId")];
data[_XPLATSTR("title")] = m_Data[_XPLATSTR("title")];
data[_XPLATSTR("body")] = m_Data[_XPLATSTR("body")];
m_Service->SendRequest(_XPLATSTR("https://jsonplaceholder.typicode.com/posts"), mitk::IRESTManager::RequestType::Post, &data)
.then([&](pplx::task<web::json::value> resultTask) {
try
{
result = resultTask.get();
}
catch (const mitk::Exception &exception)
{
MITK_ERROR << exception.what();
return;
}
})
.wait();
data[_XPLATSTR("id")] = web::json::value(101);
CPPUNIT_ASSERT_MESSAGE(
"Result is the expected JSON value, check if the link is still valid since this is an optional test",
result == data);
}
void GetException()
{
//Method which makes a get request to an invalid uri
web::json::value result;
m_Service->SendRequest(_XPLATSTR("http://localhost:1234/invalid"))
.then([&](pplx::task<web::json::value> resultTask) { result = resultTask.get(); })
.wait();
}
void GetRequestInvalidURI_ThrowsException() { CPPUNIT_ASSERT_THROW(GetException(), mitk::Exception); }
void PutException()
{
//Method which makes a put request to an invalid uri
web::json::value result;
m_Service->SendRequest(_XPLATSTR("http://localhost:1234/invalid"), mitk::IRESTManager::RequestType::Put, &m_Data)
.then([&](pplx::task<web::json::value> resultTask) {
result = resultTask.get();})
.wait();
}
void PutRequestInvalidURI_ThrowsException()
{
CPPUNIT_ASSERT_THROW(PutException(), mitk::Exception);
}
void PostException()
{
//Method which makes a post request to an invalid uri
web::json::value result;
m_Service->SendRequest(_XPLATSTR("http://localhost:1234/invalid"), mitk::IRESTManager::RequestType::Post, &m_Data)
.then([&](pplx::task<web::json::value> resultTask) {
result = resultTask.get();
})
.wait();
}
void PostRequestInvalidURI_ThrowsException()
{
CPPUNIT_ASSERT_THROW(PostException(), mitk::Exception);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkRESTClient)
diff --git a/Modules/REST/test/mitkRESTServerTest.cpp b/Modules/REST/test/mitkRESTServerTest.cpp
index a386dba712..be69606cf6 100644
--- a/Modules/REST/test/mitkRESTServerTest.cpp
+++ b/Modules/REST/test/mitkRESTServerTest.cpp
@@ -1,227 +1,227 @@
/*===================================================================
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.
===================================================================*/
#ifdef _WIN32
#include <Windows.h>
#endif
#include <mitkTestFixture.h>
#include <mitkTestingMacros.h>
#include <mitkIRESTManager.h>
#include <mitkIRESTObserver.h>
#include <mitkRESTServer.h>
#include <usGetModuleContext.h>
#include <usModuleContext.h>
#include <usServiceReference.h>
#include <vtkDebugLeaks.h>
class mitkRESTServerTestSuite : public mitk::TestFixture, mitk::IRESTObserver
{
CPPUNIT_TEST_SUITE(mitkRESTServerTestSuite);
MITK_TEST(OpenListener_Succeed);
MITK_TEST(TwoListenerSameHostSamePort_OnlyOneOpened);
MITK_TEST(CloseListener_Succeed);
MITK_TEST(OpenMultipleListenerCloseOne_Succeed);
MITK_TEST(OpenMultipleListenerCloseAll_Succeed);
// MITK_TEST(OpenListenerGetRequestSamePath_ReturnExpectedJSON); GET requests do not support content yet?
MITK_TEST(CloseListener_NoRequestPossible);
MITK_TEST(OpenListenerGetRequestDifferentPath_ReturnNotFound);
MITK_TEST(OpenListenerCloseAndReopen_Succeed);
CPPUNIT_TEST_SUITE_END();
public:
mitk::IRESTManager *m_Service;
web::json::value m_Data;
- web::json::value Notify(const web::uri &, const web::json::value &) override
+ web::json::value Notify(const web::uri &, const web::json::value &, const web::http::method &) override
{
return m_Data;
}
/**
* @brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used
* members for a new test case. (If the members are not used in a test, the method does not need to be called).
*/
void setUp() override
{
m_Data = web::json::value();
m_Data[_XPLATSTR("userId")] = web::json::value(1);
m_Data[_XPLATSTR("id")] = web::json::value(1);
m_Data[_XPLATSTR("title")] = web::json::value(U("this is a title"));
m_Data[_XPLATSTR("body")] = web::json::value(U("this is a body"));
auto serviceRef = us::GetModuleContext()->GetServiceReference<mitk::IRESTManager>();
if (serviceRef)
m_Service = us::GetModuleContext()->GetService(serviceRef);
if (!m_Service)
CPPUNIT_FAIL("Getting Service in setUp() failed");
}
void tearDown() override
{
m_Service->HandleDeleteObserver(this);
}
void OpenListener_Succeed()
{
m_Service->ReceiveRequest(_XPLATSTR("http://localhost:8080/servertest"), this);
CPPUNIT_ASSERT_MESSAGE("Open one listener, observer map size is one", 1 == m_Service->GetObservers().size());
CPPUNIT_ASSERT_MESSAGE("Open one listener, server map size is one", 1 == m_Service->GetServerMap().size());
}
void TwoListenerSameHostSamePort_OnlyOneOpened()
{
m_Service->ReceiveRequest(_XPLATSTR("http://localhost:8080/servertest"), this);
m_Service->ReceiveRequest(_XPLATSTR("http://localhost:8080/serverexample"), this);
CPPUNIT_ASSERT_MESSAGE("Open two listener with a different path,same host, same port, observer map size is two",
2 == m_Service->GetObservers().size());
CPPUNIT_ASSERT_MESSAGE("Open two listener with a different path,same host, same port, server map size is one",
1 == m_Service->GetServerMap().size());
}
void CloseListener_Succeed()
{
m_Service->ReceiveRequest(_XPLATSTR("http://localhost:8080/servertest"), this);
CPPUNIT_ASSERT_MESSAGE("Open one listener, observer map size is one", 1 == m_Service->GetObservers().size());
CPPUNIT_ASSERT_MESSAGE("Open one listener, server map size is one", 1 == m_Service->GetServerMap().size());
m_Service->HandleDeleteObserver(this);
CPPUNIT_ASSERT_MESSAGE("Closed listener, observer map is empty", 0 == m_Service->GetObservers().size());
CPPUNIT_ASSERT_MESSAGE("Closed listener, server map is empty", 0 == m_Service->GetServerMap().size());
}
void OpenMultipleListenerCloseOne_Succeed()
{
m_Service->ReceiveRequest(_XPLATSTR("http://localhost:8080/servertest"), this);
m_Service->ReceiveRequest(_XPLATSTR("http://localhost:8090/serverexample"), this);
CPPUNIT_ASSERT_MESSAGE("Open two listener, observer map size is two", 2 == m_Service->GetObservers().size());
CPPUNIT_ASSERT_MESSAGE("Open two listener, server map size is two", 2 == m_Service->GetServerMap().size());
m_Service->HandleDeleteObserver(this, _XPLATSTR("http://localhost:8080/servertest"));
CPPUNIT_ASSERT_MESSAGE("Closed one of two listeners, observer map is size is one",
1 == m_Service->GetObservers().size());
CPPUNIT_ASSERT_MESSAGE("Closed one of two listener, server map size is one",
1 == m_Service->GetServerMap().size());
}
void OpenMultipleListenerCloseAll_Succeed()
{
m_Service->ReceiveRequest(_XPLATSTR("http://localhost:8080/servertest"), this);
m_Service->ReceiveRequest(_XPLATSTR("http://localhost:8090/serverexample"), this);
CPPUNIT_ASSERT_MESSAGE("Open two listener, observer map size is two", 2 == m_Service->GetObservers().size());
CPPUNIT_ASSERT_MESSAGE("Open two listener, server map size is two", 2 == m_Service->GetServerMap().size());
m_Service->HandleDeleteObserver(this);
CPPUNIT_ASSERT_MESSAGE("Closed all listeners, observer map is empty", 0 == m_Service->GetObservers().size());
CPPUNIT_ASSERT_MESSAGE("Closed all listeners, server map is empty", 0 == m_Service->GetServerMap().size());
}
void OpenListenerGetRequestSamePath_ReturnExpectedJSON()
{
m_Service->ReceiveRequest(_XPLATSTR("http://localhost:8080/servertest"), this);
web::json::value result;
m_Service->SendRequest(_XPLATSTR("http://localhost:8080/servertest"))
.then([&](pplx::task<web::json::value> resultTask) {
try
{
result = resultTask.get();
}
catch (const mitk::Exception &exception)
{
MITK_ERROR << exception.what();
return;
}
})
.wait();
CPPUNIT_ASSERT_MESSAGE("Opened listener and send request to same uri, returned expected JSON", result == m_Data);
}
void RequestToClosedListener()
{
web::json::value result;
m_Service->SendRequest(_XPLATSTR("http://localhost:8080/servertest"))
.then([&](pplx::task<web::json::value> resultTask) { result = resultTask.get(); })
.wait();
}
void CloseListener_NoRequestPossible()
{
m_Service->ReceiveRequest(_XPLATSTR("http://localhost:8080/servertest"), this);
CPPUNIT_ASSERT_MESSAGE("Open one listener, observer map size is one", 1 == m_Service->GetObservers().size());
CPPUNIT_ASSERT_MESSAGE("Open one listener, server map size is one", 1 == m_Service->GetServerMap().size());
m_Service->HandleDeleteObserver(this);
CPPUNIT_ASSERT_MESSAGE("Closed listener, observer map is empty", 0 == m_Service->GetObservers().size());
CPPUNIT_ASSERT_MESSAGE("Closed listener, server map is empty", 0 == m_Service->GetServerMap().size());
CPPUNIT_ASSERT_THROW(RequestToClosedListener(), mitk::Exception);
}
void RequestToDifferentPathNotFound()
{
m_Service->ReceiveRequest(_XPLATSTR("http://localhost:8080/servertest"), this);
web::json::value result;
m_Service->SendRequest(_XPLATSTR("http://localhost:8080/serverexample"))
.then([&](pplx::task<web::json::value> resultTask) { result = resultTask.get(); })
.wait();
}
void OpenListenerGetRequestDifferentPath_ReturnNotFound()
{
CPPUNIT_ASSERT_THROW(RequestToDifferentPathNotFound(), mitk::Exception);
}
void OpenListenerCloseAndReopen_Succeed()
{
m_Service->ReceiveRequest(_XPLATSTR("http://localhost:8080/servertest"), this);
CPPUNIT_ASSERT_MESSAGE("Open one listener, observer map size is one", 1 == m_Service->GetObservers().size());
CPPUNIT_ASSERT_MESSAGE("Open one listener, server map size is one", 1 == m_Service->GetServerMap().size());
m_Service->HandleDeleteObserver(this);
CPPUNIT_ASSERT_MESSAGE("Closed listener, observer map is empty", 0 == m_Service->GetObservers().size());
CPPUNIT_ASSERT_MESSAGE("Closed listener, server map is empty", 0 == m_Service->GetServerMap().size());
m_Service->ReceiveRequest(_XPLATSTR("http://localhost:8080/servertest"), this);
CPPUNIT_ASSERT_MESSAGE("Reopened listener, observer map size is one", 1 == m_Service->GetObservers().size());
CPPUNIT_ASSERT_MESSAGE("Reopened listener, server map size is one", 1 == m_Service->GetServerMap().size());
}
};
MITK_TEST_SUITE_REGISTRATION(mitkRESTServer)
diff --git a/Modules/RESTService/include/mitkRESTManager.h b/Modules/RESTService/include/mitkRESTManager.h
index 53d07332b6..7c2760aea2 100644
--- a/Modules/RESTService/include/mitkRESTManager.h
+++ b/Modules/RESTService/include/mitkRESTManager.h
@@ -1,119 +1,122 @@
/*===================================================================
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 mitkRESTManager_h
#define mitkRESTManager_h
#include <MitkRESTServiceExports.h>
#include <mitkIRESTManager.h>
namespace mitk
{
/**
* @class RESTManager
* @brief this is a microservice for managing REST-requests, used for non-qt applications.
*
* RESTManagerQt in the CppRestSdkQt module inherits from this class and is the equivalent microservice
* used for Qt applications.
*/
class MITKRESTSERVICE_EXPORT RESTManager : public IRESTManager
{
public:
RESTManager();
~RESTManager() override;
/**
* @brief Executes a HTTP request in the mitkRESTClient class
*
* @throw mitk::Exception if RequestType is not suported
* @param uri defines the URI the request is send to
* @param type the RequestType of the HTTP request (optional)
* @param body the body for the request (optional)
* @param filePath the file path to store the request to
* @return task to wait for
*/
pplx::task<web::json::value> SendRequest(const web::uri &uri,
const RequestType &type = RequestType::Get,
const web::json::value *body = nullptr,
const std::map<utility::string_t, utility::string_t> headers = {},
const utility::string_t &filePath = {}) override;
/**
* @brief starts listening for requests if there isn't another observer listening and the port is free
*
* @param uri defines the URI for which incoming requests should be send to the observer
* @param observer the observer which handles the incoming requests
*/
void ReceiveRequest(const web::uri &uri, IRESTObserver *observer) override;
/**
* @brief Handles incoming requests by notifying the observer which should receive it
*
* @param uri defines the URI of the request
* @param body the body of the request
- * @return the data which is modified by the notified observer
+ * @return the response
*/
- web::json::value Handle(const web::uri &uri, const web::json::value &body) override;
+
+ web::http::http_response Handle(const web::uri &uri,
+ const web::json::value &body,
+ const web::http::method &method) override;
/**
* @brief Handles the deletion of an observer for all or a specific uri
*
* @param observer the observer which shouldn't receive requests anymore
* @param uri the uri for which the observer doesn't handle requests anymore (optional)
*/
void HandleDeleteObserver(IRESTObserver *observer, const web::uri &uri = {}) override;
/**
* @brief internal use only
*/
const std::map<int, RESTServer *> &GetServerMap() override;
std::map<std::pair<int, utility::string_t>, IRESTObserver *> &GetObservers() override;
private:
/**
* @brief adds an observer if a port is free, called by ReceiveRequest method
*
* @param uri the uri which builds the key for the observer map
* @param observer the observer which is added
*/
void AddObserver(const web::uri &uri, IRESTObserver *observer);
/**
* @brief handles server management if there is already a server under a port, called by ReceiveRequest method
*
* @param uri the uri which which is requested to be added
* @param observer the observer which proceeds the request
*/
void RequestForATakenPort(const web::uri &uri, IRESTObserver *observer);
/**
* @brief deletes an observer, called by HandleDeleteObserver method
*
* @param it the iterator comparing the observers in HandleDeleteObserver method
* @return bool if there is another observer under the port
*/
bool DeleteObserver(std::map<std::pair<int, utility::string_t>, IRESTObserver *>::iterator &it);
void SetServerMap(const int port, RESTServer *server);
void DeleteFromServerMap(const int port);
void SetObservers(const std::pair<int, utility::string_t> key, IRESTObserver *observer);
std::map<int, RESTServer *> m_ServerMap; // Map with port server pairs
std::map<std::pair<int, utility::string_t>, IRESTObserver *> m_Observers; // Map with all observers
};
} // namespace mitk
#endif
diff --git a/Modules/RESTService/src/mitkRESTManager.cpp b/Modules/RESTService/src/mitkRESTManager.cpp
index 092b5883a5..e63bf16b06 100644
--- a/Modules/RESTService/src/mitkRESTManager.cpp
+++ b/Modules/RESTService/src/mitkRESTManager.cpp
@@ -1,218 +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::json::value mitk::RESTManager::Handle(const web::uri &uri, const web::json::value &body)
+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);
+ 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";
- return web::json::value();
+ 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/files.cmake b/Plugins/org.mitk.gui.qt.segmentation.rework/files.cmake
index 3b25cdb248..cd9d2c5a59 100644
--- a/Plugins/org.mitk.gui.qt.segmentation.rework/files.cmake
+++ b/Plugins/org.mitk.gui.qt.segmentation.rework/files.cmake
@@ -1,46 +1,47 @@
set(SRC_CPP_FILES
)
set(INTERNAL_CPP_FILES
org_mitk_gui_qt_segmentation_rework_Activator.cpp
SegmentationReworkView.cpp
ReworkRequestHandler.cpp
+ DICOMweb.cpp
)
set(UI_FILES
src/internal/SegmentationReworkViewControls.ui
)
set(MOC_H_FILES
src/internal/org_mitk_gui_qt_segmentation_rework_Activator.h
src/internal/SegmentationReworkView.h
src/internal/ReworkRequestHandler.h
src/internal/DICOMweb.h
)
# list of resource files which can be used by the plug-in
# system without loading the plug-ins shared library,
# for example the icon used in the menu and tabs for the
# plug-in views in the workbench
set(CACHED_RESOURCE_FILES
resources/icon.xpm
resources/plugin_icon.png
plugin.xml
)
# list of Qt .qrc files which contain additional resources
# specific to this plugin
set(QRC_FILES
)
set(CPP_FILES )
foreach(file ${SRC_CPP_FILES})
set(CPP_FILES ${CPP_FILES} src/${file})
endforeach(file ${SRC_CPP_FILES})
foreach(file ${INTERNAL_CPP_FILES})
set(CPP_FILES ${CPP_FILES} src/internal/${file})
endforeach(file ${INTERNAL_CPP_FILES})
diff --git a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/DICOMweb.h b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/DICOMweb.h
index 8115ed396b..29bdbf882e 100644
--- a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/DICOMweb.h
+++ b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/DICOMweb.h
@@ -1,220 +1,80 @@
/*===================================================================
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 DICOMweb_h
#define DICOMweb_h
#include "cpprest/asyncrt_utils.h"
#include "cpprest/http_client.h"
#include <iostream>
#include <mitkCommon.h>
#include <mitkRESTManager.h>
#include <mitkRESTUtil.h>
#include <usGetModuleContext.h>
#include <usModuleContext.h>
class DICOMweb
{
public:
typedef web::http::uri_builder MitkUriBuilder;
typedef web::http::http_request MitkRequest;
typedef web::http::http_response MitkResponse;
typedef web::http::methods MitkRESTMethods;
+ DICOMweb();
+ DICOMweb(utility::string_t baseURI);
+
/**
* @brief Creates a QIDO request URI with the given parameter map
*/
- static utility::string_t CreateQIDOUri(mitk::RESTUtil::ParamMap map)
- {
- MitkUriBuilder queryBuilder(U("rs/instances"));
-
- for (auto const &element : map)
- {
- queryBuilder.append_query(element.first, element.second);
- }
-
- return queryBuilder.to_string();
- }
+ utility::string_t CreateQIDOUri(mitk::RESTUtil::ParamMap map);
/**
* @brief Creates a WADO request URI with the given parameter
*/
- static utility::string_t CreateWADOUri(utility::string_t studyUID,
- utility::string_t seriesUID,
- utility::string_t instanceUID)
- {
- MitkUriBuilder builder(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 CreateWADOUri(utility::string_t studyUID,
+ utility::string_t seriesUID,
+ utility::string_t instanceUID);
/**
* @brief Creates a STOW request URI with the given parameter map
*/
- static utility::string_t CreateSTOWUri(utility::string_t studyUID)
- {
- MitkUriBuilder builder(U("rs/studies"));
- builder.append_path(studyUID);
- return builder.to_string();
- }
-
- static pplx::task<void> SendSTOW(utility::string_t filePath, utility::string_t studyUID)
- {
- auto uri = CreateSTOWUri(studyUID);
- auto manager = RESTManager();
-
- // TODO: complete STOW
- return manager->SendRequest(uri, mitk::IRESTManager::RequestType::Post, {}, {}, filePath)
- .then([=](web::json::value result){});
- }
-
- static pplx::task<void> SendWADO(utility::string_t filePath,
+ utility::string_t CreateSTOWUri(utility::string_t studyUID);
+
+ pplx::task<void> SendSTOW(utility::string_t filePath, utility::string_t studyUID);
+
+ pplx::task<void> SendWADO(utility::string_t filePath,
+ utility::string_t studyUID,
+ utility::string_t seriesUID,
+ utility::string_t instanceUID,
+ mitk::IRESTManager *manager);
+
+ pplx::task<std::string> SendWADO(utility::string_t folderPath,
utility::string_t studyUID,
- utility::string_t seriesUID,
- utility::string_t instanceUID,
- mitk::IRESTManager *manager)
- {
- auto uri = CreateWADOUri(studyUID, seriesUID, instanceUID);
-
- // don't want return something
- return manager->SendRequest(uri, mitk::IRESTManager::RequestType::Get, {}, {}, filePath)
- .then([=](web::json::value result){});
- }
-
- static pplx::task<std::string> 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));
-
- auto *manager = RESTManager();
-
- 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, manager);
- 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;
- });
- }
-
- static pplx::task<web::json::value> SendQIDO(mitk::RESTUtil::ParamMap map)
- {
- auto uri = CreateQIDOUri(map);
-
- auto *manager = RESTManager();
-
- mitk::RESTUtil::ParamMap headers;
- headers.insert(mitk::RESTUtil::ParamMap::value_type(U("Accept"), U("application/json")));
-
- return manager->SendRequest(uri, mitk::IRESTManager::RequestType::Get, {}, headers);
- // return manager->SendRequest(queryBuilder.to_string()).then([=](pplx::task<MitkResponse> taskResponse) {
- // try
- // {
- // MitkResponse response = taskResponse.get();
- // auto status = response.status_code();
- // MITK_INFO << " status: " << status;
-
- // if (status != web::http::status_codes::OK)
- // {
- // MITK_ERROR << "no dicom series found for query "
- // << utility::conversions::to_utf8string(queryBuilder.to_string());
- // mitkThrow() << "no dicom series found for query "
- // << utility::conversions::to_utf8string(queryBuilder.to_string());
- // }
-
- // if (response.headers()[U("Content-Type")] == U("application/dicom+json"))
- // {
- // response.headers().remove(U("Content-Type"));
- // response.headers().add(U("Content-Type"), U("application/json"));
- // }
-
- // return response.extract_json().get();
- // }
- // catch (std::exception &e)
- // {
- // mitkThrow() << e.what();
- // }
- //});
- }
+ utility::string_t seriesUID);
+
+
+ pplx::task<web::json::value> SendQIDO(mitk::RESTUtil::ParamMap map);
+
private:
- static mitk::IRESTManager *RESTManager()
- {
- auto *context = us::GetModuleContext();
- auto managerRef = context->GetServiceReference<mitk::IRESTManager>();
- if (managerRef)
- {
- auto managerService = context->GetService(managerRef);
- if (managerService)
- {
- return managerService;
- }
- }
- return nullptr;
- }
+ mitk::IRESTManager *RESTManager();
+ utility::string_t m_BaseURI;
+
};
#endif // DICOMweb_h
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 1c0a81ec26..5a5e1204c8 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,184 +1,243 @@
/*===================================================================
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 <mitkCommon.h>
-#include <mitkRESTUtil.h>
#include <usGetModuleContext.h>
#include <usModuleContext.h>
#include <usModuleInitialization.h>
US_INITIALIZE_MODULE
-ReworkRequestHandler::ReworkRequestHandler() {}
+ReworkRequestHandler::ReworkRequestHandler()
+{
+ m_DicomWeb = DICOMweb(L"http://193.174.48.78:8090/dcm4chee-arc/aets/DCM4CHEE/");
+}
-ReworkRequestHandler::ReworkRequestHandler(std::string downloadDir) : m_DownloadDir{downloadDir}
+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::json::value ReworkRequestHandler::Notify(const web::uri &uri, const web::json::value &data)
+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";
- return web::json::value();
-
+ 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 = DICOMweb::CreateQIDOUri(seriesInstancesParams);
-
+ 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 =
- DICOMweb::SendWADO(utility::conversions::to_string_t(folderPathSeries), dto.studyUID, imageSeriesUID);
- auto segATask = DICOMweb::SendWADO(folderPathSegA, dto.studyUID, segSeriesUIDA);
- auto segBTask = DICOMweb::SendWADO(folderPathSegB, dto.studyUID, segSeriesUIDB);
+ 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();
}
- return web::json::value();
-}
\ No newline at end of file
+ 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/ReworkRequestHandler.h b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/ReworkRequestHandler.h
index 86590381ee..86291dd63c 100644
--- a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/ReworkRequestHandler.h
+++ b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/ReworkRequestHandler.h
@@ -1,62 +1,68 @@
/*===================================================================
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 ReworkRequestHandler_h
#define ReworkRequestHandler_h
+#include "DICOMweb.h"
#include <QObject>
#include <mitkIRESTManager.h>
#include <mitkIRESTObserver.h>
class ReworkRequestHandler : public QObject, public mitk::IRESTObserver
{
Q_OBJECT
public:
struct DicomDTO
{
utility::string_t segSeriesUIDA;
utility::string_t segSeriesUIDB;
utility::string_t imageSeriesUID;
utility::string_t studyUID;
utility::string_t segInstanceUIDA;
utility::string_t segInstanceUIDB;
utility::string_t srSeriesUID;
std::vector<std::string> seriesUIDList;
std::vector<double> simScoreArray;
int minSliceStart;
utility::string_t groundTruth;
};
ReworkRequestHandler();
ReworkRequestHandler(std::string downloadDir);
~ReworkRequestHandler();
- web::json::value Notify(const web::uri &uri, const web::json::value &data);
+ web::http::http_response Notify(const web::uri &uri, const web::json::value &data, const web::http::method &method);
signals:
void InvokeProgress(int, QString status);
void InvokeSimilarityGraph(std::vector<double> score, int sliceStart);
void InvokeUpdateDcmMeta(DicomDTO dto);
void InvokeLoadData(std::vector<std::string>);
private:
DicomDTO ExtractDTO(const web::json::value &data);
+ web::http::http_response HandlePut(const web::uri &uri, const web::json::value &data);
+ web::http::http_response HandlePost(const web::uri &uri, const web::json::value &data);
+ web::http::http_response HandleGet(const web::uri &uri, const web::json::value &data);
+ web::http::http_response HandleOptions(const web::uri &uri, const web::json::value &data);
mitk::IRESTManager *m_ManagerService;
std::string m_DownloadDir;
+ DICOMweb m_DicomWeb;
};
#endif // ReworkRequestHandler_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 dbca8823b7..c4a384f7b0 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,565 +1,569 @@
/*===================================================================
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 <usServiceTracker.h>
#include <usModuleRegistry.h>
-#include <usGetModuleContext.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);
+ 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_RequestHandler = new ReworkRequestHandler(m_DownloadBaseDir);
+ m_DicomWeb = DICOMweb(L"http://193.174.48.78:8090/dcm4chee-arc/aets/DCM4CHEE/");
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 = DICOMweb::CreateQIDOUri(seriesInstancesParams);
+ 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();
}
void SegmentationReworkView::RestartConnection(std::string newHost)
{
auto hostBefore = m_Controls.dcm4cheeURL->text();
std::string host;
if (newHost.empty())
{
host = m_Controls.dcm4cheeHostValue->text().toStdString();
}
else
{
host = newHost;
}
std::string url = host + "/dcm4chee-arc/aets/DCM4CHEE";
if (!host.empty())
{
MITK_INFO << "Restarting connection to " << 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;
//}
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;
}
}
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");
}
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
{
- DICOMweb::SendSTOW(filePath, mitk::RESTUtil::convertToTString(m_CurrentStudyUID)).then([=] {
+ 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 cd78ebf922..d2a882575a 100644
--- a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.h
+++ b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.h
@@ -1,105 +1,106 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef SegmentationReworkView_h
#define SegmentationReworkView_h
#include <berryISelectionListener.h>
#include <QmitkAbstractView.h>
#include "ui_SegmentationReworkViewControls.h"
#include <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 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