Mercurial > hg > orthanc-stone
changeset 372:17d1814c2fd4 am-2
integration default->am-2
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Mon, 05 Nov 2018 10:05:33 +0100 |
| parents | 557c8ff1db5c (diff) fe4befe03935 (current diff) |
| children | d6136a7e914d 20a20babc02c |
| files | |
| diffstat | 205 files changed, 14732 insertions(+), 2606 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/.hgignore Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,7 @@ +CMakeLists.txt.user +Platforms/Generic/ThirdPartyDownloads/ +Applications/Qt/archive/ +Applications/Samples/ThirdPartyDownloads/ +Applications/Samples/build-wasm/ +Applications/Samples/build-web/ +.vscode/
--- a/Applications/BasicApplicationContext.cpp Mon Nov 05 10:04:56 2018 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,144 +0,0 @@ -/** - * Stone of Orthanc - * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics - * Department, University Hospital of Liege, Belgium - * Copyright (C) 2017-2018 Osimis S.A., Belgium - * - * This program is free software: you can redistribute it and/or - * modify it under the terms of the GNU Affero General Public License - * as published by the Free Software Foundation, either version 3 of - * the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - **/ - - -#include "BasicApplicationContext.h" - -namespace OrthancStone -{ - void BasicApplicationContext::UpdateThread(BasicApplicationContext* that) - { - while (!that->stopped_) - { - { - ViewportLocker locker(*that); - locker.GetViewport().UpdateContent(); - } - - boost::this_thread::sleep(boost::posix_time::milliseconds(that->updateDelay_)); - } - } - - - BasicApplicationContext::BasicApplicationContext(Orthanc::WebServiceParameters& orthanc) : - oracle_(viewportMutex_, 4), // Use 4 threads to download - //oracle_(viewportMutex_, 1), // Disable threading to be reproducible - webService_(oracle_, orthanc), - stopped_(true), - updateDelay_(100) // By default, 100ms between each refresh of the content - { - srand(time(NULL)); - } - - - BasicApplicationContext::~BasicApplicationContext() - { - for (Interactors::iterator it = interactors_.begin(); it != interactors_.end(); ++it) - { - assert(*it != NULL); - delete *it; - } - - for (SlicedVolumes::iterator it = slicedVolumes_.begin(); it != slicedVolumes_.end(); ++it) - { - assert(*it != NULL); - delete *it; - } - - for (VolumeLoaders::iterator it = volumeLoaders_.begin(); it != volumeLoaders_.end(); ++it) - { - assert(*it != NULL); - delete *it; - } - } - - - IWidget& BasicApplicationContext::SetCentralWidget(IWidget* widget) // Takes ownership - { - viewport_.SetCentralWidget(widget); - return *widget; - } - - - ISlicedVolume& BasicApplicationContext::AddSlicedVolume(ISlicedVolume* volume) - { - if (volume == NULL) - { - throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); - } - else - { - slicedVolumes_.push_back(volume); - return *volume; - } - } - - - IVolumeLoader& BasicApplicationContext::AddVolumeLoader(IVolumeLoader* loader) - { - if (loader == NULL) - { - throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); - } - else - { - volumeLoaders_.push_back(loader); - return *loader; - } - } - - - IWorldSceneInteractor& BasicApplicationContext::AddInteractor(IWorldSceneInteractor* interactor) - { - if (interactor == NULL) - { - throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); - } - - interactors_.push_back(interactor); - - return *interactor; - } - - - void BasicApplicationContext::Start() - { - oracle_.Start(); - - if (viewport_.HasUpdateContent()) - { - stopped_ = false; - updateThread_ = boost::thread(UpdateThread, this); - } - } - - - void BasicApplicationContext::Stop() - { - stopped_ = true; - - if (updateThread_.joinable()) - { - updateThread_.join(); - } - - oracle_.Stop(); - } -}
--- a/Applications/BasicApplicationContext.h Mon Nov 05 10:04:56 2018 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,102 +0,0 @@ -/** - * Stone of Orthanc - * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics - * Department, University Hospital of Liege, Belgium - * Copyright (C) 2017-2018 Osimis S.A., Belgium - * - * This program is free software: you can redistribute it and/or - * modify it under the terms of the GNU Affero General Public License - * as published by the Free Software Foundation, either version 3 of - * the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - **/ - - -#pragma once - -#include "../Framework/Viewport/WidgetViewport.h" -#include "../Framework/Volumes/ISlicedVolume.h" -#include "../Framework/Volumes/IVolumeLoader.h" -#include "../Framework/Widgets/IWorldSceneInteractor.h" -#include "../Platforms/Generic/OracleWebService.h" - -#include <list> -#include <boost/thread.hpp> - -namespace OrthancStone -{ - class BasicApplicationContext : public boost::noncopyable - { - private: - typedef std::list<ISlicedVolume*> SlicedVolumes; - typedef std::list<IVolumeLoader*> VolumeLoaders; - typedef std::list<IWorldSceneInteractor*> Interactors; - - static void UpdateThread(BasicApplicationContext* that); - - Oracle oracle_; - OracleWebService webService_; - boost::mutex viewportMutex_; - WidgetViewport viewport_; - SlicedVolumes slicedVolumes_; - VolumeLoaders volumeLoaders_; - Interactors interactors_; - boost::thread updateThread_; - bool stopped_; - unsigned int updateDelay_; - - public: - class ViewportLocker : public boost::noncopyable - { - private: - boost::mutex::scoped_lock lock_; - IViewport& viewport_; - - public: - ViewportLocker(BasicApplicationContext& that) : - lock_(that.viewportMutex_), - viewport_(that.viewport_) - { - } - - IViewport& GetViewport() const - { - return viewport_; - } - }; - - - BasicApplicationContext(Orthanc::WebServiceParameters& orthanc); - - ~BasicApplicationContext(); - - IWidget& SetCentralWidget(IWidget* widget); // Takes ownership - - IWebService& GetWebService() - { - return webService_; - } - - ISlicedVolume& AddSlicedVolume(ISlicedVolume* volume); - - IVolumeLoader& AddVolumeLoader(IVolumeLoader* loader); - - IWorldSceneInteractor& AddInteractor(IWorldSceneInteractor* interactor); - - void Start(); - - void Stop(); - - void SetUpdateDelay(unsigned int delay) // In milliseconds - { - updateDelay_ = delay; - } - }; -}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Commands/BaseCommandBuilder.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,49 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#include "BaseCommandBuilder.h" +#include "Core/OrthancException.h" +#include <iostream> +#include "Framework/StoneException.h" + +namespace OrthancStone +{ + ICommand* BaseCommandBuilder::CreateFromJson(const Json::Value& commandJson) + { + if (!commandJson.isObject() || !commandJson["command"].isString()) + { + throw StoneException(ErrorCode_CommandJsonInvalidFormat); + } + + if (commandJson["commandType"].isString() && commandJson["commandType"].asString() == "generic-no-arg-command") + { + printf("creating a simple command\n"); + return new GenericNoArgCommand(commandJson["command"].asString().c_str()); + } + else if (commandJson["commandType"].isString() && commandJson["commandType"].asString() == "generic-one-string-arg-command") + { + printf("creating a simple command\n"); + return new GenericNoArgCommand(commandJson["command"].asString().c_str()); + } + + return NULL; + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Commands/BaseCommandBuilder.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,38 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#pragma once + +#include <map> +#include <memory> + +#include "ICommand.h" +#include "../../Applications/Commands/ICommandBuilder.h" + +// TODO: must be reworked completely (check trello) + +namespace OrthancStone +{ + class BaseCommandBuilder : public ICommandBuilder + { + public: + virtual ICommand* CreateFromJson(const Json::Value& commandJson); + }; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Commands/BaseCommands.yml Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,10 @@ +SelectTool: + target: Application + toolName: string + comment: Selects the current application tool +DownloadDicom: + target: LayerWidget + comment: Downloads the slice currently displayed in the LayerWidget +Export: + target: IWidget + comment: Export the content of the widget \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Commands/ICommand.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,94 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include <json/json.h> + +// TODO: must be reworked completely (check trello) + +namespace OrthancStone +{ + class ICommand // TODO noncopyable + { + protected: + std::string name_; + ICommand(const std::string& name) + : name_(name) + {} + public: + virtual void Execute() = 0; +// virtual void Configure(const Json::Value& arguments) = 0; + const std::string& GetName() const + { + return name_; + } + }; + + + template <typename TCommand> + class BaseCommand : public ICommand + { + protected: + BaseCommand(const std::string& name) + : ICommand(name) + {} + + public: + static ICommand* Create() { + return new TCommand(); + } + + virtual void Configure(const Json::Value& arguments) { + } + }; + + class NoopCommand : public BaseCommand<NoopCommand> + { + public: + NoopCommand() + : BaseCommand("noop") + {} + virtual void Execute() {} + }; + + class GenericNoArgCommand : public BaseCommand<GenericNoArgCommand> + { + public: + GenericNoArgCommand(const std::string& name) + : BaseCommand(name) + {} + virtual void Execute() {} // TODO currently not used but this is not nice at all ! + }; + + class GenericOneStringArgCommand : public BaseCommand<GenericOneStringArgCommand> + { + std::string argument_; + public: + GenericOneStringArgCommand(const std::string& name, const std::string& argument) + : BaseCommand(name) + {} + + const std::string& GetArgument() const {return argument_;} + virtual void Execute() {} // TODO currently not used but this is not nice at all ! + }; + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Commands/ICommandBuilder.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,37 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include <boost/noncopyable.hpp> +#include <json/json.h> + +#include "ICommand.h" + +namespace OrthancStone +{ + + class ICommandBuilder : public boost::noncopyable + { + public: + virtual ICommand* CreateFromJson(const Json::Value& commandJson) = 0; + }; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Commands/ICommandExecutor.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,32 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include <boost/noncopyable.hpp> + +namespace OrthancStone +{ + class ICommandExecutor : public boost::noncopyable + { + + }; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Generic/NativeStoneApplicationContext.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,80 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#include "NativeStoneApplicationContext.h" +#include "../../Platforms/Generic/OracleWebService.h" + +namespace OrthancStone +{ + IWidget& NativeStoneApplicationContext::SetCentralWidget(IWidget* widget) // Takes ownership + { + centralViewport_->SetCentralWidget(widget); + return *widget; + } + + + void NativeStoneApplicationContext::UpdateThread(NativeStoneApplicationContext* that) + { + while (!that->stopped_) + { + { + GlobalMutexLocker locker(*that); + that->GetCentralViewport().UpdateContent(); + } + + boost::this_thread::sleep(boost::posix_time::milliseconds(that->updateDelayInMs_)); + } + } + + + NativeStoneApplicationContext::NativeStoneApplicationContext() : + centralViewport_(new OrthancStone::WidgetViewport()), + stopped_(true), + updateDelayInMs_(100) // By default, 100ms between each refresh of the content + { + srand(time(NULL)); + } + + + void NativeStoneApplicationContext::Start() + { + dynamic_cast<OracleWebService*>(webService_)->Start(); + + if (centralViewport_->HasUpdateContent()) + { + stopped_ = false; + updateThread_ = boost::thread(UpdateThread, this); + } + } + + + void NativeStoneApplicationContext::Stop() + { + stopped_ = true; + + if (updateThread_.joinable()) + { + updateThread_.join(); + } + + dynamic_cast<OracleWebService*>(webService_)->Stop(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Generic/NativeStoneApplicationContext.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,79 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "../../Framework/Viewport/WidgetViewport.h" +#include "../../Framework/Volumes/ISlicedVolume.h" +#include "../../Framework/Volumes/IVolumeLoader.h" + +#include <list> +#include <boost/thread.hpp> +#include "../StoneApplicationContext.h" + +namespace OrthancStone +{ + class NativeStoneApplicationContext : public StoneApplicationContext + { + private: + + static void UpdateThread(NativeStoneApplicationContext* that); + + boost::mutex globalMutex_; + std::auto_ptr<WidgetViewport> centralViewport_; + boost::thread updateThread_; + bool stopped_; + unsigned int updateDelayInMs_; + + public: + class GlobalMutexLocker: public boost::noncopyable + { + boost::mutex::scoped_lock lock_; + public: + GlobalMutexLocker(NativeStoneApplicationContext& that): + lock_(that.globalMutex_) + { + } + }; + + NativeStoneApplicationContext(); + + virtual ~NativeStoneApplicationContext() + { + } + + virtual IWidget& SetCentralWidget(IWidget* widget); // Takes ownership + + IViewport& GetCentralViewport() + { + return *(centralViewport_.get()); + } + + void Start(); + + void Stop(); + + void SetUpdateDelay(unsigned int delayInMs) + { + updateDelayInMs_ = delayInMs; + } + }; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Generic/NativeStoneApplicationRunner.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,236 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#if ORTHANC_ENABLE_NATIVE != 1 +#error this file shall be included only with the ORTHANC_ENABLE_NATIVE set to 1 +#endif + +#include "NativeStoneApplicationRunner.h" +#include "NativeStoneApplicationContext.h" +#include <boost/program_options.hpp> + +#include "../../Framework/Toolbox/MessagingToolbox.h" + +#include <Core/Logging.h> +#include <Core/HttpClient.h> +#include <Core/Toolbox.h> +#include <Plugins/Samples/Common/OrthancHttpConnection.h> +#include "../../Platforms/Generic/OracleWebService.h" + +namespace OrthancStone +{ + // Anonymous namespace to avoid clashes against other compilation modules + namespace + { + class LogStatusBar : public IStatusBar + { + public: + virtual void ClearMessage() + { + } + + virtual void SetMessage(const std::string& message) + { + LOG(WARNING) << message; + } + }; + } + + int NativeStoneApplicationRunner::Execute(int argc, + char* argv[]) + { + /****************************************************************** + * Initialize all the subcomponents of Orthanc Stone + ******************************************************************/ + + Orthanc::Logging::Initialize(); + Orthanc::Toolbox::InitializeOpenSsl(); + Orthanc::HttpClient::GlobalInitialize(); + + Initialize(); + + /****************************************************************** + * Declare and parse the command-line options of the application + ******************************************************************/ + + boost::program_options::options_description options; + + { // generic options + boost::program_options::options_description generic("Generic options"); + generic.add_options() + ("help", "Display this help and exit") + ("verbose", "Be verbose in logs") + ("orthanc", boost::program_options::value<std::string>()->default_value("http://localhost:8042/"), + "URL to the Orthanc server") + ("username", "Username for the Orthanc server") + ("password", "Password for the Orthanc server") + ("https-verify", boost::program_options::value<bool>()->default_value(true), "Check HTTPS certificates") + ; + + options.add(generic); + } + + // platform specific options + DeclareCommandLineOptions(options); + + // application specific options + application_.DeclareStartupOptions(options); + + boost::program_options::variables_map parameters; + bool error = false; + + try + { + boost::program_options::store(boost::program_options::command_line_parser(argc, argv). + options(options).run(), parameters); + boost::program_options::notify(parameters); + } + catch (boost::program_options::error& e) + { + LOG(ERROR) << "Error while parsing the command-line arguments: " << e.what(); + error = true; + } + + + /****************************************************************** + * Configure the application with the command-line parameters + ******************************************************************/ + + if (error || parameters.count("help")) + { + std::cout << std::endl + << "Usage: " << argv[0] << " [OPTION]..." + << std::endl + << "Orthanc, lightweight, RESTful DICOM server for healthcare and medical research." + << std::endl << std::endl + << "Demonstration application of Orthanc Stone in native environment." + << std::endl; + + std::cout << options << "\n"; + return error ? -1 : 0; + } + + if (parameters.count("https-verify") && + !parameters["https-verify"].as<bool>()) + { + LOG(WARNING) << "Turning off verification of HTTPS certificates (unsafe)"; + Orthanc::HttpClient::ConfigureSsl(false, ""); + } + + if (parameters.count("verbose")) + { + Orthanc::Logging::EnableInfoLevel(true); + } + + ParseCommandLineOptions(parameters); + + + bool success = true; + try + { + /**************************************************************** + * Initialize the connection to the Orthanc server + ****************************************************************/ + + Orthanc::WebServiceParameters webServiceParameters; + + if (parameters.count("orthanc")) + { + webServiceParameters.SetUrl(parameters["orthanc"].as<std::string>()); + } + + if (parameters.count("username") && parameters.count("password")) + { + webServiceParameters.SetCredentials(parameters["username"].as<std::string>(), + parameters["password"].as<std::string>()); + } + + LOG(WARNING) << "URL to the Orthanc REST API: " << webServiceParameters.GetUrl(); + + { + OrthancPlugins::OrthancHttpConnection orthanc(webServiceParameters); + if (!MessagingToolbox::CheckOrthancVersion(orthanc)) + { + LOG(ERROR) << "Your version of Orthanc is incompatible with Stone of Orthanc, please upgrade"; + throw Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol); + } + } + + + /**************************************************************** + * Initialize the application + ****************************************************************/ + + LOG(WARNING) << "Creating the widgets of the application"; + + LogStatusBar statusBar; + + NativeStoneApplicationContext context; + Oracle oracle(4); // use 4 threads to download content + OracleWebService webService(broker_, oracle, webServiceParameters, context); + context.SetWebService(webService); + + application_.Initialize(&context, statusBar, parameters); + + { + NativeStoneApplicationContext::GlobalMutexLocker locker(context); + context.SetCentralWidget(application_.GetCentralWidget()); + context.GetCentralViewport().SetStatusBar(statusBar); + } + + std::string title = application_.GetTitle(); + if (title.empty()) + { + title = "Stone of Orthanc"; + } + + /**************************************************************** + * Run the application + ****************************************************************/ + + Run(context, title, argc, argv); + + /**************************************************************** + * Finalize the application + ****************************************************************/ + + LOG(WARNING) << "The application is stopping"; + application_.Finalize(); + } + catch (Orthanc::OrthancException& e) + { + LOG(ERROR) << "EXCEPTION: " << e.What(); + success = false; + } + + + /****************************************************************** + * Finalize all the subcomponents of Orthanc Stone + ******************************************************************/ + + Finalize(); + Orthanc::HttpClient::GlobalFinalize(); + Orthanc::Toolbox::FinalizeOpenSsl(); + + return (success ? 0 : -1); + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Generic/NativeStoneApplicationRunner.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,58 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "../IStoneApplication.h" + +#if ORTHANC_ENABLE_NATIVE != 1 +#error this file shall be included only with the ORTHANC_ENABLE_NATIVE set to 1 +#endif + +namespace OrthancStone +{ + class NativeStoneApplicationContext; + + class NativeStoneApplicationRunner + { + protected: + MessageBroker& broker_; + IStoneApplication& application_; + public: + + NativeStoneApplicationRunner(MessageBroker& broker, + IStoneApplication& application) + : broker_(broker), + application_(application) + { + } + int Execute(int argc, + char* argv[]); + + virtual void Initialize() = 0; + virtual void DeclareCommandLineOptions(boost::program_options::options_description& options) = 0; + virtual void ParseCommandLineOptions(const boost::program_options::variables_map& parameters) = 0; + + virtual void Run(NativeStoneApplicationContext& context, const std::string& title, int argc, char* argv[]) = 0; + virtual void Finalize() = 0; + }; + +}
--- a/Applications/IBasicApplication.cpp Mon Nov 05 10:04:56 2018 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,300 +0,0 @@ -/** - * Stone of Orthanc - * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics - * Department, University Hospital of Liege, Belgium - * Copyright (C) 2017-2018 Osimis S.A., Belgium - * - * This program is free software: you can redistribute it and/or - * modify it under the terms of the GNU Affero General Public License - * as published by the Free Software Foundation, either version 3 of - * the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - **/ - - -#include "IBasicApplication.h" - -#include "../Framework/Toolbox/MessagingToolbox.h" -#include "Sdl/SdlEngine.h" - -#include <Core/Logging.h> -#include <Core/HttpClient.h> -#include <Core/Toolbox.h> -#include <Plugins/Samples/Common/OrthancHttpConnection.h> - -namespace OrthancStone -{ - // Anonymous namespace to avoid clashes against other compilation modules - namespace - { - class LogStatusBar : public IStatusBar - { - public: - virtual void ClearMessage() - { - } - - virtual void SetMessage(const std::string& message) - { - LOG(WARNING) << message; - } - }; - } - - -#if ORTHANC_ENABLE_SDL == 1 - static void DeclareSdlCommandLineOptions(boost::program_options::options_description& options) - { - // Declare the supported parameters - boost::program_options::options_description generic("Generic options"); - generic.add_options() - ("help", "Display this help and exit") - ("verbose", "Be verbose in logs") - ("orthanc", boost::program_options::value<std::string>()->default_value("http://localhost:8042/"), - "URL to the Orthanc server") - ("username", "Username for the Orthanc server") - ("password", "Password for the Orthanc server") - ("https-verify", boost::program_options::value<bool>()->default_value(true), "Check HTTPS certificates") - ; - - options.add(generic); - - boost::program_options::options_description sdl("SDL options"); - sdl.add_options() - ("width", boost::program_options::value<int>()->default_value(1024), "Initial width of the SDL window") - ("height", boost::program_options::value<int>()->default_value(768), "Initial height of the SDL window") - ("opengl", boost::program_options::value<bool>()->default_value(true), "Enable OpenGL in SDL") - ; - - options.add(sdl); - } - - - int IBasicApplication::ExecuteWithSdl(IBasicApplication& application, - int argc, - char* argv[]) - { - /****************************************************************** - * Initialize all the subcomponents of Orthanc Stone - ******************************************************************/ - - Orthanc::Logging::Initialize(); - Orthanc::Toolbox::InitializeOpenSsl(); - Orthanc::HttpClient::GlobalInitialize(); - SdlWindow::GlobalInitialize(); - - - /****************************************************************** - * Declare and parse the command-line options of the application - ******************************************************************/ - - boost::program_options::options_description options; - DeclareSdlCommandLineOptions(options); - application.DeclareCommandLineOptions(options); - - boost::program_options::variables_map parameters; - bool error = false; - - try - { - boost::program_options::store(boost::program_options::command_line_parser(argc, argv). - options(options).run(), parameters); - boost::program_options::notify(parameters); - } - catch (boost::program_options::error& e) - { - LOG(ERROR) << "Error while parsing the command-line arguments: " << e.what(); - error = true; - } - - - /****************************************************************** - * Configure the application with the command-line parameters - ******************************************************************/ - - if (error || parameters.count("help")) - { - std::cout << std::endl - << "Usage: " << argv[0] << " [OPTION]..." - << std::endl - << "Orthanc, lightweight, RESTful DICOM server for healthcare and medical research." - << std::endl << std::endl - << "Demonstration application of Orthanc Stone using SDL." - << std::endl; - - std::cout << options << "\n"; - return error ? -1 : 0; - } - - if (parameters.count("https-verify") && - !parameters["https-verify"].as<bool>()) - { - LOG(WARNING) << "Turning off verification of HTTPS certificates (unsafe)"; - Orthanc::HttpClient::ConfigureSsl(false, ""); - } - - if (parameters.count("verbose")) - { - Orthanc::Logging::EnableInfoLevel(true); - } - - if (!parameters.count("width") || - !parameters.count("height") || - !parameters.count("opengl")) - { - LOG(ERROR) << "Parameter \"width\", \"height\" or \"opengl\" is missing"; - return -1; - } - - int w = parameters["width"].as<int>(); - int h = parameters["height"].as<int>(); - if (w <= 0 || h <= 0) - { - LOG(ERROR) << "Parameters \"width\" and \"height\" must be positive"; - return -1; - } - - unsigned int width = static_cast<unsigned int>(w); - unsigned int height = static_cast<unsigned int>(h); - LOG(WARNING) << "Initial display size: " << width << "x" << height; - - bool opengl = parameters["opengl"].as<bool>(); - if (opengl) - { - LOG(WARNING) << "OpenGL is enabled, disable it with option \"--opengl=off\" if the application crashes"; - } - else - { - LOG(WARNING) << "OpenGL is disabled, enable it with option \"--opengl=on\" for best performance"; - } - - bool success = true; - try - { - /**************************************************************** - * Initialize the connection to the Orthanc server - ****************************************************************/ - - Orthanc::WebServiceParameters webService; - - if (parameters.count("orthanc")) - { - webService.SetUrl(parameters["orthanc"].as<std::string>()); - } - - std::string username, password; - - if (parameters.count("username")) - { - username = parameters["username"].as<std::string>(); - } - - if (parameters.count("password")) - { - password = parameters["password"].as<std::string>(); - } - - if (!username.empty() || - !password.empty()) - { - webService.SetCredentials(username, password); - } - - LOG(WARNING) << "URL to the Orthanc REST API: " << webService.GetUrl(); - - { - OrthancPlugins::OrthancHttpConnection orthanc(webService); - if (!MessagingToolbox::CheckOrthancVersion(orthanc)) - { - LOG(ERROR) << "Your version of Orthanc is incompatible with Stone of Orthanc, please upgrade"; - throw Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol); - } - } - - - /**************************************************************** - * Initialize the application - ****************************************************************/ - - LOG(WARNING) << "Creating the widgets of the application"; - - LogStatusBar statusBar; - BasicApplicationContext context(webService); - - application.Initialize(context, statusBar, parameters); - - { - BasicApplicationContext::ViewportLocker locker(context); - locker.GetViewport().SetStatusBar(statusBar); - } - - std::string title = application.GetTitle(); - if (title.empty()) - { - title = "Stone of Orthanc"; - } - - { - /************************************************************** - * Run the application inside a SDL window - **************************************************************/ - - LOG(WARNING) << "Starting the application"; - - SdlWindow window(title.c_str(), width, height, opengl); - SdlEngine sdl(window, context); - - { - BasicApplicationContext::ViewportLocker locker(context); - locker.GetViewport().Register(sdl); // (*) - } - - context.Start(); - sdl.Run(); - - LOG(WARNING) << "Stopping the application"; - - // Don't move the "Stop()" command below out of the block, - // otherwise the application might crash, because the - // "SdlEngine" is an observer of the viewport (*) and the - // update thread started by "context.Start()" would call a - // destructed object (the "SdlEngine" is deleted with the - // lexical scope). - context.Stop(); - } - - - /**************************************************************** - * Finalize the application - ****************************************************************/ - - LOG(WARNING) << "The application has stopped"; - application.Finalize(); - } - catch (Orthanc::OrthancException& e) - { - LOG(ERROR) << "EXCEPTION: " << e.What(); - success = false; - } - - - /****************************************************************** - * Finalize all the subcomponents of Orthanc Stone - ******************************************************************/ - - SdlWindow::GlobalFinalize(); - Orthanc::HttpClient::GlobalFinalize(); - Orthanc::Toolbox::FinalizeOpenSsl(); - - return (success ? 0 : -1); - } -#endif - -}
--- a/Applications/IBasicApplication.h Mon Nov 05 10:04:56 2018 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,57 +0,0 @@ -/** - * Stone of Orthanc - * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics - * Department, University Hospital of Liege, Belgium - * Copyright (C) 2017-2018 Osimis S.A., Belgium - * - * This program is free software: you can redistribute it and/or - * modify it under the terms of the GNU Affero General Public License - * as published by the Free Software Foundation, either version 3 of - * the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - **/ - - -#pragma once - -#include "BasicApplicationContext.h" - -#include <boost/program_options.hpp> - -#if ORTHANC_ENABLE_SDL == 1 -# include <SDL.h> // Necessary to avoid undefined reference to `SDL_main' -#endif - -namespace OrthancStone -{ - class IBasicApplication : public boost::noncopyable - { - public: - virtual ~IBasicApplication() - { - } - - virtual void DeclareCommandLineOptions(boost::program_options::options_description& options) = 0; - - virtual std::string GetTitle() const = 0; - - virtual void Initialize(BasicApplicationContext& context, - IStatusBar& statusBar, - const boost::program_options::variables_map& parameters) = 0; - - virtual void Finalize() = 0; - -#if ORTHANC_ENABLE_SDL == 1 - static int ExecuteWithSdl(IBasicApplication& application, - int argc, - char* argv[]); -#endif - }; -}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/IStoneApplication.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,74 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "StoneApplicationContext.h" +#include <boost/program_options.hpp> +#include "../Framework/Viewport/WidgetViewport.h" +#include "json/json.h" +#include "Commands/ICommand.h" +#include "Commands/BaseCommandBuilder.h" + + +namespace OrthancStone +{ +#if ORTHANC_ENABLE_QT==1 + class QStoneMainWindow; +#endif + + // a StoneApplication is an application that can actually be executed + // in multiple environments. i.e: it can run natively integrated in a QtApplication + // or it can be executed as part of a WebPage when compiled into WebAssembly. + class IStoneApplication : public boost::noncopyable + { + protected: + StoneApplicationContext* context_; + + public: + virtual ~IStoneApplication() + { + } + + virtual void DeclareStartupOptions(boost::program_options::options_description& options) = 0; + virtual void Initialize(StoneApplicationContext* context, + IStatusBar& statusBar, + const boost::program_options::variables_map& parameters) = 0; +#if ORTHANC_ENABLE_WASM==1 + virtual void InitializeWasm() {} // specific initialization when the app is running in WebAssembly. This is called after the other Initialize() +#endif +#if ORTHANC_ENABLE_QT==1 + virtual QStoneMainWindow* CreateQtMainWindow() = 0; +#endif + + virtual std::string GetTitle() const = 0; + virtual IWidget* GetCentralWidget() = 0; + + virtual void Finalize() = 0; + + virtual BaseCommandBuilder& GetCommandBuilder() = 0; + + virtual void ExecuteCommand(ICommand& command) + { + } + }; + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Qt/QCairoWidget.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,183 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#include "QCairoWidget.h" + +#include <QPainter> +#include <QPaintEvent> + +#include <stdexcept> + +QCairoWidget::QCairoWidget(QWidget *parent) : + QWidget(parent), + context_(NULL) +{ + setFocusPolicy(Qt::StrongFocus); // catch keyPressEvents +} + +QCairoWidget::~QCairoWidget() +{ +} + +void QCairoWidget::SetContext(OrthancStone::NativeStoneApplicationContext& context) +{ + context_ = &context; + context_->GetCentralViewport().Register(*this); // get notified each time the content of the central viewport changes +} + +void QCairoWidget::paintEvent(QPaintEvent* /*event*/) +{ + QPainter painter(this); + + if (image_.get() != NULL && context_ != NULL) + { + OrthancStone::NativeStoneApplicationContext::GlobalMutexLocker locker(*context_); + OrthancStone::IViewport& viewport = context_->GetCentralViewport(); + Orthanc::ImageAccessor a; + surface_.GetWriteableAccessor(a); + viewport.Render(a); + painter.drawImage(0, 0, *image_); + } + else + { + painter.fillRect(rect(), Qt::red); + } +} + +OrthancStone::KeyboardModifiers GetKeyboardModifiers(QInputEvent* event) +{ + Qt::KeyboardModifiers qtModifiers = event->modifiers(); + int stoneModifiers = static_cast<int>(OrthancStone::KeyboardModifiers_None); + if ((qtModifiers & Qt::AltModifier) != 0) + { + stoneModifiers |= static_cast<int>(OrthancStone::KeyboardModifiers_Alt); + } + if ((qtModifiers & Qt::ControlModifier) != 0) + { + stoneModifiers |= static_cast<int>(OrthancStone::KeyboardModifiers_Control); + } + if ((qtModifiers & Qt::ShiftModifier) != 0) + { + stoneModifiers |= static_cast<int>(OrthancStone::KeyboardModifiers_Shift); + } + return static_cast<OrthancStone::KeyboardModifiers>(stoneModifiers); +} + +void QCairoWidget::mousePressEvent(QMouseEvent* event) +{ + OrthancStone::KeyboardModifiers stoneModifiers = GetKeyboardModifiers(event); + + OrthancStone::MouseButton button; + + switch (event->button()) + { + case Qt::LeftButton: + button = OrthancStone::MouseButton_Left; + break; + + case Qt::RightButton: + button = OrthancStone::MouseButton_Right; + break; + + case Qt::MiddleButton: + button = OrthancStone::MouseButton_Middle; + break; + + default: + return; // Unsupported button + } + context_->GetCentralViewport().MouseDown(button, event->pos().x(), event->pos().y(), stoneModifiers); +} + + +void QCairoWidget::mouseReleaseEvent(QMouseEvent* /*eventNotUsed*/) +{ + context_->GetCentralViewport().MouseLeave(); +} + + +void QCairoWidget::mouseMoveEvent(QMouseEvent* event) +{ + context_->GetCentralViewport().MouseMove(event->pos().x(), event->pos().y()); +} + + +void QCairoWidget::wheelEvent(QWheelEvent * event) +{ + OrthancStone::KeyboardModifiers stoneModifiers = GetKeyboardModifiers(event); + + if (event->orientation() == Qt::Vertical) + { + if (event->delta() < 0) // TODO: compare direction with SDL and make sure we send the same directions + { + context_->GetCentralViewport().MouseWheel(OrthancStone::MouseWheelDirection_Up, event->pos().x(), event->pos().y(), stoneModifiers); + } + else + { + context_->GetCentralViewport().MouseWheel(OrthancStone::MouseWheelDirection_Down, event->pos().x(), event->pos().y(), stoneModifiers); + } + } +} + +void QCairoWidget::keyPressEvent(QKeyEvent *event) +{ + using namespace OrthancStone; + + OrthancStone::KeyboardModifiers stoneModifiers = GetKeyboardModifiers(event); + + OrthancStone::KeyboardKeys keyType = OrthancStone::KeyboardKeys_Generic; + char keyChar = event->text()[0].toLatin1(); + +#define CASE_QT_KEY_TO_ORTHANC(qt, o) case qt: keyType = o; break; + if (keyChar == 0) + { + switch (event->key()) + { + CASE_QT_KEY_TO_ORTHANC(Qt::Key_Up, KeyboardKeys_Up); + CASE_QT_KEY_TO_ORTHANC(Qt::Key_Down, KeyboardKeys_Down); + CASE_QT_KEY_TO_ORTHANC(Qt::Key_Left, KeyboardKeys_Left); + CASE_QT_KEY_TO_ORTHANC(Qt::Key_Right, KeyboardKeys_Right); + default: + break; + } + } + context_->GetCentralViewport().KeyPressed(keyType, keyChar, stoneModifiers); +} + + +void QCairoWidget::resizeEvent(QResizeEvent* event) +{ + grabGesture(Qt::PanGesture); + QWidget::resizeEvent(event); + + if (event) + { + surface_.SetSize(event->size().width(), event->size().height()); + + image_.reset(new QImage(reinterpret_cast<uchar*>(surface_.GetBuffer()), + event->size().width(), + event->size().height(), + surface_.GetPitch(), + QImage::Format_RGB32)); + + context_->GetCentralViewport().SetSize(event->size().width(), event->size().height()); + + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Qt/QCairoWidget.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,75 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#pragma once + +#include "../../Framework/Widgets/CairoWidget.h" +#include "../../Applications/Generic/NativeStoneApplicationContext.h" +#include "../../Framework/Viewport/CairoSurface.h" + +#include <QWidget> +#include <QGestureEvent> +#include <memory> +#include <cassert> + +class QCairoWidget : public QWidget, public OrthancStone::IViewport::IObserver +{ + Q_OBJECT + +private: + std::auto_ptr<QImage> image_; + OrthancStone::CairoSurface surface_; + OrthancStone::NativeStoneApplicationContext* context_; + +protected: + virtual void paintEvent(QPaintEvent *event); + + virtual void resizeEvent(QResizeEvent *event); + + virtual void mouseMoveEvent(QMouseEvent *event); + + virtual void mousePressEvent(QMouseEvent *event); + + virtual void mouseReleaseEvent(QMouseEvent *event); + + virtual void wheelEvent(QWheelEvent *event); + + virtual void keyPressEvent(QKeyEvent *event); + +public: + explicit QCairoWidget(QWidget *parent); + + virtual ~QCairoWidget(); + + void SetContext(OrthancStone::NativeStoneApplicationContext& context); + + virtual void OnViewportContentChanged(const OrthancStone::IViewport& /*sceneNotUsed*/) + { + update(); // schedule a repaint (handled by Qt) + emit ContentChanged(); + } + +signals: + + void ContentChanged(); + +public slots: + +};
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Qt/QStoneMainWindow.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,41 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#include "QStoneMainWindow.h" + +namespace OrthancStone +{ + + QStoneMainWindow::QStoneMainWindow(NativeStoneApplicationContext& context, QWidget *parent) : + QMainWindow(parent), + context_(context) + { + } + + void QStoneMainWindow::SetCentralStoneWidget(QCairoWidget *centralWidget) + { + cairoCentralWidget_ = centralWidget; + cairoCentralWidget_->SetContext(context_); + } + + QStoneMainWindow::~QStoneMainWindow() + { + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Qt/QStoneMainWindow.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,45 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ +#pragma once + +#include <QMainWindow> + +#include "QCairoWidget.h" +#include "../Generic/NativeStoneApplicationContext.h" + +namespace OrthancStone +{ + class QStoneMainWindow : public QMainWindow + { + Q_OBJECT + + private: + OrthancStone::NativeStoneApplicationContext& context_; + QCairoWidget *cairoCentralWidget_; + + protected: // you must inherit this class + QStoneMainWindow(NativeStoneApplicationContext& context, QWidget *parent = 0); + void SetCentralStoneWidget(QCairoWidget* centralWidget); + public: + virtual ~QStoneMainWindow(); + + }; + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Qt/QtStoneApplicationRunner.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,67 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#if ORTHANC_ENABLE_QT != 1 +#error this file shall be included only with the ORTHANC_ENABLE_QT set to 1 +#endif + +#include "QtStoneApplicationRunner.h" +#include <boost/program_options.hpp> +#include <QApplication> + +#include "../../Framework/Toolbox/MessagingToolbox.h" + +#include <Core/Logging.h> +#include <Core/HttpClient.h> +#include <Core/Toolbox.h> +#include <Plugins/Samples/Common/OrthancHttpConnection.h> +#include "../../Platforms/Generic/OracleWebService.h" + + +namespace OrthancStone +{ + void QtStoneApplicationRunner::Initialize() + { + } + + void QtStoneApplicationRunner::DeclareCommandLineOptions(boost::program_options::options_description& options) + { + } + + void QtStoneApplicationRunner::Run(NativeStoneApplicationContext& context, const std::string& title, int argc, char* argv[]) + { + context.Start(); + + QApplication qtApplication(argc, argv); + window_.reset(application_.CreateQtMainWindow()); + + window_->show(); + qtApplication.exec(); + + context.Stop(); + } + + void QtStoneApplicationRunner::Finalize() + { + } + + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Qt/QtStoneApplicationRunner.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,54 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "../Generic/NativeStoneApplicationRunner.h" +#include "QStoneMainWindow.h" + +#if ORTHANC_ENABLE_QT != 1 +#error this file shall be included only with the ORTHANC_ENABLE_QT set to 1 +#endif + +namespace OrthancStone +{ + class QtStoneApplicationRunner : public NativeStoneApplicationRunner + { + protected: + std::auto_ptr<QStoneMainWindow> window_; + + public: + QtStoneApplicationRunner(MessageBroker& broker, + IStoneApplication& application) + : NativeStoneApplicationRunner(broker, application) + { + } + + + virtual void Initialize(); + + virtual void DeclareCommandLineOptions(boost::program_options::options_description& options); + virtual void ParseCommandLineOptions(const boost::program_options::variables_map& parameters) {} + virtual void Run(NativeStoneApplicationContext& context, const std::string& title, int argc, char* argv[]); + virtual void Finalize(); + }; + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/CMakeLists.txt Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,222 @@ +# Usage (Linux): +# to build the WASM samples +# source ~/Downloads/emsdk/emsdk_env.sh && cmake -DCMAKE_TOOLCHAIN_FILE=${EMSCRIPTEN}/cmake/Modules/Platform/Emscripten.cmake -DCMAKE_BUILD_TYPE=Release -DSTONE_SOURCES_DIR=$currentDir/../../../orthanc-stone -DORTHANC_FRAMEWORK_SOURCE=path -DORTHANC_FRAMEWORK_ROOT=$currentDir/../../../orthanc -DALLOW_DOWNLOADS=ON .. -DENABLE_WASM=ON +# to build the Qt samples + +cmake_minimum_required(VERSION 2.8.3) +project(OrthancStone) + +include(../../Resources/CMake/OrthancStoneParameters.cmake) + +#set(ENABLE_DCMTK ON) + +set(ENABLE_SDL OFF CACHE BOOL "Target SDL Native application") +set(ENABLE_QT OFF CACHE BOOL "Target Qt Native application") +set(ENABLE_WASM OFF CACHE BOOL "Target WASM application") + +if (ENABLE_WASM) + ##################################################################### + ## Configuration of the Emscripten compiler for WebAssembly target + ##################################################################### + + set(WASM_FLAGS "-s WASM=1") + set(WASM_MODULE_NAME "StoneFrameworkModule" CACHE STRING "Name of the WebAssembly module") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WASM_FLAGS}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WASM_FLAGS}") + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --js-library ${STONE_SOURCES_DIR}/Applications/Samples/samples-library.js --js-library ${STONE_SOURCES_DIR}/Platforms/Wasm/WasmWebService.js --js-library ${STONE_SOURCES_DIR}/Platforms/Wasm/default-library.js -s EXTRA_EXPORTED_RUNTIME_METHODS='[\"ccall\", \"cwrap\"]'") + + # Handling of memory + #set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s ALLOW_MEMORY_GROWTH=1") # Resize + #set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s TOTAL_MEMORY=536870912") # 512MB + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s EXPORT_NAME='\"${WASM_MODULE_NAME}\"' -s ALLOW_MEMORY_GROWTH=1 -s TOTAL_MEMORY=536870912 -s TOTAL_STACK=128000000") # 512MB + resize + #set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s ALLOW_MEMORY_GROWTH=1 -s TOTAL_MEMORY=1073741824") # 1GB + resize + + # To debug exceptions + #set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s DEMANGLE_SUPPORT=1 -s ASSERTIONS=2") + + add_definitions(-DORTHANC_ENABLE_WASM=1) + set(ORTHANC_SANDBOXED ON) + +elseif (ENABLE_QT OR ENABLE_SDL) + + set(ENABLE_NATIVE ON) + set(ORTHANC_SANDBOXED OFF) + set(ENABLE_CRYPTO_OPTIONS ON) + set(ENABLE_GOOGLE_TEST ON) + set(ENABLE_WEB_CLIENT ON) + +endif() + +##################################################################### +## Configuration for Orthanc +##################################################################### + +# include(../../Resources/CMake/Version.cmake) + +if (ORTHANC_STONE_VERSION STREQUAL "mainline") + set(ORTHANC_FRAMEWORK_VERSION "mainline") + set(ORTHANC_FRAMEWORK_DEFAULT_SOURCE "hg") +else() + set(ORTHANC_FRAMEWORK_VERSION "1.4.1") + set(ORTHANC_FRAMEWORK_DEFAULT_SOURCE "web") +endif() + +set(ORTHANC_FRAMEWORK_SOURCE "${ORTHANC_FRAMEWORK_DEFAULT_SOURCE}" CACHE STRING "Source of the Orthanc source code (can be \"hg\", \"archive\", \"web\" or \"path\")") +set(ORTHANC_FRAMEWORK_ARCHIVE "" CACHE STRING "Path to the Orthanc archive, if ORTHANC_FRAMEWORK_SOURCE is \"archive\"") +set(ORTHANC_FRAMEWORK_ROOT "" CACHE STRING "Path to the Orthanc source directory, if ORTHANC_FRAMEWORK_SOURCE is \"path\"") + + +##################################################################### +## Build a static library containing the Orthanc Stone framework +##################################################################### + + +LIST(APPEND ORTHANC_BOOST_COMPONENTS program_options) + +include(../../Resources/CMake/OrthancStoneConfiguration.cmake) + +add_library(OrthancStone STATIC + ${ORTHANC_STONE_SOURCES} + ) + +##################################################################### +## Build all the sample applications +##################################################################### + +include_directories(${ORTHANC_STONE_ROOT}) + +# files common to all samples +list(APPEND SAMPLE_APPLICATIONS_SOURCES + ${ORTHANC_STONE_ROOT}/Applications/Samples/SampleInteractor.h + ${ORTHANC_STONE_ROOT}/Applications/Samples/SampleApplicationBase.h + ) + +if (ENABLE_QT) + list(APPEND SAMPLE_APPLICATIONS_SOURCES + ${ORTHANC_STONE_ROOT}/Applications/Samples/Qt/SampleQtApplicationRunner.h + ${ORTHANC_STONE_ROOT}/Applications/Samples/Qt/SampleMainWindow.cpp + ${ORTHANC_STONE_ROOT}/Applications/Samples/Qt/SampleMainWindowWithButtons.cpp + ) + + ORTHANC_QT_WRAP_UI(SAMPLE_APPLICATIONS_SOURCES + ${ORTHANC_STONE_ROOT}/Applications/Samples/Qt/SampleMainWindow.ui + ${ORTHANC_STONE_ROOT}/Applications/Samples/Qt/SampleMainWindowWithButtons.ui + ) + + ORTHANC_QT_WRAP_CPP(SAMPLE_APPLICATIONS_SOURCES + ${ORTHANC_STONE_ROOT}/Applications/Qt/QCairoWidget.h + ${ORTHANC_STONE_ROOT}/Applications/Qt/QStoneMainWindow.h + ${ORTHANC_STONE_ROOT}/Applications/Samples/Qt/SampleMainWindow.h + ${ORTHANC_STONE_ROOT}/Applications/Samples/Qt/SampleMainWindowWithButtons.h + ) +endif() + +if (ENABLE_NATIVE) + list(APPEND SAMPLE_APPLICATIONS_SOURCES + ${ORTHANC_STONE_ROOT}/Applications/Samples/SampleMainNative.cpp + ) + +elseif (ENABLE_WASM) + + list(APPEND SAMPLE_APPLICATIONS_SOURCES + ${ORTHANC_STONE_ROOT}/Applications/Samples/SampleMainWasm.cpp + ${STONE_WASM_SOURCES} + ) +endif() + + +macro(BuildSingleFileSample Target Header Sample) + add_executable(${Target} + ${ORTHANC_STONE_ROOT}/Applications/Samples/${Header} + ${SAMPLE_APPLICATIONS_SOURCES} + ) + set_target_properties(${Target} PROPERTIES COMPILE_DEFINITIONS ORTHANC_STONE_SAMPLE=${Sample}) + target_link_libraries(${Target} OrthancStone) +endmacro() + +#BuildSingleFileSample(OrthancStoneEmpty EmptyApplication.h 1) +#BuildSingleFileSample(OrthancStoneTestPattern TestPatternApplication.h 2) +BuildSingleFileSample(OrthancStoneSingleFrame SingleFrameApplication.h 3) +#BuildSingleFileSample(OrthancStoneSingleVolume SingleVolumeApplication.h 4) +#BuildSingleFileSample(OrthancStoneBasicPetCtFusion 5) +#BuildSingleFileSample(OrthancStoneSynchronizedSeries 6) +#BuildSingleFileSample(OrthancStoneLayoutPetCtFusion 7) +BuildSingleFileSample(OrthancStoneSimpleViewerSingleFile SimpleViewerApplicationSingleFile.h 8) # we keep that one just as a sample before we convert another sample to this pattern +BuildSingleFileSample(OrthancStoneSingleFrameEditor SingleFrameEditorApplication.h 9) + +##### SimpleViewer sample (Qt and WASM only) ####### + +if (ENABLE_QT OR ENABLE_WASM) + + if (ENABLE_QT) + list(APPEND SIMPLE_VIEWER_APPLICATION_SOURCES + ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/Qt/SimpleViewerMainWindow.cpp + ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/Qt/SimpleViewerMainWindow.ui + ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/Qt/mainQt.cpp + ) + + ORTHANC_QT_WRAP_UI(SIMPLE_VIEWER_APPLICATION_SOURCES + ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/Qt/SimpleViewerMainWindow.ui + ) + + ORTHANC_QT_WRAP_CPP(SIMPLE_VIEWER_APPLICATION_SOURCES + ${ORTHANC_STONE_ROOT}/Applications/Qt/QCairoWidget.h + ${ORTHANC_STONE_ROOT}/Applications/Qt/QStoneMainWindow.h + ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/Qt/SimpleViewerMainWindow.h + ) + +elseif (ENABLE_WASM) + list(APPEND SIMPLE_VIEWER_APPLICATION_SOURCES + ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/Wasm/mainWasm.cpp + ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/Wasm/SimpleViewerWasmApplicationAdapter.cpp + ${STONE_WASM_SOURCES} + ) + endif() + + add_executable(OrthancStoneSimpleViewer + ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/SimpleViewerApplication.cpp + ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/ThumbnailInteractor.cpp + ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/MainWidgetInteractor.cpp + ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/AppStatus.h + ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/Messages.h + ${SIMPLE_VIEWER_APPLICATION_SOURCES} + ) + target_link_libraries(OrthancStoneSimpleViewer OrthancStone) + +endif() + +##################################################################### +## Build the unit tests +##################################################################### + +if (ENABLE_NATIVE) + add_executable(UnitTests + ${GOOGLE_TEST_SOURCES} + ${ORTHANC_STONE_ROOT}/UnitTestsSources/TestCommands.cpp + ${ORTHANC_STONE_ROOT}/UnitTestsSources/TestExceptions.cpp + ${ORTHANC_STONE_ROOT}/UnitTestsSources/TestMessageBroker.cpp + ${ORTHANC_STONE_ROOT}/UnitTestsSources/TestMessageBroker2.cpp + ${ORTHANC_STONE_ROOT}/UnitTestsSources/UnitTestsMain.cpp + ) + + target_link_libraries(UnitTests OrthancStone) +endif() + +##################################################################### +## Generate the documentation if Doxygen is present +##################################################################### + +find_package(Doxygen) +if (DOXYGEN_FOUND) + configure_file( + ${ORTHANC_STONE_ROOT}/Resources/OrthancStone.doxygen + ${CMAKE_CURRENT_BINARY_DIR}/OrthancStone.doxygen + @ONLY) + + add_custom_target(doc + ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/OrthancStone.doxygen + COMMENT "Generating documentation with Doxygen" VERBATIM + ) +else() + message("Doxygen not found. The documentation will not be built.") +endif()
--- a/Applications/Samples/EmptyApplication.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Applications/Samples/EmptyApplication.h Mon Nov 05 10:05:33 2018 +0100 @@ -32,7 +32,7 @@ class EmptyApplication : public SampleApplicationBase { public: - virtual void DeclareCommandLineOptions(boost::program_options::options_description& options) + virtual void DeclareStartupOptions(boost::program_options::options_description& options) { boost::program_options::options_description generic("Sample options"); generic.add_options() @@ -44,15 +44,14 @@ options.add(generic); } - virtual void Initialize(BasicApplicationContext& context, - IStatusBar& statusBar, + virtual void Initialize(IStatusBar& statusBar, const boost::program_options::variables_map& parameters) { int red = parameters["red"].as<int>(); int green = parameters["green"].as<int>(); int blue = parameters["blue"].as<int>(); - context.SetCentralWidget(new EmptyWidget(red, green, blue)); + context_->SetCentralWidget(new EmptyWidget(red, green, blue)); } }; }
--- a/Applications/Samples/LayoutPetCtFusionApplication.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Applications/Samples/LayoutPetCtFusionApplication.h Mon Nov 05 10:05:33 2018 +0100 @@ -89,7 +89,7 @@ { if (key == 's') { - that_.SetDefaultView(); + that_.FitContent(); } } }; @@ -109,11 +109,11 @@ LayeredSceneWidget* fusionSagittal_; - void SetDefaultView() + void FitContent() { - petAxial_->SetDefaultView(); - petCoronal_->SetDefaultView(); - petSagittal_->SetDefaultView(); + petAxial_->FitContent(); + petCoronal_->FitContent(); + petSagittal_->FitContent(); } @@ -361,7 +361,7 @@ virtual void NotifySizeChange(const WorldSceneWidget& source, ViewportGeometry& view) { - view.SetDefaultView(); + view.FitContent(); } virtual void NotifyViewChange(const WorldSceneWidget& source,
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Qt/SampleMainWindow.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,50 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#include "SampleMainWindow.h" + +/** + * Don't use "ui_MainWindow.h" instead of <ui_MainWindow.h> below, as + * this makes CMake unable to detect when the UI file changes. + **/ +#include <ui_SampleMainWindow.h> +#include "../../Applications/Samples/SampleApplicationBase.h" + +namespace OrthancStone +{ + namespace Samples + { + + SampleMainWindow::SampleMainWindow(OrthancStone::NativeStoneApplicationContext& context, OrthancStone::Samples::SampleSingleCanvasApplicationBase& stoneSampleApplication, QWidget *parent) : + QStoneMainWindow(context, parent), + ui_(new Ui::SampleMainWindow), + stoneSampleApplication_(stoneSampleApplication) + { + ui_->setupUi(this); + SetCentralStoneWidget(ui_->cairoCentralWidget); + } + + SampleMainWindow::~SampleMainWindow() + { + delete ui_; + } + + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Qt/SampleMainWindow.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,50 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ +#pragma once + +#include "../../Qt/QCairoWidget.h" +#include "../../Qt/QStoneMainWindow.h" + +namespace Ui +{ + class SampleMainWindow; +} + +namespace OrthancStone +{ + namespace Samples + { + + class SampleSingleCanvasApplicationBase; + + class SampleMainWindow : public QStoneMainWindow + { + Q_OBJECT + + private: + Ui::SampleMainWindow* ui_; + SampleSingleCanvasApplicationBase& stoneSampleApplication_; + + public: + explicit SampleMainWindow(OrthancStone::NativeStoneApplicationContext& context, SampleSingleCanvasApplicationBase& stoneSampleApplication, QWidget *parent = 0); + ~SampleMainWindow(); + }; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Qt/SampleMainWindow.ui Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,84 @@ +<?xml version="1.0" encoding="UTF-8"?> +<ui version="4.0"> + <class>SampleMainWindow</class> + <widget class="QMainWindow" name="SampleMainWindow"> + <property name="geometry"> + <rect> + <x>0</x> + <y>0</y> + <width>903</width> + <height>634</height> + </rect> + </property> + <property name="minimumSize"> + <size> + <width>500</width> + <height>300</height> + </size> + </property> + <property name="baseSize"> + <size> + <width>500</width> + <height>300</height> + </size> + </property> + <property name="windowTitle"> + <string>Stone of Orthanc</string> + </property> + <property name="layoutDirection"> + <enum>Qt::LeftToRight</enum> + </property> + <widget class="QWidget" name="centralwidget"> + <property name="sizePolicy"> + <sizepolicy hsizetype="Preferred" vsizetype="Preferred"> + <horstretch>0</horstretch> + <verstretch>0</verstretch> + </sizepolicy> + </property> + <property name="layoutDirection"> + <enum>Qt::LeftToRight</enum> + </property> + <layout class="QVBoxLayout" name="verticalLayout_2" stretch="0"> + <property name="sizeConstraint"> + <enum>QLayout::SetDefaultConstraint</enum> + </property> + <item> + <widget class="QCairoWidget" name="cairoCentralWidget"> + <property name="minimumSize"> + <size> + <width>0</width> + <height>500</height> + </size> + </property> + </widget> + </item> + </layout> + </widget> + <widget class="QMenuBar" name="menubar"> + <property name="geometry"> + <rect> + <x>0</x> + <y>0</y> + <width>903</width> + <height>22</height> + </rect> + </property> + <widget class="QMenu" name="menuTest"> + <property name="title"> + <string>Test</string> + </property> + </widget> + <addaction name="menuTest"/> + </widget> + <widget class="QStatusBar" name="statusbar"/> + </widget> + <customwidgets> + <customwidget> + <class>QCairoWidget</class> + <extends>QGraphicsView</extends> + <header location="global">QCairoWidget.h</header> + </customwidget> + </customwidgets> + <resources/> + <connections/> +</ui>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Qt/SampleMainWindowWithButtons.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,93 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#include "SampleMainWindow.h" + +/** + * Don't use "ui_MainWindow.h" instead of <ui_MainWindow.h> below, as + * this makes CMake unable to detect when the UI file changes. + **/ +#include <ui_SampleMainWindowWithButtons.h> +#include "../../Applications/Samples/SampleApplicationBase.h" + +namespace OrthancStone +{ + namespace Samples + { + + SampleMainWindowWithButtons::SampleMainWindowWithButtons(OrthancStone::NativeStoneApplicationContext& context, OrthancStone::Samples::SampleSingleCanvasWithButtonsApplicationBase& stoneSampleApplication, QWidget *parent) : + QStoneMainWindow(context, parent), + ui_(new Ui::SampleMainWindowWithButtons), + stoneSampleApplication_(stoneSampleApplication) + { + ui_->setupUi(this); + SetCentralStoneWidget(ui_->cairoCentralWidget); + +#if QT_VERSION >= 0x050000 + connect(ui_->toolButton1, &QToolButton::clicked, this, &SampleMainWindowWithButtons::tool1Clicked); + connect(ui_->toolButton2, &QToolButton::clicked, this, &SampleMainWindowWithButtons::tool2Clicked); + connect(ui_->pushButton1, &QPushButton::clicked, this, &SampleMainWindowWithButtons::pushButton1Clicked); + connect(ui_->pushButton1, &QPushButton::clicked, this, &SampleMainWindowWithButtons::pushButton2Clicked); +#else + connect(ui_->toolButton1, SIGNAL(clicked()), this, SLOT(tool1Clicked())); + connect(ui_->toolButton2, SIGNAL(clicked()), this, SLOT(tool2Clicked())); + connect(ui_->pushButton1, SIGNAL(clicked()), this, SLOT(pushButton1Clicked())); + connect(ui_->pushButton1, SIGNAL(clicked()), this, SLOT(pushButton2Clicked())); +#endif + + std::string pushButton1Name; + std::string pushButton2Name; + std::string tool1Name; + std::string tool2Name; + stoneSampleApplication_.GetButtonNames(pushButton1Name, pushButton2Name, tool1Name, tool2Name); + + ui_->toolButton1->setText(QString::fromStdString(tool1Name)); + ui_->toolButton2->setText(QString::fromStdString(tool2Name)); + ui_->pushButton1->setText(QString::fromStdString(pushButton1Name)); + ui_->pushButton2->setText(QString::fromStdString(pushButton2Name)); + } + + SampleMainWindowWithButtons::~SampleMainWindowWithButtons() + { + delete ui_; + } + + void SampleMainWindowWithButtons::tool1Clicked() + { + stoneSampleApplication_.OnTool1Clicked(); + } + + void SampleMainWindowWithButtons::tool2Clicked() + { + stoneSampleApplication_.OnTool2Clicked(); + } + + void SampleMainWindowWithButtons::pushButton1Clicked() + { + stoneSampleApplication_.OnPushButton1Clicked(); + } + + void SampleMainWindowWithButtons::pushButton2Clicked() + { + stoneSampleApplication_.OnPushButton2Clicked(); + } + + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Qt/SampleMainWindowWithButtons.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,56 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ +#pragma once + +#include "../../Qt/QCairoWidget.h" +#include "../../Qt/QStoneMainWindow.h" + +namespace Ui +{ + class SampleMainWindowWithButtons; +} + +namespace OrthancStone +{ + namespace Samples + { + + class SampleSingleCanvasWithButtonsApplicationBase; + + class SampleMainWindowWithButtons : public QStoneMainWindow + { + Q_OBJECT + + private: + Ui::SampleMainWindowWithButtons* ui_; + SampleSingleCanvasWithButtonsApplicationBase& stoneSampleApplication_; + + public: + explicit SampleMainWindowWithButtons(OrthancStone::NativeStoneApplicationContext& context, SampleSingleCanvasWithButtonsApplicationBase& stoneSampleApplication, QWidget *parent = 0); + ~SampleMainWindowWithButtons(); + + private slots: + void tool1Clicked(); + void tool2Clicked(); + void pushButton1Clicked(); + void pushButton2Clicked(); + }; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Qt/SampleMainWindowWithButtons.ui Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,130 @@ +<?xml version="1.0" encoding="UTF-8"?> +<ui version="4.0"> + <class>SampleMainWindowWithButtons</class> + <widget class="QMainWindow" name="SampleMainWindowWithButtons"> + <property name="geometry"> + <rect> + <x>0</x> + <y>0</y> + <width>903</width> + <height>634</height> + </rect> + </property> + <property name="minimumSize"> + <size> + <width>500</width> + <height>300</height> + </size> + </property> + <property name="baseSize"> + <size> + <width>500</width> + <height>300</height> + </size> + </property> + <property name="windowTitle"> + <string>Stone of Orthanc</string> + </property> + <property name="layoutDirection"> + <enum>Qt::LeftToRight</enum> + </property> + <widget class="QWidget" name="centralwidget"> + <property name="sizePolicy"> + <sizepolicy hsizetype="Preferred" vsizetype="Preferred"> + <horstretch>0</horstretch> + <verstretch>0</verstretch> + </sizepolicy> + </property> + <property name="layoutDirection"> + <enum>Qt::LeftToRight</enum> + </property> + <layout class="QVBoxLayout" name="verticalLayout_2" stretch="0,0"> + <property name="sizeConstraint"> + <enum>QLayout::SetDefaultConstraint</enum> + </property> + <item> + <widget class="QCairoWidget" name="cairoCentralWidget"> + <property name="minimumSize"> + <size> + <width>0</width> + <height>500</height> + </size> + </property> + </widget> + </item> + <item> + <widget class="QGroupBox" name="horizontalGroupBox"> + <property name="minimumSize"> + <size> + <width>0</width> + <height>100</height> + </size> + </property> + <property name="maximumSize"> + <size> + <width>16777215</width> + <height>100</height> + </size> + </property> + <layout class="QHBoxLayout" name="horizontalLayout"> + <item> + <widget class="QToolButton" name="toolButton1"> + <property name="text"> + <string>tool1</string> + </property> + </widget> + </item> + <item> + <widget class="QToolButton" name="toolButton2"> + <property name="text"> + <string>tool2</string> + </property> + </widget> + </item> + <item> + <widget class="QPushButton" name="pushButton1"> + <property name="text"> + <string>action1</string> + </property> + </widget> + </item> + <item> + <widget class="QPushButton" name="pushButton2"> + <property name="text"> + <string>action2</string> + </property> + </widget> + </item> + </layout> + </widget> + </item> + </layout> + </widget> + <widget class="QMenuBar" name="menubar"> + <property name="geometry"> + <rect> + <x>0</x> + <y>0</y> + <width>903</width> + <height>22</height> + </rect> + </property> + <widget class="QMenu" name="menuTest"> + <property name="title"> + <string>Test</string> + </property> + </widget> + <addaction name="menuTest"/> + </widget> + <widget class="QStatusBar" name="statusbar"/> + </widget> + <customwidgets> + <customwidget> + <class>QCairoWidget</class> + <extends>QGraphicsView</extends> + <header location="global">QCairoWidget.h</header> + </customwidget> + </customwidgets> + <resources/> + <connections/> +</ui>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Qt/SampleQtApplicationRunner.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,50 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "../../Qt/QtStoneApplicationRunner.h" + +#if ORTHANC_ENABLE_QT != 1 +#error this file shall be included only with the ORTHANC_ENABLE_QT set to 1 +#endif + +namespace OrthancStone +{ + namespace Samples + { + class SampleQtApplicationRunner : public OrthancStone::QtStoneApplicationRunner + { + protected: + virtual void InitializeMainWindow(OrthancStone::NativeStoneApplicationContext& context) + { + window_.reset(application_.CreateQtMainWindow()); + } + public: + SampleQtApplicationRunner(MessageBroker& broker, + SampleApplicationBase& application) + : OrthancStone::QtStoneApplicationRunner(broker, application) + { + } + + }; + } +}
--- a/Applications/Samples/SampleApplicationBase.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Applications/Samples/SampleApplicationBase.h Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -21,27 +21,100 @@ #pragma once -#include "../IBasicApplication.h" +#include "../../Applications/IStoneApplication.h" +#include "../../Framework/Widgets/WorldSceneWidget.h" + +#if ORTHANC_ENABLE_WASM==1 +#include "../../Platforms/Wasm/WasmPlatformApplicationAdapter.h" +#include "../../Platforms/Wasm/Defaults.h" +#endif + +#if ORTHANC_ENABLE_QT==1 +#include "Qt/SampleMainWindow.h" +#include "Qt/SampleMainWindowWithButtons.h" +#endif namespace OrthancStone { namespace Samples { - class SampleApplicationBase : public IBasicApplication + class SampleApplicationBase : public IStoneApplication { + protected: + BaseCommandBuilder commandBuilder_; + WorldSceneWidget* mainWidget_; // ownership is transfered to the application context + public: + virtual void Initialize(StoneApplicationContext* context, + IStatusBar& statusBar, + const boost::program_options::variables_map& parameters) + { + } + virtual std::string GetTitle() const { return "Stone of Orthanc - Sample"; } - virtual void DeclareCommandLineOptions(boost::program_options::options_description& options) + virtual BaseCommandBuilder& GetCommandBuilder() {return commandBuilder_;} + + virtual void Finalize() {} + virtual IWidget* GetCentralWidget() {return mainWidget_;} + +#if ORTHANC_ENABLE_WASM==1 + // default implementations for a single canvas named "canvas" in the HTML and an emtpy WasmApplicationAdapter + + virtual void InitializeWasm() { + AttachWidgetToWasmViewport("canvas", mainWidget_); } - virtual void Finalize() + virtual WasmPlatformApplicationAdapter* CreateWasmApplicationAdapter(MessageBroker& broker) { + return new WasmPlatformApplicationAdapter(broker, *this); } +#endif + + }; + + // this application actually works in Qt and WASM + class SampleSingleCanvasWithButtonsApplicationBase : public SampleApplicationBase + { +public: + virtual void OnPushButton1Clicked() {} + virtual void OnPushButton2Clicked() {} + virtual void OnTool1Clicked() {} + virtual void OnTool2Clicked() {} + + virtual void GetButtonNames(std::string& pushButton1, + std::string& pushButton2, + std::string& tool1, + std::string& tool2 + ) { + pushButton1 = "action1"; + pushButton2 = "action2"; + tool1 = "tool1"; + tool2 = "tool2"; + } + +#if ORTHANC_ENABLE_QT==1 + virtual QStoneMainWindow* CreateQtMainWindow() { + return new SampleMainWindowWithButtons(dynamic_cast<OrthancStone::NativeStoneApplicationContext&>(*context_), *this); + } +#endif + + }; + + // this application actually works in SDL and WASM + class SampleSingleCanvasApplicationBase : public SampleApplicationBase + { +public: + +#if ORTHANC_ENABLE_QT==1 + virtual QStoneMainWindow* CreateQtMainWindow() { + return new SampleMainWindow(dynamic_cast<OrthancStone::NativeStoneApplicationContext&>(*context_), *this); + } +#endif }; } }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SampleList.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,41 @@ +// The macro "ORTHANC_STONE_SAMPLE" must be set by the CMake script + +#if ORTHANC_STONE_SAMPLE == 1 +#include "EmptyApplication.h" +typedef OrthancStone::Samples::EmptyApplication SampleApplication; + +#elif ORTHANC_STONE_SAMPLE == 2 +#include "TestPatternApplication.h" +typedef OrthancStone::Samples::TestPatternApplication SampleApplication; + +#elif ORTHANC_STONE_SAMPLE == 3 +#include "SingleFrameApplication.h" +typedef OrthancStone::Samples::SingleFrameApplication SampleApplication; + +#elif ORTHANC_STONE_SAMPLE == 4 +#include "SingleVolumeApplication.h" +typedef OrthancStone::Samples::SingleVolumeApplication SampleApplication; + +#elif ORTHANC_STONE_SAMPLE == 5 +#include "BasicPetCtFusionApplication.h" +typedef OrthancStone::Samples::BasicPetCtFusionApplication SampleApplication; + +#elif ORTHANC_STONE_SAMPLE == 6 +#include "SynchronizedSeriesApplication.h" +typedef OrthancStone::Samples::SynchronizedSeriesApplication SampleApplication; + +#elif ORTHANC_STONE_SAMPLE == 7 +#include "LayoutPetCtFusionApplication.h" +typedef OrthancStone::Samples::LayoutPetCtFusionApplication SampleApplication; + +#elif ORTHANC_STONE_SAMPLE == 8 +#include "SimpleViewerApplicationSingleFile.h" +typedef OrthancStone::Samples::SimpleViewerApplication SampleApplication; + +#elif ORTHANC_STONE_SAMPLE == 9 +#include "SingleFrameEditorApplication.h" +typedef OrthancStone::Samples::SingleFrameEditorApplication SampleApplication; + +#else +#error Please set the ORTHANC_STONE_SAMPLE macro +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SampleMainNative.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,44 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#include "SampleList.h" +#if ORTHANC_ENABLE_SDL==1 +#include "../Sdl/SdlStoneApplicationRunner.h" +#endif +#if ORTHANC_ENABLE_QT==1 +#include "Qt/SampleQtApplicationRunner.h" +#endif +#include "../../Framework/Messages/MessageBroker.h" + +int main(int argc, char* argv[]) +{ + OrthancStone::MessageBroker broker; + SampleApplication sampleStoneApplication(broker); + +#if ORTHANC_ENABLE_SDL==1 + OrthancStone::SdlStoneApplicationRunner sdlApplicationRunner(broker, sampleStoneApplication); + return sdlApplicationRunner.Execute(argc, argv); +#endif +#if ORTHANC_ENABLE_QT==1 + OrthancStone::Samples::SampleQtApplicationRunner qtAppRunner(broker, sampleStoneApplication); + return qtAppRunner.Execute(argc, argv); +#endif +}
--- a/Applications/Samples/SampleMainSdl.cpp Mon Nov 05 10:04:56 2018 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,62 +0,0 @@ -/** - * Stone of Orthanc - * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics - * Department, University Hospital of Liege, Belgium - * Copyright (C) 2017-2018 Osimis S.A., Belgium - * - * This program is free software: you can redistribute it and/or - * modify it under the terms of the GNU Affero General Public License - * as published by the Free Software Foundation, either version 3 of - * the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - **/ - - -// The macro "ORTHANC_STONE_SAMPLE" must be set by the CMake script - -#if ORTHANC_STONE_SAMPLE == 1 -#include "EmptyApplication.h" -typedef OrthancStone::Samples::EmptyApplication Application; - -#elif ORTHANC_STONE_SAMPLE == 2 -#include "TestPatternApplication.h" -typedef OrthancStone::Samples::TestPatternApplication Application; - -#elif ORTHANC_STONE_SAMPLE == 3 -#include "SingleFrameApplication.h" -typedef OrthancStone::Samples::SingleFrameApplication Application; - -#elif ORTHANC_STONE_SAMPLE == 4 -#include "SingleVolumeApplication.h" -typedef OrthancStone::Samples::SingleVolumeApplication Application; - -#elif ORTHANC_STONE_SAMPLE == 5 -#include "BasicPetCtFusionApplication.h" -typedef OrthancStone::Samples::BasicPetCtFusionApplication Application; - -#elif ORTHANC_STONE_SAMPLE == 6 -#include "SynchronizedSeriesApplication.h" -typedef OrthancStone::Samples::SynchronizedSeriesApplication Application; - -#elif ORTHANC_STONE_SAMPLE == 7 -#include "LayoutPetCtFusionApplication.h" -typedef OrthancStone::Samples::LayoutPetCtFusionApplication Application; - -#else -#error Please set the ORTHANC_STONE_SAMPLE macro -#endif - - -int main(int argc, char* argv[]) -{ - Application application; - - return OrthancStone::IBasicApplication::ExecuteWithSdl(application, argc, argv); -}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SampleMainWasm.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,37 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#include "Platforms/Wasm/WasmWebService.h" +#include "Platforms/Wasm/WasmViewport.h" + +#include <emscripten/emscripten.h> + +#include "SampleList.h" + + +OrthancStone::IStoneApplication* CreateUserApplication(OrthancStone::MessageBroker& broker) +{ + return new SampleApplication(broker); +} + +OrthancStone::WasmPlatformApplicationAdapter* CreateWasmApplicationAdapter(OrthancStone::MessageBroker& broker, OrthancStone::IStoneApplication* application) +{ + return dynamic_cast<SampleApplication*>(application)->CreateWasmApplicationAdapter(broker); +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/AppStatus.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,27 @@ +#pragma once + +#include <string> + + +namespace SimpleViewer +{ + struct AppStatus + { + std::string patientId; + std::string studyDescription; + std::string currentInstanceIdInMainViewport; + // note: if you add members here, update the serialization code below and deserialization in simple-viewer.ts -> onAppStatusUpdated() + + + AppStatus() + { + } + + void ToJson(Json::Value &output) const + { + output["patientId"] = patientId; + output["studyDescription"] = studyDescription; + output["currentInstanceIdInMainViewport"] = currentInstanceIdInMainViewport; + } + }; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/MainWidgetInteractor.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,111 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#include "MainWidgetInteractor.h" + +#include "SimpleViewerApplication.h" + +namespace SimpleViewer { + + IWorldSceneMouseTracker* MainWidgetInteractor::CreateMouseTracker(WorldSceneWidget& widget, + const ViewportGeometry& view, + MouseButton button, + KeyboardModifiers modifiers, + int viewportX, + int viewportY, + double x, + double y, + IStatusBar* statusBar) + { + if (button == MouseButton_Left) + { + if (application_.GetCurrentTool() == SimpleViewerApplication::Tools_LineMeasure) + { + return new LineMeasureTracker(statusBar, dynamic_cast<LayerWidget&>(widget).GetSlice(), + x, y, 255, 0, 0, application_.GetFont()); + } + else if (application_.GetCurrentTool() == SimpleViewerApplication::Tools_CircleMeasure) + { + return new CircleMeasureTracker(statusBar, dynamic_cast<LayerWidget&>(widget).GetSlice(), + x, y, 255, 0, 0, application_.GetFont()); + } + else if (application_.GetCurrentTool() == SimpleViewerApplication::Tools_Crop) + { + // TODO + } + else if (application_.GetCurrentTool() == SimpleViewerApplication::Tools_Windowing) + { + // TODO + } + else if (application_.GetCurrentTool() == SimpleViewerApplication::Tools_Zoom) + { + // TODO + } + else if (application_.GetCurrentTool() == SimpleViewerApplication::Tools_Pan) + { + // TODO + } + + } + return NULL; + } + + void MainWidgetInteractor::MouseOver(CairoContext& context, + WorldSceneWidget& widget, + const ViewportGeometry& view, + double x, + double y, + IStatusBar* statusBar) + { + if (statusBar != NULL) + { + Vector p = dynamic_cast<LayerWidget&>(widget).GetSlice().MapSliceToWorldCoordinates(x, y); + + char buf[64]; + sprintf(buf, "X = %.02f Y = %.02f Z = %.02f (in cm)", + p[0] / 10.0, p[1] / 10.0, p[2] / 10.0); + statusBar->SetMessage(buf); + } + } + + void MainWidgetInteractor::MouseWheel(WorldSceneWidget& widget, + MouseWheelDirection direction, + KeyboardModifiers modifiers, + IStatusBar* statusBar) + { + } + + void MainWidgetInteractor::KeyPressed(WorldSceneWidget& widget, + KeyboardKeys key, + char keyChar, + KeyboardModifiers modifiers, + IStatusBar* statusBar) + { + switch (keyChar) + { + case 's': + widget.FitContent(); + break; + + default: + break; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/MainWidgetInteractor.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,73 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "Framework/Widgets/IWorldSceneInteractor.h" + +using namespace OrthancStone; + +namespace SimpleViewer { + + class SimpleViewerApplication; + + class MainWidgetInteractor : public IWorldSceneInteractor + { + private: + SimpleViewerApplication& application_; + + public: + MainWidgetInteractor(SimpleViewerApplication& application) : + application_(application) + { + } + + virtual IWorldSceneMouseTracker* CreateMouseTracker(WorldSceneWidget& widget, + const ViewportGeometry& view, + MouseButton button, + KeyboardModifiers modifiers, + int viewportX, + int viewportY, + double x, + double y, + IStatusBar* statusBar); + + virtual void MouseOver(CairoContext& context, + WorldSceneWidget& widget, + const ViewportGeometry& view, + double x, + double y, + IStatusBar* statusBar); + + virtual void MouseWheel(WorldSceneWidget& widget, + MouseWheelDirection direction, + KeyboardModifiers modifiers, + IStatusBar* statusBar); + + virtual void KeyPressed(WorldSceneWidget& widget, + KeyboardKeys key, + char keyChar, + KeyboardModifiers modifiers, + IStatusBar* statusBar); + }; + + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/Messages.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,13 @@ +#pragma once + +#include "Framework/Messages/MessageType.h" + +namespace SimpleViewer +{ + enum SimpleViewerMessageType + { + SimpleViewerMessageType_First = OrthancStone::MessageType_CustomMessage, + SimpleViewerMessageType_AppStatusUpdated + + }; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/Qt/SimpleViewerMainWindow.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,106 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#include "SimpleViewerMainWindow.h" + +/** + * Don't use "ui_MainWindow.h" instead of <ui_MainWindow.h> below, as + * this makes CMake unable to detect when the UI file changes. + **/ +#include <ui_SimpleViewerMainWindow.h> +#include "../SimpleViewerApplication.h" + +namespace SimpleViewer +{ + + SimpleViewerMainWindow::SimpleViewerMainWindow(OrthancStone::NativeStoneApplicationContext& context, SimpleViewerApplication& stoneApplication, QWidget *parent) : + QStoneMainWindow(context, parent), + ui_(new Ui::SimpleViewerMainWindow), + stoneApplication_(stoneApplication) + { + ui_->setupUi(this); + SetCentralStoneWidget(ui_->cairoCentralWidget); + +#if QT_VERSION >= 0x050000 + connect(ui_->toolButtonCrop, &QToolButton::clicked, this, &SimpleViewerMainWindow::cropClicked); + connect(ui_->pushButtonUndoCrop, &QToolButton::clicked, this, &SimpleViewerMainWindow::undoCropClicked); + connect(ui_->toolButtonLine, &QToolButton::clicked, this, &SimpleViewerMainWindow::lineClicked); + connect(ui_->toolButtonCircle, &QToolButton::clicked, this, &SimpleViewerMainWindow::circleClicked); + connect(ui_->toolButtonWindowing, &QToolButton::clicked, this, &SimpleViewerMainWindow::windowingClicked); + connect(ui_->pushButtonRotate, &QPushButton::clicked, this, &SimpleViewerMainWindow::rotateClicked); + connect(ui_->pushButtonInvert, &QPushButton::clicked, this, &SimpleViewerMainWindow::invertClicked); +#else + connect(ui_->toolButtonCrop, SIGNAL(clicked()), this, SLOT(cropClicked())); + connect(ui_->toolButtonLine, SIGNAL(clicked()), this, SLOT(lineClicked())); + connect(ui_->toolButtonCircle, SIGNAL(clicked()), this, SLOT(circleClicked())); + connect(ui_->toolButtonWindowing, SIGNAL(clicked()), this, SLOT(windowingClicked())); + connect(ui_->pushButtonUndoCrop, SIGNAL(clicked()), this, SLOT(undoCropClicked())); + connect(ui_->pushButtonRotate, SIGNAL(clicked()), this, SLOT(rotateClicked())); + connect(ui_->pushButtonInvert, SIGNAL(clicked()), this, SLOT(invertClicked())); +#endif + } + + SimpleViewerMainWindow::~SimpleViewerMainWindow() + { + delete ui_; + } + + void SimpleViewerMainWindow::cropClicked() + { + GenericNoArgCommand command("selectTool:crop"); + stoneApplication_.ExecuteCommand(command); + } + + void SimpleViewerMainWindow::undoCropClicked() + { + GenericNoArgCommand command("action:undo-crop"); + stoneApplication_.ExecuteCommand(command); + } + + void SimpleViewerMainWindow::lineClicked() + { + GenericNoArgCommand command("selectTool:line-measure"); + stoneApplication_.ExecuteCommand(command); + } + + void SimpleViewerMainWindow::circleClicked() + { + GenericNoArgCommand command("selectTool:circle-measure"); + stoneApplication_.ExecuteCommand(command); + } + + void SimpleViewerMainWindow::windowingClicked() + { + GenericNoArgCommand command("selectTool:windowing"); + stoneApplication_.ExecuteCommand(command); + } + + void SimpleViewerMainWindow::rotateClicked() + { + GenericNoArgCommand command("action:rotate"); + stoneApplication_.ExecuteCommand(command); + } + + void SimpleViewerMainWindow::invertClicked() + { + GenericNoArgCommand command("action:invert"); + stoneApplication_.ExecuteCommand(command); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/Qt/SimpleViewerMainWindow.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,57 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ +#pragma once + +#include <Applications/Qt/QCairoWidget.h> +#include <Applications/Qt/QStoneMainWindow.h> + +namespace Ui +{ + class SimpleViewerMainWindow; +} + +using namespace OrthancStone; + +namespace SimpleViewer +{ + class SimpleViewerApplication; + + class SimpleViewerMainWindow : public QStoneMainWindow + { + Q_OBJECT + + private: + Ui::SimpleViewerMainWindow* ui_; + SimpleViewerApplication& stoneApplication_; + + public: + explicit SimpleViewerMainWindow(OrthancStone::NativeStoneApplicationContext& context, SimpleViewerApplication& stoneApplication, QWidget *parent = 0); + ~SimpleViewerMainWindow(); + + private slots: + void cropClicked(); + void undoCropClicked(); + void rotateClicked(); + void windowingClicked(); + void lineClicked(); + void circleClicked(); + void invertClicked(); + }; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/Qt/SimpleViewerMainWindow.ui Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,151 @@ +<?xml version="1.0" encoding="UTF-8"?> +<ui version="4.0"> + <class>SimpleViewerMainWindow</class> + <widget class="QMainWindow" name="SimpleViewerMainWindow"> + <property name="geometry"> + <rect> + <x>0</x> + <y>0</y> + <width>903</width> + <height>634</height> + </rect> + </property> + <property name="minimumSize"> + <size> + <width>500</width> + <height>300</height> + </size> + </property> + <property name="baseSize"> + <size> + <width>500</width> + <height>300</height> + </size> + </property> + <property name="windowTitle"> + <string>Stone of Orthanc</string> + </property> + <property name="layoutDirection"> + <enum>Qt::LeftToRight</enum> + </property> + <widget class="QWidget" name="centralwidget"> + <property name="sizePolicy"> + <sizepolicy hsizetype="Preferred" vsizetype="Preferred"> + <horstretch>0</horstretch> + <verstretch>0</verstretch> + </sizepolicy> + </property> + <property name="layoutDirection"> + <enum>Qt::LeftToRight</enum> + </property> + <layout class="QVBoxLayout" name="verticalLayout_2" stretch="0,0"> + <property name="sizeConstraint"> + <enum>QLayout::SetDefaultConstraint</enum> + </property> + <item> + <widget class="QCairoWidget" name="cairoCentralWidget"> + <property name="minimumSize"> + <size> + <width>0</width> + <height>500</height> + </size> + </property> + </widget> + </item> + <item> + <widget class="QGroupBox" name="horizontalGroupBox"> + <property name="minimumSize"> + <size> + <width>0</width> + <height>100</height> + </size> + </property> + <property name="maximumSize"> + <size> + <width>16777215</width> + <height>100</height> + </size> + </property> + <layout class="QHBoxLayout" name="horizontalLayout"> + <item> + <widget class="QToolButton" name="toolButtonWindowing"> + <property name="text"> + <string>windowing</string> + </property> + </widget> + </item> + <item> + <widget class="QToolButton" name="toolButtonCrop"> + <property name="text"> + <string>crop</string> + </property> + </widget> + </item> + <item> + <widget class="QPushButton" name="pushButtonUndoCrop"> + <property name="text"> + <string>undo crop</string> + </property> + </widget> + </item> + <item> + <widget class="QToolButton" name="toolButtonLine"> + <property name="text"> + <string>line</string> + </property> + </widget> + </item> + <item> + <widget class="QToolButton" name="toolButtonCircle"> + <property name="text"> + <string>circle</string> + </property> + </widget> + </item> + <item> + <widget class="QPushButton" name="pushButtonRotate"> + <property name="text"> + <string>rotate</string> + </property> + </widget> + </item> + <item> + <widget class="QPushButton" name="pushButtonInvert"> + <property name="text"> + <string>invert</string> + </property> + </widget> + </item> + </layout> + </widget> + </item> + </layout> + </widget> + <widget class="QMenuBar" name="menubar"> + <property name="geometry"> + <rect> + <x>0</x> + <y>0</y> + <width>903</width> + <height>22</height> + </rect> + </property> + <widget class="QMenu" name="menuTest"> + <property name="title"> + <string>Test</string> + </property> + </widget> + <addaction name="menuTest"/> + </widget> + <widget class="QStatusBar" name="statusbar"/> + </widget> + <customwidgets> + <customwidget> + <class>QCairoWidget</class> + <extends>QGraphicsView</extends> + <header location="global">QCairoWidget.h</header> + </customwidget> + </customwidgets> + <resources/> + <connections/> +</ui>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/Qt/mainQt.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,14 @@ +#include "Applications/Qt/QtStoneApplicationRunner.h" + +#include "../SimpleViewerApplication.h" +#include "Framework/Messages/MessageBroker.h" + + +int main(int argc, char* argv[]) +{ + OrthancStone::MessageBroker broker; + SimpleViewer::SimpleViewerApplication stoneApplication(broker); + + OrthancStone::QtStoneApplicationRunner qtAppRunner(broker, stoneApplication); + return qtAppRunner.Execute(argc, argv); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/SimpleViewerApplication.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,242 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#include "SimpleViewerApplication.h" + +#if ORTHANC_ENABLE_QT==1 +#include "Qt/SimpleViewerMainWindow.h" +#endif + +#if ORTHANC_ENABLE_WASM==1 +#include <Platforms/Wasm/WasmViewport.h> +#endif + +namespace SimpleViewer { + + void SimpleViewerApplication::Initialize(StoneApplicationContext* context, + IStatusBar& statusBar, + const boost::program_options::variables_map& parameters) + { + using namespace OrthancStone; + + context_ = context; + statusBar_ = &statusBar; + + {// initialize viewports and layout + mainLayout_ = new LayoutWidget("main-layout"); + mainLayout_->SetPadding(10); + mainLayout_->SetBackgroundCleared(true); + mainLayout_->SetBackgroundColor(0, 0, 0); + mainLayout_->SetHorizontal(); + + thumbnailsLayout_ = new LayoutWidget("thumbnail-layout"); + thumbnailsLayout_->SetPadding(10); + thumbnailsLayout_->SetBackgroundCleared(true); + thumbnailsLayout_->SetBackgroundColor(50, 50, 50); + thumbnailsLayout_->SetVertical(); + + mainWidget_ = new LayerWidget(IObserver::broker_, "main-viewport"); + //mainWidget_->RegisterObserver(*this); + + // hierarchy + mainLayout_->AddWidget(thumbnailsLayout_); + mainLayout_->AddWidget(mainWidget_); + + orthancApiClient_.reset(new OrthancApiClient(IObserver::broker_, context_->GetWebService())); + + // sources + smartLoader_.reset(new SmartLoader(IObserver::broker_, *orthancApiClient_)); + smartLoader_->SetImageQuality(SliceImageQuality_FullPam); + + mainLayout_->SetTransmitMouseOver(true); + mainWidgetInteractor_.reset(new MainWidgetInteractor(*this)); + mainWidget_->SetInteractor(*mainWidgetInteractor_); + thumbnailInteractor_.reset(new ThumbnailInteractor(*this)); + } + + statusBar.SetMessage("Use the key \"s\" to reinitialize the layout"); + statusBar.SetMessage("Use the key \"n\" to go to next image in the main viewport"); + + + if (parameters.count("studyId") < 1) + { + LOG(WARNING) << "The study ID is missing, will take the first studyId found in Orthanc"; + orthancApiClient_->GetJsonAsync("/studies", new Callable<SimpleViewerApplication, OrthancApiClient::JsonResponseReadyMessage>(*this, &SimpleViewerApplication::OnStudyListReceived)); + } + else + { + SelectStudy(parameters["studyId"].as<std::string>()); + } + } + + + void SimpleViewerApplication::DeclareStartupOptions(boost::program_options::options_description& options) + { + boost::program_options::options_description generic("Sample options"); + generic.add_options() + ("studyId", boost::program_options::value<std::string>(), + "Orthanc ID of the study") + ; + + options.add(generic); + } + + void SimpleViewerApplication::OnStudyListReceived(const OrthancApiClient::JsonResponseReadyMessage& message) + { + const Json::Value& response = message.Response; + + if (response.isArray() && response.size() > 1) + { + SelectStudy(response[0].asString()); + } + } + void SimpleViewerApplication::OnStudyReceived(const OrthancApiClient::JsonResponseReadyMessage& message) + { + const Json::Value& response = message.Response; + + if (response.isObject() && response["Series"].isArray()) + { + for (size_t i=0; i < response["Series"].size(); i++) + { + orthancApiClient_->GetJsonAsync("/series/" + response["Series"][(int)i].asString(), new Callable<SimpleViewerApplication, OrthancApiClient::JsonResponseReadyMessage>(*this, &SimpleViewerApplication::OnSeriesReceived)); + } + } + } + + void SimpleViewerApplication::OnSeriesReceived(const OrthancApiClient::JsonResponseReadyMessage& message) + { + const Json::Value& response = message.Response; + + if (response.isObject() && response["Instances"].isArray() && response["Instances"].size() > 0) + { + // keep track of all instances IDs + const std::string& seriesId = response["ID"].asString(); + seriesTags_[seriesId] = response; + instancesIdsPerSeriesId_[seriesId] = std::vector<std::string>(); + for (size_t i = 0; i < response["Instances"].size(); i++) + { + const std::string& instanceId = response["Instances"][static_cast<int>(i)].asString(); + instancesIdsPerSeriesId_[seriesId].push_back(instanceId); + } + + // load the first instance in the thumbnail + LoadThumbnailForSeries(seriesId, instancesIdsPerSeriesId_[seriesId][0]); + + // if this is the first thumbnail loaded, load the first instance in the mainWidget + if (mainWidget_->GetLayerCount() == 0) + { + smartLoader_->SetFrameInWidget(*mainWidget_, 0, instancesIdsPerSeriesId_[seriesId][0], 0); + } + } + } + + void SimpleViewerApplication::LoadThumbnailForSeries(const std::string& seriesId, const std::string& instanceId) + { + LOG(INFO) << "Loading thumbnail for series " << seriesId; + LayerWidget* thumbnailWidget = new LayerWidget(IObserver::broker_, "thumbnail-series-" + seriesId); + thumbnails_.push_back(thumbnailWidget); + thumbnailsLayout_->AddWidget(thumbnailWidget); + thumbnailWidget->RegisterObserverCallback(new Callable<SimpleViewerApplication, LayerWidget::GeometryChangedMessage>(*this, &SimpleViewerApplication::OnWidgetGeometryChanged)); + smartLoader_->SetFrameInWidget(*thumbnailWidget, 0, instanceId, 0); + thumbnailWidget->SetInteractor(*thumbnailInteractor_); + } + + void SimpleViewerApplication::SelectStudy(const std::string& studyId) + { + orthancApiClient_->GetJsonAsync("/studies/" + studyId, new Callable<SimpleViewerApplication, OrthancApiClient::JsonResponseReadyMessage>(*this, &SimpleViewerApplication::OnStudyReceived)); + } + + void SimpleViewerApplication::OnWidgetGeometryChanged(const LayerWidget::GeometryChangedMessage& message) + { + message.origin_.FitContent(); + } + + void SimpleViewerApplication::SelectSeriesInMainViewport(const std::string& seriesId) + { + smartLoader_->SetFrameInWidget(*mainWidget_, 0, instancesIdsPerSeriesId_[seriesId][0], 0); + } + + + + void SimpleViewerApplication::ExecuteCommand(ICommand& command) + { + statusBar_->SetMessage("received command: " + std::string(command.GetName())); + if (command.GetName() == "selectTool:circle-measure") + { + SelectTool(Tools_CircleMeasure); + } + else if (command.GetName() == "selectTool:line-measure") + { + SelectTool(Tools_LineMeasure); + } + else if (command.GetName() == "selectTool:crop") + { + SelectTool(Tools_Crop); + } + else if (command.GetName() == "selectTool:windowing") + { + SelectTool(Tools_Windowing); + } + else if (command.GetName() == "action:rotate") + { + ExecuteAction(Actions_Rotate); + } + else if (command.GetName() == "action:undo-crop") + { + ExecuteAction(Actions_UndoCrop); + } + else if (command.GetName() == "action:invert") + { + ExecuteAction(Actions_Invert); + } + else + { + command.Execute(); + } + } + + void SimpleViewerApplication::ExecuteAction(SimpleViewerApplication::Actions action) + { + // TODO + } + + void SimpleViewerApplication::SelectTool(SimpleViewerApplication::Tools tool) + { + currentTool_ = tool; + } + +#if ORTHANC_ENABLE_QT==1 + QStoneMainWindow* SimpleViewerApplication::CreateQtMainWindow() + { + return new SimpleViewerMainWindow(dynamic_cast<OrthancStone::NativeStoneApplicationContext&>(*context_), *this); + } +#endif + +#if ORTHANC_ENABLE_WASM==1 + void SimpleViewerApplication::InitializeWasm() { + + AttachWidgetToWasmViewport("canvasThumbnails", thumbnailsLayout_); + AttachWidgetToWasmViewport("canvasMain", mainWidget_); + } +#endif + + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/SimpleViewerApplication.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,176 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "Applications/IStoneApplication.h" + +#include "Framework/Layers/OrthancFrameLayerSource.h" +#include "Framework/Layers/CircleMeasureTracker.h" +#include "Framework/Layers/LineMeasureTracker.h" +#include "Framework/Widgets/LayerWidget.h" +#include "Framework/Widgets/LayoutWidget.h" +#include "Framework/Messages/IObserver.h" +#include "Framework/SmartLoader.h" + +#if ORTHANC_ENABLE_WASM==1 +#include "Platforms/Wasm/WasmPlatformApplicationAdapter.h" +#include "Platforms/Wasm/Defaults.h" +#endif + +#if ORTHANC_ENABLE_QT==1 +#include "Qt/SimpleViewerMainWindow.h" +#endif + +#include <Core/Images/Font.h> +#include <Core/Logging.h> + +#include "ThumbnailInteractor.h" +#include "MainWidgetInteractor.h" +#include "AppStatus.h" +#include "Messages.h" + +using namespace OrthancStone; + + +namespace SimpleViewer +{ + + class SimpleViewerApplication : + public IStoneApplication, + public IObserver, + public IObservable + { + public: + + struct StatusUpdatedMessage : public BaseMessage<SimpleViewerMessageType_AppStatusUpdated> + { + const AppStatus& status_; + + StatusUpdatedMessage(const AppStatus& status) + : BaseMessage(), + status_(status) + { + } + }; + + enum Tools { + Tools_LineMeasure, + Tools_CircleMeasure, + Tools_Crop, + Tools_Windowing, + Tools_Zoom, + Tools_Pan + }; + + enum Actions { + Actions_Rotate, + Actions_Invert, + Actions_UndoCrop + }; + + private: + Tools currentTool_; + std::unique_ptr<MainWidgetInteractor> mainWidgetInteractor_; + std::unique_ptr<ThumbnailInteractor> thumbnailInteractor_; + LayoutWidget* mainLayout_; + LayoutWidget* thumbnailsLayout_; + LayerWidget* mainWidget_; + std::vector<LayerWidget*> thumbnails_; + std::map<std::string, std::vector<std::string> > instancesIdsPerSeriesId_; + std::map<std::string, Json::Value> seriesTags_; + BaseCommandBuilder commandBuilder_; + + unsigned int currentInstanceIndex_; + OrthancStone::WidgetViewport* wasmViewport1_; + OrthancStone::WidgetViewport* wasmViewport2_; + + IStatusBar* statusBar_; + std::unique_ptr<SmartLoader> smartLoader_; + std::unique_ptr<OrthancApiClient> orthancApiClient_; + + Orthanc::Font font_; + + public: + SimpleViewerApplication(MessageBroker& broker) : + IObserver(broker), + IObservable(broker), + currentTool_(Tools_LineMeasure), + mainLayout_(NULL), + currentInstanceIndex_(0), + wasmViewport1_(NULL), + wasmViewport2_(NULL) + { + font_.LoadFromResource(Orthanc::EmbeddedResources::FONT_UBUNTU_MONO_BOLD_16); + } + + virtual void Finalize() {} + virtual IWidget* GetCentralWidget() {return mainLayout_;} + + virtual void DeclareStartupOptions(boost::program_options::options_description& options); + virtual void Initialize(StoneApplicationContext* context, + IStatusBar& statusBar, + const boost::program_options::variables_map& parameters); + + void OnStudyListReceived(const OrthancApiClient::JsonResponseReadyMessage& message); + + void OnStudyReceived(const OrthancApiClient::JsonResponseReadyMessage& message); + + void OnSeriesReceived(const OrthancApiClient::JsonResponseReadyMessage& message); + + void LoadThumbnailForSeries(const std::string& seriesId, const std::string& instanceId); + + void SelectStudy(const std::string& studyId); + + void OnWidgetGeometryChanged(const LayerWidget::GeometryChangedMessage& message); + + void SelectSeriesInMainViewport(const std::string& seriesId); + + void SelectTool(Tools tool); + + Tools GetCurrentTool() const + { + return currentTool_; + } + + const Orthanc::Font& GetFont() const + { + return font_; + } + + void ExecuteAction(Actions action); + + virtual std::string GetTitle() const {return "SimpleViewer";} + virtual void ExecuteCommand(ICommand& command); + virtual BaseCommandBuilder& GetCommandBuilder() {return commandBuilder_;} + + +#if ORTHANC_ENABLE_WASM==1 + virtual void InitializeWasm(); +#endif + +#if ORTHANC_ENABLE_QT==1 + virtual QStoneMainWindow* CreateQtMainWindow(); +#endif + }; + + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/ThumbnailInteractor.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,45 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#include "ThumbnailInteractor.h" + +#include "SimpleViewerApplication.h" + +namespace SimpleViewer { + + IWorldSceneMouseTracker* ThumbnailInteractor::CreateMouseTracker(WorldSceneWidget& widget, + const ViewportGeometry& view, + MouseButton button, + KeyboardModifiers modifiers, + int viewportX, + int viewportY, + double x, + double y, + IStatusBar* statusBar) + { + if (button == MouseButton_Left) + { + statusBar->SetMessage("selected thumbnail " + widget.GetName()); + std::string seriesId = widget.GetName().substr(strlen("thumbnail-series-")); + application_.SelectSeriesInMainViewport(seriesId); + } + return NULL; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/ThumbnailInteractor.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,76 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "Framework/Widgets/IWorldSceneInteractor.h" + +using namespace OrthancStone; + +namespace SimpleViewer { + + class SimpleViewerApplication; + + class ThumbnailInteractor : public IWorldSceneInteractor + { + private: + SimpleViewerApplication& application_; + public: + ThumbnailInteractor(SimpleViewerApplication& application) : + application_(application) + { + } + + virtual IWorldSceneMouseTracker* CreateMouseTracker(WorldSceneWidget& widget, + const ViewportGeometry& view, + MouseButton button, + KeyboardModifiers modifiers, + int viewportX, + int viewportY, + double x, + double y, + IStatusBar* statusBar); + + virtual void MouseOver(CairoContext& context, + WorldSceneWidget& widget, + const ViewportGeometry& view, + double x, + double y, + IStatusBar* statusBar) + {} + + virtual void MouseWheel(WorldSceneWidget& widget, + MouseWheelDirection direction, + KeyboardModifiers modifiers, + IStatusBar* statusBar) + {} + + virtual void KeyPressed(WorldSceneWidget& widget, + KeyboardKeys key, + char keyChar, + KeyboardModifiers modifiers, + IStatusBar* statusBar) + {} + + }; + + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/Wasm/SimpleViewerWasmApplicationAdapter.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,51 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#include "SimpleViewerWasmApplicationAdapter.h" + +namespace SimpleViewer +{ + + SimpleViewerWasmApplicationAdapter::SimpleViewerWasmApplicationAdapter(MessageBroker &broker, SimpleViewerApplication &application) + : WasmPlatformApplicationAdapter(broker, application), + viewerApplication_(application) + { + application.RegisterObserverCallback(new Callable<SimpleViewerWasmApplicationAdapter, SimpleViewerApplication::StatusUpdatedMessage>(*this, &SimpleViewerWasmApplicationAdapter::OnStatusUpdated)); + } + + void SimpleViewerWasmApplicationAdapter::OnStatusUpdated(const SimpleViewerApplication::StatusUpdatedMessage &message) + { + Json::Value statusJson; + message.status_.ToJson(statusJson); + + Json::Value event; + event["event"] = "appStatusUpdated"; + event["data"] = statusJson; + + Json::StreamWriterBuilder builder; + std::unique_ptr<Json::StreamWriter> writer(builder.newStreamWriter()); + std::ostringstream outputStr; + + writer->write(event, &outputStr); + + NotifyStatusUpdateFromCppToWeb(outputStr.str()); + } + +} // namespace SimpleViewer \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/Wasm/SimpleViewerWasmApplicationAdapter.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,43 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#pragma once + +#include <string> +#include <Framework/Messages/IObserver.h> +#include <Platforms/Wasm/WasmPlatformApplicationAdapter.h> + +#include "../SimpleViewerApplication.h" + +namespace SimpleViewer { + + class SimpleViewerWasmApplicationAdapter : public WasmPlatformApplicationAdapter + { + SimpleViewerApplication& viewerApplication_; + + public: + SimpleViewerWasmApplicationAdapter(MessageBroker& broker, SimpleViewerApplication& application); + + private: + void OnStatusUpdated(const SimpleViewerApplication::StatusUpdatedMessage& message); + + }; + +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/Wasm/mainWasm.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,38 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#include "Platforms/Wasm/WasmWebService.h" +#include "Platforms/Wasm/WasmViewport.h" + +#include <emscripten/emscripten.h> + +#include "../SimpleViewerApplication.h" +#include "SimpleViewerWasmApplicationAdapter.h" + + +OrthancStone::IStoneApplication* CreateUserApplication(OrthancStone::MessageBroker& broker) { + + return new SimpleViewer::SimpleViewerApplication(broker); +} + +OrthancStone::WasmPlatformApplicationAdapter* CreateWasmApplicationAdapter(OrthancStone::MessageBroker& broker, IStoneApplication* application) +{ + return new SimpleViewer::SimpleViewerWasmApplicationAdapter(broker, *(dynamic_cast<SimpleViewer::SimpleViewerApplication*>(application))); +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/Wasm/simple-viewer.html Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,39 @@ +<!doctype html> + +<html lang="us"> + <head> + <meta charset="utf-8" /> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> + + <!-- Disable pinch zoom on mobile devices --> + <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" /> + <meta name="HandheldFriendly" content="true" /> + + <title>Simple Viewer</title> + <link href="styles.css" rel="stylesheet" /> + +<body> + <div id="breadcrumb"> + <span id="label-patient-id"></span> + <span id="label-study-description"></span> + <span id="label-series-description"></span> + </div> + <div> + <canvas id="canvasThumbnails" data-width-ratio="20" data-height-ratio="50"></canvas> + <canvas id="canvasMain" data-width-ratio="70" data-height-ratio="50"></canvas> + </div> + <div id="toolbox"> + <button tool-selector="line-measure" class="tool-selector">line</button> + <button tool-selector="circle-measure" class="tool-selector">circle</button> + <button tool-selector="crop" class="tool-selector">crop</button> + <button tool-selector="windowing" class="tool-selector">windowing</button> + <button tool-selector="zoom" class="tool-selector">zoom</button> + <button tool-selector="pan" class="tool-selector">pan</button> + <button action-trigger="rotate-left" class="action-trigger">rotate left</button> + <button action-trigger="rotate-right" class="action-trigger">rotate right</button> + <button action-trigger="invert" class="action-trigger">invert</button> + </div> + <script type="text/javascript" src="app-simple-viewer.js"></script> +</body> + +</html> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/Wasm/simple-viewer.ts Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,75 @@ +///<reference path='../../../../Platforms/Wasm/wasm-application-runner.ts'/> + +InitializeWasmApplication("OrthancStoneSimpleViewer", "/orthanc"); + +function SelectTool(toolName: string) { + var command = { + command: "selectTool:" + toolName, + commandType: "generic-no-arg-command", + args: { + } + }; + SendMessageToStoneApplication(JSON.stringify(command)); + +} + +function PerformAction(actionName: string) { + var command = { + command: "action:" + actionName, + commandType: "generic-no-arg-command", + args: { + } + }; + SendMessageToStoneApplication(JSON.stringify(command)); +} + +class SimpleViewerUI { + + private _labelPatientId: HTMLSpanElement; + private _labelStudyDescription: HTMLSpanElement; + + public constructor() { + // install "SelectTool" handlers + document.querySelectorAll("[tool-selector]").forEach((e) => { + console.log(e); + (e as HTMLButtonElement).addEventListener("click", () => { + console.log(e); + SelectTool(e.attributes["tool-selector"].value); + }); + }); + + // install "PerformAction" handlers + document.querySelectorAll("[action-trigger]").forEach((e) => { + (e as HTMLButtonElement).addEventListener("click", () => { + PerformAction(e.attributes["action-trigger"].value); + }); + }); + + // connect all ui elements to members + this._labelPatientId = document.getElementById("label-patient-id") as HTMLSpanElement; + this._labelStudyDescription = document.getElementById("label-study-description") as HTMLSpanElement; + } + + public onAppStatusUpdated(status: any) { + this._labelPatientId.innerText = status["patientId"]; + this._labelStudyDescription.innerText = status["studyDescription"]; + // this.highlighThumbnail(status["currentInstanceIdInMainViewport"]); + } + +} + +var ui = new SimpleViewerUI(); + +// this method is called "from the C++ code" when the StoneApplication is updated. +// it can be used to update the UI of the application +function UpdateWebApplication(statusUpdateMessageString: string) { + console.log("updating web application: ", statusUpdateMessageString); + let statusUpdateMessage = JSON.parse(statusUpdateMessageString); + + if ("event" in statusUpdateMessage) { + let eventName = statusUpdateMessage["event"]; + if (eventName == "appStatusUpdated") { + ui.onAppStatusUpdated(statusUpdateMessage["data"]); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/Wasm/styles.css Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,54 @@ +html, body { + width: 100%; + height: 100%; + margin: 0px; + border: 0; + overflow: hidden; /* Disable scrollbars */ + display: block; /* No floating content on sides */ + background-color: black; + color: white; + font-family: Arial, Helvetica, sans-serif; +} + +canvas { + left:0px; + top:0px; +} + +#canvas-group { + padding:5px; + background-color: grey; +} + +#status-group { + padding:5px; +} + +#worklist-group { + padding:5px; +} + +.vsol-button { + height: 40px; +} + +#thumbnails-group ul li { + display: inline; + list-style: none; +} + +.thumbnail { + width: 100px; + height: 100px; + padding: 3px; +} + +.thumbnail-selected { + border-width: 1px; + border-color: red; + border-style: solid; +} + +#template-thumbnail-li { + display: none !important; +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewer/Wasm/tsconfig-simple-viewer.json Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,9 @@ +{ + "extends" : "../../Web/tsconfig-samples", + "compilerOptions": { + "outFile": "../../build-web/simple-viewer/app-simple-viewer.js" + }, + "include" : [ + "simple-viewer.ts" + ] +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SimpleViewerApplicationSingleFile.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,440 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "SampleApplicationBase.h" + +#include "../../Framework/Layers/OrthancFrameLayerSource.h" +#include "../../Framework/Layers/CircleMeasureTracker.h" +#include "../../Framework/Layers/LineMeasureTracker.h" +#include "../../Framework/Widgets/LayerWidget.h" +#include "../../Framework/Widgets/LayoutWidget.h" +#include "../../Framework/Messages/IObserver.h" +#include "../../Framework/SmartLoader.h" + +#if ORTHANC_ENABLE_WASM==1 +#include "../../Platforms/Wasm/WasmPlatformApplicationAdapter.h" +#include "../../Platforms/Wasm/Defaults.h" +#endif + +#include <Core/Images/Font.h> +#include <Core/Logging.h> + +namespace OrthancStone +{ + namespace Samples + { + class SimpleViewerApplication : + public SampleSingleCanvasWithButtonsApplicationBase, + public IObserver + { + private: + class ThumbnailInteractor : public IWorldSceneInteractor + { + private: + SimpleViewerApplication& application_; + public: + ThumbnailInteractor(SimpleViewerApplication& application) : + application_(application) + { + } + + virtual IWorldSceneMouseTracker* CreateMouseTracker(WorldSceneWidget& widget, + const ViewportGeometry& view, + MouseButton button, + KeyboardModifiers modifiers, + int viewportX, + int viewportY, + double x, + double y, + IStatusBar* statusBar) + { + if (button == MouseButton_Left) + { + statusBar->SetMessage("selected thumbnail " + widget.GetName()); + std::string seriesId = widget.GetName().substr(strlen("thumbnail-series-")); + application_.SelectSeriesInMainViewport(seriesId); + } + return NULL; + } + virtual void MouseOver(CairoContext& context, + WorldSceneWidget& widget, + const ViewportGeometry& view, + double x, + double y, + IStatusBar* statusBar) + {} + + virtual void MouseWheel(WorldSceneWidget& widget, + MouseWheelDirection direction, + KeyboardModifiers modifiers, + IStatusBar* statusBar) + {} + + virtual void KeyPressed(WorldSceneWidget& widget, + KeyboardKeys key, + char keyChar, + KeyboardModifiers modifiers, + IStatusBar* statusBar) + {} + + }; + + class MainWidgetInteractor : public IWorldSceneInteractor + { + private: + SimpleViewerApplication& application_; + + public: + MainWidgetInteractor(SimpleViewerApplication& application) : + application_(application) + { + } + + virtual IWorldSceneMouseTracker* CreateMouseTracker(WorldSceneWidget& widget, + const ViewportGeometry& view, + MouseButton button, + KeyboardModifiers modifiers, + int viewportX, + int viewportY, + double x, + double y, + IStatusBar* statusBar) + { + if (button == MouseButton_Left) + { + if (application_.currentTool_ == Tools_LineMeasure) + { + return new LineMeasureTracker(statusBar, dynamic_cast<LayerWidget&>(widget).GetSlice(), + x, y, 255, 0, 0, application_.GetFont()); + } + else if (application_.currentTool_ == Tools_CircleMeasure) + { + return new CircleMeasureTracker(statusBar, dynamic_cast<LayerWidget&>(widget).GetSlice(), + x, y, 255, 0, 0, application_.GetFont()); + } + } + return NULL; + } + + virtual void MouseOver(CairoContext& context, + WorldSceneWidget& widget, + const ViewportGeometry& view, + double x, + double y, + IStatusBar* statusBar) + { + if (statusBar != NULL) + { + Vector p = dynamic_cast<LayerWidget&>(widget).GetSlice().MapSliceToWorldCoordinates(x, y); + + char buf[64]; + sprintf(buf, "X = %.02f Y = %.02f Z = %.02f (in cm)", + p[0] / 10.0, p[1] / 10.0, p[2] / 10.0); + statusBar->SetMessage(buf); + } + } + + virtual void MouseWheel(WorldSceneWidget& widget, + MouseWheelDirection direction, + KeyboardModifiers modifiers, + IStatusBar* statusBar) + { + } + + virtual void KeyPressed(WorldSceneWidget& widget, + KeyboardKeys key, + char keyChar, + KeyboardModifiers modifiers, + IStatusBar* statusBar) + { + switch (keyChar) + { + case 's': + widget.FitContent(); + break; + + case 'l': + application_.currentTool_ = Tools_LineMeasure; + break; + + case 'c': + application_.currentTool_ = Tools_CircleMeasure; + break; + + default: + break; + } + } + }; + + +#if ORTHANC_ENABLE_WASM==1 + class SimpleViewerApplicationAdapter : public WasmPlatformApplicationAdapter + { + SimpleViewerApplication& viewerApplication_; + + public: + SimpleViewerApplicationAdapter(MessageBroker& broker, SimpleViewerApplication& application) + : WasmPlatformApplicationAdapter(broker, application), + viewerApplication_(application) + { + + } + + virtual void HandleMessageFromWeb(std::string& output, const std::string& input) { + if (input == "select-tool:line-measure") + { + viewerApplication_.currentTool_ = Tools_LineMeasure; + NotifyStatusUpdateFromCppToWeb("currentTool=line-measure"); + } + else if (input == "select-tool:circle-measure") + { + viewerApplication_.currentTool_ = Tools_CircleMeasure; + NotifyStatusUpdateFromCppToWeb("currentTool=circle-measure"); + } + + output = "ok"; + } + + virtual void NotifyStatusUpdateFromCppToWeb(const std::string& statusUpdateMessage) { + UpdateStoneApplicationStatusFromCpp(statusUpdateMessage.c_str()); + } + + }; +#endif + enum Tools { + Tools_LineMeasure, + Tools_CircleMeasure + }; + + Tools currentTool_; + std::auto_ptr<MainWidgetInteractor> mainWidgetInteractor_; + std::auto_ptr<ThumbnailInteractor> thumbnailInteractor_; + LayoutWidget* mainLayout_; + LayoutWidget* thumbnailsLayout_; + std::vector<LayerWidget*> thumbnails_; + + std::map<std::string, std::vector<std::string> > instancesIdsPerSeriesId_; + std::map<std::string, Json::Value> seriesTags_; + + unsigned int currentInstanceIndex_; + OrthancStone::WidgetViewport* wasmViewport1_; + OrthancStone::WidgetViewport* wasmViewport2_; + + IStatusBar* statusBar_; + std::auto_ptr<SmartLoader> smartLoader_; + std::auto_ptr<OrthancApiClient> orthancApiClient_; + + Orthanc::Font font_; + + public: + SimpleViewerApplication(MessageBroker& broker) : + IObserver(broker), + currentTool_(Tools_LineMeasure), + mainLayout_(NULL), + currentInstanceIndex_(0), + wasmViewport1_(NULL), + wasmViewport2_(NULL) + { + font_.LoadFromResource(Orthanc::EmbeddedResources::FONT_UBUNTU_MONO_BOLD_16); +// DeclareIgnoredMessage(MessageType_Widget_ContentChanged); + } + + virtual void DeclareStartupOptions(boost::program_options::options_description& options) + { + boost::program_options::options_description generic("Sample options"); + generic.add_options() + ("studyId", boost::program_options::value<std::string>(), + "Orthanc ID of the study") + ; + + options.add(generic); + } + + virtual void Initialize(StoneApplicationContext* context, + IStatusBar& statusBar, + const boost::program_options::variables_map& parameters) + { + using namespace OrthancStone; + + context_ = context; + statusBar_ = &statusBar; + + {// initialize viewports and layout + mainLayout_ = new LayoutWidget("main-layout"); + mainLayout_->SetPadding(10); + mainLayout_->SetBackgroundCleared(true); + mainLayout_->SetBackgroundColor(0, 0, 0); + mainLayout_->SetHorizontal(); + + thumbnailsLayout_ = new LayoutWidget("thumbnail-layout"); + thumbnailsLayout_->SetPadding(10); + thumbnailsLayout_->SetBackgroundCleared(true); + thumbnailsLayout_->SetBackgroundColor(50, 50, 50); + thumbnailsLayout_->SetVertical(); + + mainWidget_ = new LayerWidget(broker_, "main-viewport"); + //mainWidget_->RegisterObserver(*this); + + // hierarchy + mainLayout_->AddWidget(thumbnailsLayout_); + mainLayout_->AddWidget(mainWidget_); + + orthancApiClient_.reset(new OrthancApiClient(IObserver::broker_, context_->GetWebService())); + + // sources + smartLoader_.reset(new SmartLoader(IObserver::broker_, *orthancApiClient_)); + smartLoader_->SetImageQuality(SliceImageQuality_FullPam); + + mainLayout_->SetTransmitMouseOver(true); + mainWidgetInteractor_.reset(new MainWidgetInteractor(*this)); + mainWidget_->SetInteractor(*mainWidgetInteractor_); + thumbnailInteractor_.reset(new ThumbnailInteractor(*this)); + } + + statusBar.SetMessage("Use the key \"s\" to reinitialize the layout"); + statusBar.SetMessage("Use the key \"n\" to go to next image in the main viewport"); + + + if (parameters.count("studyId") < 1) + { + LOG(WARNING) << "The study ID is missing, will take the first studyId found in Orthanc"; + orthancApiClient_->GetJsonAsync("/studies", new Callable<SimpleViewerApplication, OrthancApiClient::JsonResponseReadyMessage>(*this, &SimpleViewerApplication::OnStudyListReceived)); + } + else + { + SelectStudy(parameters["studyId"].as<std::string>()); + } + } + + void OnStudyListReceived(const OrthancApiClient::JsonResponseReadyMessage& message) + { + const Json::Value& response = message.Response; + + if (response.isArray() && response.size() > 1) + { + SelectStudy(response[0].asString()); + } + } + void OnStudyReceived(const OrthancApiClient::JsonResponseReadyMessage& message) + { + const Json::Value& response = message.Response; + + if (response.isObject() && response["Series"].isArray()) + { + for (size_t i=0; i < response["Series"].size(); i++) + { + orthancApiClient_->GetJsonAsync("/series/" + response["Series"][(int)i].asString(), new Callable<SimpleViewerApplication, OrthancApiClient::JsonResponseReadyMessage>(*this, &SimpleViewerApplication::OnSeriesReceived)); + } + } + } + + void OnSeriesReceived(const OrthancApiClient::JsonResponseReadyMessage& message) + { + const Json::Value& response = message.Response; + + if (response.isObject() && response["Instances"].isArray() && response["Instances"].size() > 0) + { + // keep track of all instances IDs + const std::string& seriesId = response["ID"].asString(); + seriesTags_[seriesId] = response; + instancesIdsPerSeriesId_[seriesId] = std::vector<std::string>(); + for (size_t i = 0; i < response["Instances"].size(); i++) + { + const std::string& instanceId = response["Instances"][static_cast<int>(i)].asString(); + instancesIdsPerSeriesId_[seriesId].push_back(instanceId); + } + + // load the first instance in the thumbnail + LoadThumbnailForSeries(seriesId, instancesIdsPerSeriesId_[seriesId][0]); + + // if this is the first thumbnail loaded, load the first instance in the mainWidget + LayerWidget& widget = *dynamic_cast<LayerWidget*>(mainWidget_); + if (widget.GetLayerCount() == 0) + { + smartLoader_->SetFrameInWidget(widget, 0, instancesIdsPerSeriesId_[seriesId][0], 0); + } + } + } + + void LoadThumbnailForSeries(const std::string& seriesId, const std::string& instanceId) + { + LOG(INFO) << "Loading thumbnail for series " << seriesId; + LayerWidget* thumbnailWidget = new LayerWidget(IObserver::broker_, "thumbnail-series-" + seriesId); + thumbnails_.push_back(thumbnailWidget); + thumbnailsLayout_->AddWidget(thumbnailWidget); + thumbnailWidget->RegisterObserverCallback(new Callable<SimpleViewerApplication, LayerWidget::GeometryChangedMessage>(*this, &SimpleViewerApplication::OnWidgetGeometryChanged)); + smartLoader_->SetFrameInWidget(*thumbnailWidget, 0, instanceId, 0); + thumbnailWidget->SetInteractor(*thumbnailInteractor_); + } + + void SelectStudy(const std::string& studyId) + { + orthancApiClient_->GetJsonAsync("/studies/" + studyId, new Callable<SimpleViewerApplication, OrthancApiClient::JsonResponseReadyMessage>(*this, &SimpleViewerApplication::OnStudyReceived)); + } + + void OnWidgetGeometryChanged(const LayerWidget::GeometryChangedMessage& message) + { + message.origin_.FitContent(); + } + + void SelectSeriesInMainViewport(const std::string& seriesId) + { + LayerWidget& widget = *dynamic_cast<LayerWidget*>(mainWidget_); + smartLoader_->SetFrameInWidget(widget, 0, instancesIdsPerSeriesId_[seriesId][0], 0); + } + + const Orthanc::Font& GetFont() const + { + return font_; + } + + virtual void OnPushButton1Clicked() {} + virtual void OnPushButton2Clicked() {} + virtual void OnTool1Clicked() { currentTool_ = Tools_LineMeasure;} + virtual void OnTool2Clicked() { currentTool_ = Tools_CircleMeasure;} + + virtual void GetButtonNames(std::string& pushButton1, + std::string& pushButton2, + std::string& tool1, + std::string& tool2 + ) { + tool1 = "line"; + tool2 = "circle"; + pushButton1 = "action1"; + pushButton2 = "action2"; + } + +#if ORTHANC_ENABLE_WASM==1 + virtual void InitializeWasm() { + + AttachWidgetToWasmViewport("canvas", thumbnailsLayout_); + AttachWidgetToWasmViewport("canvas2", mainWidget_); + } +#endif + + }; + + + } +}
--- a/Applications/Samples/SingleFrameApplication.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Applications/Samples/SingleFrameApplication.h Mon Nov 05 10:05:33 2018 +0100 @@ -33,8 +33,8 @@ namespace Samples { class SingleFrameApplication : - public SampleApplicationBase, - private ILayerSource::IObserver + public SampleSingleCanvasApplicationBase, + public IObserver { private: class Interactor : public IWorldSceneInteractor @@ -51,6 +51,9 @@ virtual IWorldSceneMouseTracker* CreateMouseTracker(WorldSceneWidget& widget, const ViewportGeometry& view, MouseButton button, + KeyboardModifiers modifiers, + int viewportX, + int viewportY, double x, double y, IStatusBar* statusBar) @@ -99,14 +102,15 @@ } virtual void KeyPressed(WorldSceneWidget& widget, - char key, + KeyboardKeys key, + char keyChar, KeyboardModifiers modifiers, IStatusBar* statusBar) { - switch (key) + switch (keyChar) { case 's': - widget.SetDefaultView(); + widget.FitContent(); break; default: @@ -138,6 +142,12 @@ } } } + + + LayerWidget& GetMainWidget() + { + return *dynamic_cast<LayerWidget*>(mainWidget_); + } void SetSlice(size_t index) @@ -148,7 +158,7 @@ slice_ = index; #if 1 - widget_->SetSlice(source_->GetSlice(slice_).GetGeometry()); + GetMainWidget().SetSlice(source_->GetSlice(slice_).GetGeometry()); #else // TEST for scene extents - Rotate the axes double a = 15.0 / 180.0 * M_PI; @@ -169,52 +179,33 @@ } - virtual void NotifyGeometryReady(const ILayerSource& source) + void OnMainWidgetGeometryReady(const ILayerSource::GeometryReadyMessage& message) { // Once the geometry of the series is downloaded from Orthanc, - // display its first slice, and adapt the viewport to fit this + // display its middle slice, and adapt the viewport to fit this // slice - if (source_ == &source) + if (source_ == &message.origin_) { SetSlice(source_->GetSliceCount() / 2); } - widget_->SetDefaultView(); - } - - virtual void NotifyGeometryError(const ILayerSource& source) - { + GetMainWidget().FitContent(); } - virtual void NotifyContentChange(const ILayerSource& source) - { - } + std::auto_ptr<Interactor> mainWidgetInteractor_; + std::auto_ptr<OrthancApiClient> orthancApiClient_; + const OrthancFrameLayerSource* source_; + unsigned int slice_; - virtual void NotifySliceChange(const ILayerSource& source, - const Slice& slice) - { - } - - virtual void NotifyLayerReady(std::auto_ptr<ILayerRenderer>& layer, - const ILayerSource& source, - const CoordinateSystem3D& slice, - bool isError) - { - } - - LayerWidget* widget_; - const OrthancFrameLayerSource* source_; - unsigned int slice_; - public: - SingleFrameApplication() : - widget_(NULL), + SingleFrameApplication(MessageBroker& broker) : + IObserver(broker), source_(NULL), slice_(0) { } - virtual void DeclareCommandLineOptions(boost::program_options::options_description& options) + virtual void DeclareStartupOptions(boost::program_options::options_description& options) { boost::program_options::options_description generic("Sample options"); generic.add_options() @@ -229,12 +220,14 @@ options.add(generic); } - virtual void Initialize(BasicApplicationContext& context, + virtual void Initialize(StoneApplicationContext* context, IStatusBar& statusBar, const boost::program_options::variables_map& parameters) { using namespace OrthancStone; + context_ = context; + statusBar.SetMessage("Use the key \"s\" to reinitialize the layout"); if (parameters.count("instance") != 1) @@ -246,17 +239,14 @@ std::string instance = parameters["instance"].as<std::string>(); int frame = parameters["frame"].as<unsigned int>(); - std::auto_ptr<LayerWidget> widget(new LayerWidget); + orthancApiClient_.reset(new OrthancApiClient(IObserver::broker_, context_->GetWebService())); + mainWidget_ = new LayerWidget(broker_, "main-widget"); -#if 1 - std::auto_ptr<OrthancFrameLayerSource> layer - (new OrthancFrameLayerSource(context.GetWebService())); - //layer->SetImageQuality(SliceImageQuality_Jpeg50); + std::auto_ptr<OrthancFrameLayerSource> layer(new OrthancFrameLayerSource(broker_, *orthancApiClient_)); + source_ = layer.get(); layer->LoadFrame(instance, frame); - //layer->LoadSeries("6f1b492a-e181e200-44e51840-ef8db55e-af529ab6"); - layer->Register(*this); - source_ = layer.get(); - widget->AddLayer(layer.release()); + layer->RegisterObserverCallback(new Callable<SingleFrameApplication, ILayerSource::GeometryReadyMessage>(*this, &SingleFrameApplication::OnMainWidgetGeometryReady)); + GetMainWidget().AddLayer(layer.release()); RenderStyle s; @@ -265,53 +255,14 @@ s.interpolation_ = ImageInterpolation_Bilinear; } - //s.drawGrid_ = true; - widget->SetLayerStyle(0, s); -#else - // 0178023P** - // Extent of the CT layer: (-35.068 -20.368) => (34.932 49.632) - std::auto_ptr<OrthancFrameLayerSource> ct; - ct.reset(new OrthancFrameLayerSource(context.GetWebService())); - //ct->LoadInstance("c804a1a2-142545c9-33b32fe2-3df4cec0-a2bea6d6", 0); - //ct->LoadInstance("4bd4304f-47478948-71b24af2-51f4f1bc-275b6c1b", 0); // BAD SLICE - //ct->SetImageQuality(SliceImageQuality_Jpeg50); - ct->LoadSeries("dd069910-4f090474-7d2bba07-e5c10783-f9e4fb1d"); - - ct->Register(*this); - widget->AddLayer(ct.release()); - - std::auto_ptr<OrthancFrameLayerSource> pet; - pet.reset(new OrthancFrameLayerSource(context.GetWebService())); - //pet->LoadInstance("a1c4dc6b-255d27f0-88069875-8daed730-2f5ee5c6", 0); - pet->LoadSeries("aabad2e7-80702b5d-e599d26c-4f13398e-38d58a9e"); - pet->Register(*this); - source_ = pet.get(); - widget->AddLayer(pet.release()); + GetMainWidget().SetLayerStyle(0, s); + GetMainWidget().SetTransmitMouseOver(true); - { - RenderStyle s; - //s.drawGrid_ = true; - s.alpha_ = 1; - widget->SetLayerStyle(0, s); - } - - { - RenderStyle s; - //s.drawGrid_ = true; - s.SetColor(255, 0, 0); // Draw missing PET layer in red - s.alpha_ = 0.5; - s.applyLut_ = true; - s.lut_ = Orthanc::EmbeddedResources::COLORMAP_JET; - s.interpolation_ = ImageInterpolation_Bilinear; - widget->SetLayerStyle(1, s); - } -#endif - - widget_ = widget.get(); - widget_->SetTransmitMouseOver(true); - widget_->SetInteractor(context.AddInteractor(new Interactor(*this))); - context.SetCentralWidget(widget.release()); + mainWidgetInteractor_.reset(new Interactor(*this)); + GetMainWidget().SetInteractor(*mainWidgetInteractor_); } }; + + } }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/SingleFrameEditorApplication.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,2922 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "SampleApplicationBase.h" + +#include "../../Framework/Toolbox/ImageGeometry.h" +#include "../../Framework/Toolbox/OrthancApiClient.h" +#include "../../Framework/Toolbox/DicomFrameConverter.h" + +#include <Core/Images/FontRegistry.h> +#include <Core/Images/Image.h> +#include <Core/Images/ImageProcessing.h> +#include <Core/Images/PamReader.h> +#include <Core/Images/PamWriter.h> +#include <Core/Images/PngWriter.h> +#include <Core/Logging.h> +#include <Core/Toolbox.h> +#include <Plugins/Samples/Common/DicomDatasetReader.h> +#include <Plugins/Samples/Common/FullOrthancDataset.h> + +#define EXPORT_USING_PAM 1 + + +#include <boost/math/constants/constants.hpp> + +namespace OrthancStone +{ + static Matrix CreateOffsetMatrix(double dx, + double dy) + { + Matrix m = LinearAlgebra::IdentityMatrix(3); + m(0, 2) = dx; + m(1, 2) = dy; + return m; + } + + + static Matrix CreateScalingMatrix(double sx, + double sy) + { + Matrix m = LinearAlgebra::IdentityMatrix(3); + m(0, 0) = sx; + m(1, 1) = sy; + return m; + } + + + static Matrix CreateRotationMatrix(double angle) + { + Matrix m; + const double v[] = { cos(angle), -sin(angle), 0, + sin(angle), cos(angle), 0, + 0, 0, 1 }; + LinearAlgebra::FillMatrix(m, 3, 3, v); + return m; + } + + + class BitmapStack : + public IObserver, + public IObservable + { + public: + typedef OriginMessage<MessageType_Widget_GeometryChanged, BitmapStack> GeometryChangedMessage; + typedef OriginMessage<MessageType_Widget_ContentChanged, BitmapStack> ContentChangedMessage; + + + enum Corner + { + Corner_TopLeft, + Corner_TopRight, + Corner_BottomLeft, + Corner_BottomRight + }; + + + + class Bitmap : public boost::noncopyable + { + private: + size_t index_; + bool hasSize_; + unsigned int width_; + unsigned int height_; + bool hasCrop_; + unsigned int cropX_; + unsigned int cropY_; + unsigned int cropWidth_; + unsigned int cropHeight_; + Matrix transform_; + Matrix transformInverse_; + double pixelSpacingX_; + double pixelSpacingY_; + double panX_; + double panY_; + double angle_; + bool resizeable_; + + + protected: + const Matrix& GetTransform() const + { + return transform_; + } + + + private: + static void ApplyTransform(double& x /* inout */, + double& y /* inout */, + const Matrix& transform) + { + Vector p; + LinearAlgebra::AssignVector(p, x, y, 1); + + Vector q = LinearAlgebra::Product(transform, p); + + if (!LinearAlgebra::IsNear(q[2], 1.0)) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + else + { + x = q[0]; + y = q[1]; + } + } + + + void UpdateTransform() + { + transform_ = CreateScalingMatrix(pixelSpacingX_, pixelSpacingY_); + + double centerX, centerY; + GetCenter(centerX, centerY); + + transform_ = LinearAlgebra::Product( + CreateOffsetMatrix(panX_ + centerX, panY_ + centerY), + CreateRotationMatrix(angle_), + CreateOffsetMatrix(-centerX, -centerY), + transform_); + + LinearAlgebra::InvertMatrix(transformInverse_, transform_); + } + + + void AddToExtent(Extent2D& extent, + double x, + double y) const + { + ApplyTransform(x, y, transform_); + extent.AddPoint(x, y); + } + + + void GetCornerInternal(double& x, + double& y, + Corner corner, + unsigned int cropX, + unsigned int cropY, + unsigned int cropWidth, + unsigned int cropHeight) const + { + double dx = static_cast<double>(cropX); + double dy = static_cast<double>(cropY); + double dwidth = static_cast<double>(cropWidth); + double dheight = static_cast<double>(cropHeight); + + switch (corner) + { + case Corner_TopLeft: + x = dx; + y = dy; + break; + + case Corner_TopRight: + x = dx + dwidth; + y = dy; + break; + + case Corner_BottomLeft: + x = dx; + y = dy + dheight; + break; + + case Corner_BottomRight: + x = dx + dwidth; + y = dy + dheight; + break; + + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + + ApplyTransform(x, y, transform_); + } + + + public: + Bitmap(size_t index) : + index_(index), + hasSize_(false), + width_(0), + height_(0), + hasCrop_(false), + pixelSpacingX_(1), + pixelSpacingY_(1), + panX_(0), + panY_(0), + angle_(0), + resizeable_(false) + { + UpdateTransform(); + } + + virtual ~Bitmap() + { + } + + size_t GetIndex() const + { + return index_; + } + + void ResetCrop() + { + hasCrop_ = false; + } + + void SetCrop(unsigned int x, + unsigned int y, + unsigned int width, + unsigned int height) + { + if (!hasSize_) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); + } + + if (x + width > width_ || + y + height > height_) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + + hasCrop_ = true; + cropX_ = x; + cropY_ = y; + cropWidth_ = width; + cropHeight_ = height; + + UpdateTransform(); + } + + void GetCrop(unsigned int& x, + unsigned int& y, + unsigned int& width, + unsigned int& height) const + { + if (hasCrop_) + { + x = cropX_; + y = cropY_; + width = cropWidth_; + height = cropHeight_; + } + else + { + x = 0; + y = 0; + width = width_; + height = height_; + } + } + + void SetAngle(double angle) + { + angle_ = angle; + UpdateTransform(); + } + + double GetAngle() const + { + return angle_; + } + + void SetSize(unsigned int width, + unsigned int height) + { + if (hasSize_ && + (width != width_ || + height != height_)) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageSize); + } + + hasSize_ = true; + width_ = width; + height_ = height; + + UpdateTransform(); + } + + + unsigned int GetWidth() const + { + return width_; + } + + + unsigned int GetHeight() const + { + return height_; + } + + + void CheckSize(unsigned int width, + unsigned int height) + { + if (hasSize_ && + (width != width_ || + height != height_)) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageSize); + } + } + + + Extent2D GetExtent() const + { + Extent2D extent; + + unsigned int x, y, width, height; + GetCrop(x, y, width, height); + + double dx = static_cast<double>(x); + double dy = static_cast<double>(y); + double dwidth = static_cast<double>(width); + double dheight = static_cast<double>(height); + + AddToExtent(extent, dx, dy); + AddToExtent(extent, dx + dwidth, dy); + AddToExtent(extent, dx, dy + dheight); + AddToExtent(extent, dx + dwidth, dy + dheight); + + return extent; + } + + + bool Contains(double x, + double y) const + { + ApplyTransform(x, y, transformInverse_); + + unsigned int cropX, cropY, cropWidth, cropHeight; + GetCrop(cropX, cropY, cropWidth, cropHeight); + + return (x >= cropX && x <= cropX + cropWidth && + y >= cropY && y <= cropY + cropHeight); + } + + + bool GetPixel(unsigned int& imageX, + unsigned int& imageY, + double sceneX, + double sceneY) const + { + if (width_ == 0 || + height_ == 0) + { + return false; + } + else + { + ApplyTransform(sceneX, sceneY, transformInverse_); + + int x = static_cast<int>(std::floor(sceneX)); + int y = static_cast<int>(std::floor(sceneY)); + + if (x < 0) + { + imageX = 0; + } + else if (x >= static_cast<int>(width_)) + { + imageX = width_; + } + else + { + imageX = static_cast<unsigned int>(x); + } + + if (y < 0) + { + imageY = 0; + } + else if (y >= static_cast<int>(height_)) + { + imageY = height_; + } + else + { + imageY = static_cast<unsigned int>(y); + } + + return true; + } + } + + + void SetPan(double x, + double y) + { + panX_ = x; + panY_ = y; + UpdateTransform(); + } + + + void SetPixelSpacing(double x, + double y) + { + pixelSpacingX_ = x; + pixelSpacingY_ = y; + UpdateTransform(); + } + + double GetPixelSpacingX() const + { + return pixelSpacingX_; + } + + double GetPixelSpacingY() const + { + return pixelSpacingY_; + } + + double GetPanX() const + { + return panX_; + } + + double GetPanY() const + { + return panY_; + } + + void GetCenter(double& centerX, + double& centerY) const + { + centerX = static_cast<double>(width_) / 2.0; + centerY = static_cast<double>(height_) / 2.0; + ApplyTransform(centerX, centerY, transform_); + } + + + void DrawBorders(CairoContext& context, + double zoom) + { + unsigned int cx, cy, width, height; + GetCrop(cx, cy, width, height); + + double dx = static_cast<double>(cx); + double dy = static_cast<double>(cy); + double dwidth = static_cast<double>(width); + double dheight = static_cast<double>(height); + + cairo_t* cr = context.GetObject(); + cairo_set_line_width(cr, 2.0 / zoom); + + double x, y; + x = dx; + y = dy; + ApplyTransform(x, y, transform_); + cairo_move_to(cr, x, y); + + x = dx + dwidth; + y = dy; + ApplyTransform(x, y, transform_); + cairo_line_to(cr, x, y); + + x = dx + dwidth; + y = dy + dheight; + ApplyTransform(x, y, transform_); + cairo_line_to(cr, x, y); + + x = dx; + y = dy + dheight; + ApplyTransform(x, y, transform_); + cairo_line_to(cr, x, y); + + x = dx; + y = dy; + ApplyTransform(x, y, transform_); + cairo_line_to(cr, x, y); + + cairo_stroke(cr); + } + + + static double Square(double x) + { + return x * x; + } + + + void GetCorner(double& x /* out */, + double& y /* out */, + Corner corner) const + { + unsigned int cropX, cropY, cropWidth, cropHeight; + GetCrop(cropX, cropY, cropWidth, cropHeight); + GetCornerInternal(x, y, corner, cropX, cropY, cropWidth, cropHeight); + } + + + bool LookupCorner(Corner& corner /* out */, + double x, + double y, + double zoom, + double viewportDistance) const + { + static const Corner CORNERS[] = { + Corner_TopLeft, + Corner_TopRight, + Corner_BottomLeft, + Corner_BottomRight + }; + + unsigned int cropX, cropY, cropWidth, cropHeight; + GetCrop(cropX, cropY, cropWidth, cropHeight); + + double threshold = Square(viewportDistance / zoom); + + for (size_t i = 0; i < 4; i++) + { + double cx, cy; + GetCornerInternal(cx, cy, CORNERS[i], cropX, cropY, cropWidth, cropHeight); + + double d = Square(cx - x) + Square(cy - y); + + if (d <= threshold) + { + corner = CORNERS[i]; + return true; + } + } + + return false; + } + + bool IsResizeable() const + { + return resizeable_; + } + + void SetResizeable(bool resizeable) + { + resizeable_ = resizeable; + } + + virtual bool GetDefaultWindowing(float& center, + float& width) const + { + return false; + } + + virtual void Render(Orthanc::ImageAccessor& buffer, + const Matrix& viewTransform, + ImageInterpolation interpolation) const = 0; + + virtual bool GetRange(float& minValue, + float& maxValue) const = 0; + }; + + + class BitmapAccessor : public boost::noncopyable + { + private: + BitmapStack& stack_; + size_t index_; + Bitmap* bitmap_; + + public: + BitmapAccessor(BitmapStack& stack, + size_t index) : + stack_(stack), + index_(index) + { + Bitmaps::iterator bitmap = stack.bitmaps_.find(index); + if (bitmap == stack.bitmaps_.end()) + { + bitmap_ = NULL; + } + else + { + assert(bitmap->second != NULL); + bitmap_ = bitmap->second; + } + } + + BitmapAccessor(BitmapStack& stack, + double x, + double y) : + stack_(stack), + index_(0) // Dummy initialization + { + if (stack.LookupBitmap(index_, x, y)) + { + Bitmaps::iterator bitmap = stack.bitmaps_.find(index_); + + if (bitmap == stack.bitmaps_.end()) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + else + { + assert(bitmap->second != NULL); + bitmap_ = bitmap->second; + } + } + else + { + bitmap_ = NULL; + } + } + + void Invalidate() + { + bitmap_ = NULL; + } + + bool IsValid() const + { + return bitmap_ != NULL; + } + + BitmapStack& GetStack() const + { + if (IsValid()) + { + return stack_; + } + else + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); + } + } + + size_t GetIndex() const + { + if (IsValid()) + { + return index_; + } + else + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); + } + } + + Bitmap& GetBitmap() const + { + if (IsValid()) + { + return *bitmap_; + } + else + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); + } + } + }; + + + class AlphaBitmap : public Bitmap + { + private: + const BitmapStack& stack_; + std::auto_ptr<Orthanc::ImageAccessor> alpha_; // Grayscale8 + bool useWindowing_; + float foreground_; + + public: + AlphaBitmap(size_t index, + const BitmapStack& stack) : + Bitmap(index), + stack_(stack), + useWindowing_(true), + foreground_(0) + { + } + + + void SetForegroundValue(float foreground) + { + useWindowing_ = false; + foreground_ = foreground; + } + + + void SetAlpha(Orthanc::ImageAccessor* image) + { + std::auto_ptr<Orthanc::ImageAccessor> raii(image); + + if (image == NULL) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); + } + + if (image->GetFormat() != Orthanc::PixelFormat_Grayscale8) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageFormat); + } + + SetSize(image->GetWidth(), image->GetHeight()); + alpha_ = raii; + } + + + void LoadText(const Orthanc::Font& font, + const std::string& utf8) + { + SetAlpha(font.RenderAlpha(utf8)); + } + + + virtual void Render(Orthanc::ImageAccessor& buffer, + const Matrix& viewTransform, + ImageInterpolation interpolation) const + { + if (buffer.GetFormat() != Orthanc::PixelFormat_Float32) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageFormat); + } + + unsigned int cropX, cropY, cropWidth, cropHeight; + GetCrop(cropX, cropY, cropWidth, cropHeight); + + Matrix m = LinearAlgebra::Product(viewTransform, + GetTransform(), + CreateOffsetMatrix(cropX, cropY)); + + Orthanc::ImageAccessor cropped; + alpha_->GetRegion(cropped, cropX, cropY, cropWidth, cropHeight); + + Orthanc::Image tmp(Orthanc::PixelFormat_Grayscale8, buffer.GetWidth(), buffer.GetHeight(), false); + ApplyProjectiveTransform(tmp, cropped, m, interpolation, true /* clear */); + + // Blit + const unsigned int width = buffer.GetWidth(); + const unsigned int height = buffer.GetHeight(); + + float value = foreground_; + + if (useWindowing_) + { + float center, width; + if (stack_.GetWindowing(center, width)) + { + value = center + width / 2.0f; + } + } + + for (unsigned int y = 0; y < height; y++) + { + float *q = reinterpret_cast<float*>(buffer.GetRow(y)); + const uint8_t *p = reinterpret_cast<uint8_t*>(tmp.GetRow(y)); + + for (unsigned int x = 0; x < width; x++, p++, q++) + { + float a = static_cast<float>(*p) / 255.0f; + + *q = (a * value + (1.0f - a) * (*q)); + } + } + } + + virtual bool GetRange(float& minValue, + float& maxValue) const + { + if (useWindowing_) + { + return false; + } + else + { + minValue = 0; + maxValue = 0; + + if (foreground_ < 0) + { + minValue = foreground_; + } + + if (foreground_ > 0) + { + maxValue = foreground_; + } + + return true; + } + } + }; + + + + private: + class DicomBitmap : public Bitmap + { + private: + std::auto_ptr<Orthanc::ImageAccessor> source_; // Content of PixelData + std::auto_ptr<DicomFrameConverter> converter_; + std::auto_ptr<Orthanc::ImageAccessor> converted_; // Float32 + + static OrthancPlugins::DicomTag ConvertTag(const Orthanc::DicomTag& tag) + { + return OrthancPlugins::DicomTag(tag.GetGroup(), tag.GetElement()); + } + + + void ApplyConverter() + { + if (source_.get() != NULL && + converter_.get() != NULL) + { + converted_.reset(converter_->ConvertFrame(*source_)); + } + } + + public: + DicomBitmap(size_t index) : + Bitmap(index) + { + } + + void SetDicomTags(const OrthancPlugins::FullOrthancDataset& dataset) + { + converter_.reset(new DicomFrameConverter); + converter_->ReadParameters(dataset); + ApplyConverter(); + + std::string tmp; + Vector pixelSpacing; + + if (dataset.GetStringValue(tmp, ConvertTag(Orthanc::DICOM_TAG_PIXEL_SPACING)) && + LinearAlgebra::ParseVector(pixelSpacing, tmp) && + pixelSpacing.size() == 2) + { + SetPixelSpacing(pixelSpacing[0], pixelSpacing[1]); + } + + //SetPan(-0.5 * GetPixelSpacingX(), -0.5 * GetPixelSpacingY()); + + OrthancPlugins::DicomDatasetReader reader(dataset); + + unsigned int width, height; + if (!reader.GetUnsignedIntegerValue(width, ConvertTag(Orthanc::DICOM_TAG_COLUMNS)) || + !reader.GetUnsignedIntegerValue(height, ConvertTag(Orthanc::DICOM_TAG_ROWS))) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + else + { + SetSize(width, height); + } + } + + + void SetSourceImage(Orthanc::ImageAccessor* image) // Takes ownership + { + std::auto_ptr<Orthanc::ImageAccessor> raii(image); + + if (image == NULL) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); + } + + SetSize(image->GetWidth(), image->GetHeight()); + + source_ = raii; + ApplyConverter(); + } + + + virtual void Render(Orthanc::ImageAccessor& buffer, + const Matrix& viewTransform, + ImageInterpolation interpolation) const + { + if (converted_.get() != NULL) + { + if (converted_->GetFormat() != Orthanc::PixelFormat_Float32) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + unsigned int cropX, cropY, cropWidth, cropHeight; + GetCrop(cropX, cropY, cropWidth, cropHeight); + + Matrix m = LinearAlgebra::Product(viewTransform, + GetTransform(), + CreateOffsetMatrix(cropX, cropY)); + + Orthanc::ImageAccessor cropped; + converted_->GetRegion(cropped, cropX, cropY, cropWidth, cropHeight); + + ApplyProjectiveTransform(buffer, cropped, m, interpolation, false); + } + } + + + virtual bool GetDefaultWindowing(float& center, + float& width) const + { + if (converter_.get() != NULL && + converter_->HasDefaultWindow()) + { + center = static_cast<float>(converter_->GetDefaultWindowCenter()); + width = static_cast<float>(converter_->GetDefaultWindowWidth()); + return true; + } + else + { + return false; + } + } + + + virtual bool GetRange(float& minValue, + float& maxValue) const + { + if (converted_.get() != NULL) + { + if (converted_->GetFormat() != Orthanc::PixelFormat_Float32) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + Orthanc::ImageProcessing::GetMinMaxFloatValue(minValue, maxValue, *converted_); + return true; + } + else + { + return false; + } + } + }; + + + + + typedef std::map<size_t, Bitmap*> Bitmaps; + + OrthancApiClient& orthanc_; + size_t countBitmaps_; + bool hasWindowing_; + float windowingCenter_; + float windowingWidth_; + Bitmaps bitmaps_; + bool hasSelection_; + size_t selectedBitmap_; + + public: + BitmapStack(MessageBroker& broker, + OrthancApiClient& orthanc) : + IObserver(broker), + IObservable(broker), + orthanc_(orthanc), + countBitmaps_(0), + hasWindowing_(false), + windowingCenter_(0), // Dummy initialization + windowingWidth_(0), // Dummy initialization + hasSelection_(false), + selectedBitmap_(0) // Dummy initialization + { + } + + + void Unselect() + { + hasSelection_ = false; + } + + + void Select(size_t bitmap) + { + hasSelection_ = true; + selectedBitmap_ = bitmap; + } + + + bool GetSelectedBitmap(size_t& bitmap) const + { + if (hasSelection_) + { + bitmap = selectedBitmap_; + return true; + } + else + { + return false; + } + } + + + virtual ~BitmapStack() + { + for (Bitmaps::iterator it = bitmaps_.begin(); it != bitmaps_.end(); it++) + { + assert(it->second != NULL); + delete it->second; + } + } + + + bool GetWindowing(float& center, + float& width) const + { + if (hasWindowing_) + { + center = windowingCenter_; + width = windowingWidth_; + return true; + } + else + { + return false; + } + } + + + void GetWindowingWithDefault(float& center, + float& width) const + { + if (!GetWindowing(center, width)) + { + center = 128; + width = 256; + } + } + + + void SetWindowing(float center, + float width) + + { + hasWindowing_ = true; + windowingCenter_ = center; + windowingWidth_ = width; + + //EmitMessage(ContentChangedMessage(*this)); + } + + + Bitmap& LoadText(const Orthanc::Font& font, + const std::string& utf8) + { + size_t bitmap = countBitmaps_++; + + std::auto_ptr<AlphaBitmap> alpha(new AlphaBitmap(bitmap, *this)); + alpha->LoadText(font, utf8); + + AlphaBitmap* ptr = alpha.get(); + bitmaps_[bitmap] = alpha.release(); + + return *ptr; + } + + + Bitmap& LoadTestBlock(unsigned int width, + unsigned int height) + { + size_t bitmap = countBitmaps_++; + + std::auto_ptr<AlphaBitmap> alpha(new AlphaBitmap(bitmap, *this)); + + std::auto_ptr<Orthanc::Image> block(new Orthanc::Image(Orthanc::PixelFormat_Grayscale8, width, height, false)); + + for (unsigned int padding = 0; + (width > 2 * padding) && (height > 2 * padding); + padding++) + { + uint8_t color; + if (255 > 10 * padding) + { + color = 255 - 10 * padding; + } + else + { + color = 0; + } + + Orthanc::ImageAccessor region; + block->GetRegion(region, padding, padding, width - 2 * padding, height - 2 * padding); + Orthanc::ImageProcessing::Set(region, color); + } + + alpha->SetAlpha(block.release()); + + AlphaBitmap* ptr = alpha.get(); + bitmaps_[bitmap] = alpha.release(); + + return *ptr; + } + + + Bitmap& LoadFrame(const std::string& instance, + unsigned int frame, + bool httpCompression) + { + size_t bitmap = countBitmaps_++; + + bitmaps_[bitmap] = new DicomBitmap(bitmap); + + { + IWebService::Headers headers; + std::string uri = "/instances/" + instance + "/tags"; + orthanc_.GetBinaryAsync(uri, headers, + new Callable<BitmapStack, OrthancApiClient::BinaryResponseReadyMessage> + (*this, &BitmapStack::OnTagsReceived), NULL, + new Orthanc::SingleValueObject<size_t>(bitmap)); + } + + { + IWebService::Headers headers; + headers["Accept"] = "image/x-portable-arbitrarymap"; + + if (httpCompression) + { + headers["Accept-Encoding"] = "gzip"; + } + + std::string uri = "/instances/" + instance + "/frames/" + boost::lexical_cast<std::string>(frame) + "/image-uint16"; + orthanc_.GetBinaryAsync(uri, headers, + new Callable<BitmapStack, OrthancApiClient::BinaryResponseReadyMessage> + (*this, &BitmapStack::OnFrameReceived), NULL, + new Orthanc::SingleValueObject<size_t>(bitmap)); + } + + return *bitmaps_[bitmap]; + } + + + void OnTagsReceived(const OrthancApiClient::BinaryResponseReadyMessage& message) + { + size_t index = dynamic_cast<Orthanc::SingleValueObject<size_t>*>(message.Payload.get())->GetValue(); + + LOG(INFO) << "JSON received: " << message.Uri.c_str() + << " (" << message.AnswerSize << " bytes) for bitmap " << index; + + Bitmaps::iterator bitmap = bitmaps_.find(index); + if (bitmap != bitmaps_.end()) + { + assert(bitmap->second != NULL); + + OrthancPlugins::FullOrthancDataset dicom(message.Answer, message.AnswerSize); + dynamic_cast<DicomBitmap*>(bitmap->second)->SetDicomTags(dicom); + + float c, w; + if (!hasWindowing_ && + bitmap->second->GetDefaultWindowing(c, w)) + { + hasWindowing_ = true; + windowingCenter_ = c; + windowingWidth_ = w; + } + + EmitMessage(GeometryChangedMessage(*this)); + } + } + + + void OnFrameReceived(const OrthancApiClient::BinaryResponseReadyMessage& message) + { + size_t index = dynamic_cast<Orthanc::SingleValueObject<size_t>*>(message.Payload.get())->GetValue(); + + LOG(INFO) << "DICOM frame received: " << message.Uri.c_str() + << " (" << message.AnswerSize << " bytes) for bitmap " << index; + + Bitmaps::iterator bitmap = bitmaps_.find(index); + if (bitmap != bitmaps_.end()) + { + assert(bitmap->second != NULL); + + std::string content; + if (message.AnswerSize > 0) + { + content.assign(reinterpret_cast<const char*>(message.Answer), message.AnswerSize); + } + + std::auto_ptr<Orthanc::PamReader> reader(new Orthanc::PamReader); + reader->ReadFromMemory(content); + dynamic_cast<DicomBitmap*>(bitmap->second)->SetSourceImage(reader.release()); + + EmitMessage(ContentChangedMessage(*this)); + } + } + + + Extent2D GetSceneExtent() const + { + Extent2D extent; + + for (Bitmaps::const_iterator it = bitmaps_.begin(); + it != bitmaps_.end(); ++it) + { + assert(it->second != NULL); + extent.Union(it->second->GetExtent()); + } + + return extent; + } + + + void Render(Orthanc::ImageAccessor& buffer, + const Matrix& viewTransform, + ImageInterpolation interpolation) const + { + Orthanc::ImageProcessing::Set(buffer, 0); + + // Render layers in the background-to-foreground order + for (size_t index = 0; index < countBitmaps_; index++) + { + Bitmaps::const_iterator it = bitmaps_.find(index); + if (it != bitmaps_.end()) + { + assert(it->second != NULL); + it->second->Render(buffer, viewTransform, interpolation); + } + } + } + + + bool LookupBitmap(size_t& index /* out */, + double x, + double y) const + { + // Render layers in the foreground-to-background order + for (size_t i = countBitmaps_; i > 0; i--) + { + index = i - 1; + Bitmaps::const_iterator it = bitmaps_.find(index); + if (it != bitmaps_.end()) + { + assert(it->second != NULL); + if (it->second->Contains(x, y)) + { + return true; + } + } + } + + return false; + } + + void DrawControls(CairoContext& context, + double zoom) + { + if (hasSelection_) + { + Bitmaps::const_iterator bitmap = bitmaps_.find(selectedBitmap_); + + if (bitmap != bitmaps_.end()) + { + context.SetSourceColor(255, 0, 0); + //view.ApplyTransform(context); + bitmap->second->DrawBorders(context, zoom); + } + } + } + + + void GetRange(float& minValue, + float& maxValue) const + { + bool first = true; + + for (Bitmaps::const_iterator it = bitmaps_.begin(); + it != bitmaps_.end(); it++) + { + assert(it->second != NULL); + + float a, b; + if (it->second->GetRange(a, b)) + { + if (first) + { + minValue = a; + maxValue = b; + first = false; + } + else + { + minValue = std::min(a, minValue); + maxValue = std::max(b, maxValue); + } + } + } + + if (first) + { + minValue = 0; + maxValue = 0; + } + } + }; + + + class UndoRedoStack : public boost::noncopyable + { + public: + class ICommand : public boost::noncopyable + { + public: + virtual ~ICommand() + { + } + + virtual void Undo() const = 0; + + virtual void Redo() const = 0; + }; + + private: + typedef std::list<ICommand*> Stack; + + Stack stack_; + Stack::iterator current_; + + void Clear(Stack::iterator from) + { + for (Stack::iterator it = from; it != stack_.end(); ++it) + { + assert(*it != NULL); + delete *it; + } + + stack_.erase(from, stack_.end()); + } + + public: + UndoRedoStack() : + current_(stack_.end()) + { + } + + ~UndoRedoStack() + { + Clear(stack_.begin()); + } + + void Add(ICommand* command) + { + if (command == NULL) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); + } + + Clear(current_); + + stack_.push_back(command); + current_ = stack_.end(); + } + + void Undo() + { + if (current_ != stack_.begin()) + { + --current_; + + assert(*current_ != NULL); + (*current_)->Undo(); + } + } + + void Redo() + { + if (current_ != stack_.end()) + { + assert(*current_ != NULL); + (*current_)->Redo(); + + ++current_; + } + } + }; + + + class BitmapCommandBase : public UndoRedoStack::ICommand + { + private: + BitmapStack& stack_; + size_t bitmap_; + + protected: + virtual void UndoInternal(BitmapStack::Bitmap& bitmap) const = 0; + + virtual void RedoInternal(BitmapStack::Bitmap& bitmap) const = 0; + + public: + BitmapCommandBase(BitmapStack& stack, + size_t bitmap) : + stack_(stack), + bitmap_(bitmap) + { + } + + BitmapCommandBase(const BitmapStack::BitmapAccessor& accessor) : + stack_(accessor.GetStack()), + bitmap_(accessor.GetIndex()) + { + } + + virtual void Undo() const + { + BitmapStack::BitmapAccessor accessor(stack_, bitmap_); + + if (accessor.IsValid()) + { + UndoInternal(accessor.GetBitmap()); + } + } + + virtual void Redo() const + { + BitmapStack::BitmapAccessor accessor(stack_, bitmap_); + + if (accessor.IsValid()) + { + RedoInternal(accessor.GetBitmap()); + } + } + }; + + + class RotateBitmapTracker : public IWorldSceneMouseTracker + { + private: + UndoRedoStack& undoRedoStack_; + BitmapStack::BitmapAccessor accessor_; + double centerX_; + double centerY_; + double originalAngle_; + double clickAngle_; + bool roundAngles_; + + bool ComputeAngle(double& angle /* out */, + double sceneX, + double sceneY) const + { + Vector u; + LinearAlgebra::AssignVector(u, sceneX - centerX_, sceneY - centerY_); + + double nu = boost::numeric::ublas::norm_2(u); + + if (!LinearAlgebra::IsCloseToZero(nu)) + { + u /= nu; + angle = atan2(u[1], u[0]); + return true; + } + else + { + return false; + } + } + + + class UndoRedoCommand : public BitmapCommandBase + { + private: + double sourceAngle_; + double targetAngle_; + + static int ToDegrees(double angle) + { + return static_cast<int>(round(angle * 180.0 / boost::math::constants::pi<double>())); + } + + protected: + virtual void UndoInternal(BitmapStack::Bitmap& bitmap) const + { + LOG(INFO) << "Undo - Set angle to " << ToDegrees(sourceAngle_) << " degrees"; + bitmap.SetAngle(sourceAngle_); + } + + virtual void RedoInternal(BitmapStack::Bitmap& bitmap) const + { + LOG(INFO) << "Redo - Set angle to " << ToDegrees(sourceAngle_) << " degrees"; + bitmap.SetAngle(targetAngle_); + } + + public: + UndoRedoCommand(const RotateBitmapTracker& tracker) : + BitmapCommandBase(tracker.accessor_), + sourceAngle_(tracker.originalAngle_), + targetAngle_(tracker.accessor_.GetBitmap().GetAngle()) + { + } + }; + + + public: + RotateBitmapTracker(UndoRedoStack& undoRedoStack, + BitmapStack& stack, + const ViewportGeometry& view, + size_t bitmap, + double x, + double y, + bool roundAngles) : + undoRedoStack_(undoRedoStack), + accessor_(stack, bitmap), + roundAngles_(roundAngles) + { + if (accessor_.IsValid()) + { + accessor_.GetBitmap().GetCenter(centerX_, centerY_); + originalAngle_ = accessor_.GetBitmap().GetAngle(); + + double sceneX, sceneY; + view.MapDisplayToScene(sceneX, sceneY, x, y); + + if (!ComputeAngle(clickAngle_, x, y)) + { + accessor_.Invalidate(); + } + } + } + + virtual bool HasRender() const + { + return false; + } + + virtual void Render(CairoContext& context, + double zoom) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + virtual void MouseUp() + { + if (accessor_.IsValid()) + { + undoRedoStack_.Add(new UndoRedoCommand(*this)); + } + } + + virtual void MouseMove(int displayX, + int displayY, + double sceneX, + double sceneY) + { + static const double ROUND_ANGLE = 15.0 / 180.0 * boost::math::constants::pi<double>(); + + double angle; + + if (accessor_.IsValid() && + ComputeAngle(angle, sceneX, sceneY)) + { + angle = angle - clickAngle_ + originalAngle_; + + if (roundAngles_) + { + angle = round(angle / ROUND_ANGLE) * ROUND_ANGLE; + } + + accessor_.GetBitmap().SetAngle(angle); + } + } + }; + + + class MoveBitmapTracker : public IWorldSceneMouseTracker + { + private: + UndoRedoStack& undoRedoStack_; + BitmapStack::BitmapAccessor accessor_; + double clickX_; + double clickY_; + double panX_; + double panY_; + bool oneAxis_; + + class UndoRedoCommand : public BitmapCommandBase + { + private: + double sourceX_; + double sourceY_; + double targetX_; + double targetY_; + + protected: + virtual void UndoInternal(BitmapStack::Bitmap& bitmap) const + { + bitmap.SetPan(sourceX_, sourceY_); + } + + virtual void RedoInternal(BitmapStack::Bitmap& bitmap) const + { + bitmap.SetPan(targetX_, targetY_); + } + + public: + UndoRedoCommand(const MoveBitmapTracker& tracker) : + BitmapCommandBase(tracker.accessor_), + sourceX_(tracker.panX_), + sourceY_(tracker.panY_), + targetX_(tracker.accessor_.GetBitmap().GetPanX()), + targetY_(tracker.accessor_.GetBitmap().GetPanY()) + { + } + }; + + + public: + MoveBitmapTracker(UndoRedoStack& undoRedoStack, + BitmapStack& stack, + size_t bitmap, + double x, + double y, + bool oneAxis) : + undoRedoStack_(undoRedoStack), + accessor_(stack, bitmap), + clickX_(x), + clickY_(y), + oneAxis_(oneAxis) + { + if (accessor_.IsValid()) + { + panX_ = accessor_.GetBitmap().GetPanX(); + panY_ = accessor_.GetBitmap().GetPanY(); + } + } + + virtual bool HasRender() const + { + return false; + } + + virtual void Render(CairoContext& context, + double zoom) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + virtual void MouseUp() + { + if (accessor_.IsValid()) + { + undoRedoStack_.Add(new UndoRedoCommand(*this)); + } + } + + virtual void MouseMove(int displayX, + int displayY, + double sceneX, + double sceneY) + { + if (accessor_.IsValid()) + { + double dx = sceneX - clickX_; + double dy = sceneY - clickY_; + + if (oneAxis_) + { + if (fabs(dx) > fabs(dy)) + { + accessor_.GetBitmap().SetPan(dx + panX_, panY_); + } + else + { + accessor_.GetBitmap().SetPan(panX_, dy + panY_); + } + } + else + { + accessor_.GetBitmap().SetPan(dx + panX_, dy + panY_); + } + } + } + }; + + + class CropBitmapTracker : public IWorldSceneMouseTracker + { + private: + UndoRedoStack& undoRedoStack_; + BitmapStack::BitmapAccessor accessor_; + BitmapStack::Corner corner_; + unsigned int cropX_; + unsigned int cropY_; + unsigned int cropWidth_; + unsigned int cropHeight_; + + class UndoRedoCommand : public BitmapCommandBase + { + private: + unsigned int sourceCropX_; + unsigned int sourceCropY_; + unsigned int sourceCropWidth_; + unsigned int sourceCropHeight_; + unsigned int targetCropX_; + unsigned int targetCropY_; + unsigned int targetCropWidth_; + unsigned int targetCropHeight_; + + protected: + virtual void UndoInternal(BitmapStack::Bitmap& bitmap) const + { + bitmap.SetCrop(sourceCropX_, sourceCropY_, sourceCropWidth_, sourceCropHeight_); + } + + virtual void RedoInternal(BitmapStack::Bitmap& bitmap) const + { + bitmap.SetCrop(targetCropX_, targetCropY_, targetCropWidth_, targetCropHeight_); + } + + public: + UndoRedoCommand(const CropBitmapTracker& tracker) : + BitmapCommandBase(tracker.accessor_), + sourceCropX_(tracker.cropX_), + sourceCropY_(tracker.cropY_), + sourceCropWidth_(tracker.cropWidth_), + sourceCropHeight_(tracker.cropHeight_) + { + tracker.accessor_.GetBitmap().GetCrop(targetCropX_, targetCropY_, + targetCropWidth_, targetCropHeight_); + } + }; + + + public: + CropBitmapTracker(UndoRedoStack& undoRedoStack, + BitmapStack& stack, + const ViewportGeometry& view, + size_t bitmap, + double x, + double y, + BitmapStack::Corner corner) : + undoRedoStack_(undoRedoStack), + accessor_(stack, bitmap), + corner_(corner) + { + if (accessor_.IsValid()) + { + accessor_.GetBitmap().GetCrop(cropX_, cropY_, cropWidth_, cropHeight_); + } + } + + virtual bool HasRender() const + { + return false; + } + + virtual void Render(CairoContext& context, + double zoom) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + virtual void MouseUp() + { + if (accessor_.IsValid()) + { + undoRedoStack_.Add(new UndoRedoCommand(*this)); + } + } + + virtual void MouseMove(int displayX, + int displayY, + double sceneX, + double sceneY) + { + if (accessor_.IsValid()) + { + unsigned int x, y; + + BitmapStack::Bitmap& bitmap = accessor_.GetBitmap(); + if (bitmap.GetPixel(x, y, sceneX, sceneY)) + { + unsigned int targetX, targetWidth; + + if (corner_ == BitmapStack::Corner_TopLeft || + corner_ == BitmapStack::Corner_BottomLeft) + { + targetX = std::min(x, cropX_ + cropWidth_); + targetWidth = cropX_ + cropWidth_ - targetX; + } + else + { + targetX = cropX_; + targetWidth = std::max(x, cropX_) - cropX_; + } + + unsigned int targetY, targetHeight; + + if (corner_ == BitmapStack::Corner_TopLeft || + corner_ == BitmapStack::Corner_TopRight) + { + targetY = std::min(y, cropY_ + cropHeight_); + targetHeight = cropY_ + cropHeight_ - targetY; + } + else + { + targetY = cropY_; + targetHeight = std::max(y, cropY_) - cropY_; + } + + bitmap.SetCrop(targetX, targetY, targetWidth, targetHeight); + } + } + } + }; + + + class ResizeBitmapTracker : public IWorldSceneMouseTracker + { + private: + UndoRedoStack& undoRedoStack_; + BitmapStack::BitmapAccessor accessor_; + bool roundScaling_; + double originalSpacingX_; + double originalSpacingY_; + double originalPanX_; + double originalPanY_; + BitmapStack::Corner oppositeCorner_; + double oppositeX_; + double oppositeY_; + double baseScaling_; + + static double ComputeDistance(double x1, + double y1, + double x2, + double y2) + { + double dx = x1 - x2; + double dy = y1 - y2; + return sqrt(dx * dx + dy * dy); + } + + class UndoRedoCommand : public BitmapCommandBase + { + private: + double sourceSpacingX_; + double sourceSpacingY_; + double sourcePanX_; + double sourcePanY_; + double targetSpacingX_; + double targetSpacingY_; + double targetPanX_; + double targetPanY_; + + protected: + virtual void UndoInternal(BitmapStack::Bitmap& bitmap) const + { + bitmap.SetPixelSpacing(sourceSpacingX_, sourceSpacingY_); + bitmap.SetPan(sourcePanX_, sourcePanY_); + } + + virtual void RedoInternal(BitmapStack::Bitmap& bitmap) const + { + bitmap.SetPixelSpacing(targetSpacingX_, targetSpacingY_); + bitmap.SetPan(targetPanX_, targetPanY_); + } + + public: + UndoRedoCommand(const ResizeBitmapTracker& tracker) : + BitmapCommandBase(tracker.accessor_), + sourceSpacingX_(tracker.originalSpacingX_), + sourceSpacingY_(tracker.originalSpacingY_), + sourcePanX_(tracker.originalPanX_), + sourcePanY_(tracker.originalPanY_), + targetSpacingX_(tracker.accessor_.GetBitmap().GetPixelSpacingX()), + targetSpacingY_(tracker.accessor_.GetBitmap().GetPixelSpacingY()), + targetPanX_(tracker.accessor_.GetBitmap().GetPanX()), + targetPanY_(tracker.accessor_.GetBitmap().GetPanY()) + { + } + }; + + + public: + ResizeBitmapTracker(UndoRedoStack& undoRedoStack, + BitmapStack& stack, + size_t bitmap, + double x, + double y, + BitmapStack::Corner corner, + bool roundScaling) : + undoRedoStack_(undoRedoStack), + accessor_(stack, bitmap), + roundScaling_(roundScaling) + { + if (accessor_.IsValid() && + accessor_.GetBitmap().IsResizeable()) + { + originalSpacingX_ = accessor_.GetBitmap().GetPixelSpacingX(); + originalSpacingY_ = accessor_.GetBitmap().GetPixelSpacingY(); + originalPanX_ = accessor_.GetBitmap().GetPanX(); + originalPanY_ = accessor_.GetBitmap().GetPanY(); + + switch (corner) + { + case BitmapStack::Corner_TopLeft: + oppositeCorner_ = BitmapStack::Corner_BottomRight; + break; + + case BitmapStack::Corner_TopRight: + oppositeCorner_ = BitmapStack::Corner_BottomLeft; + break; + + case BitmapStack::Corner_BottomLeft: + oppositeCorner_ = BitmapStack::Corner_TopRight; + break; + + case BitmapStack::Corner_BottomRight: + oppositeCorner_ = BitmapStack::Corner_TopLeft; + break; + + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + accessor_.GetBitmap().GetCorner(oppositeX_, oppositeY_, oppositeCorner_); + + double d = ComputeDistance(x, y, oppositeX_, oppositeY_); + if (d >= std::numeric_limits<float>::epsilon()) + { + baseScaling_ = 1.0 / d; + } + else + { + // Avoid division by zero in extreme cases + accessor_.Invalidate(); + } + } + } + + virtual bool HasRender() const + { + return false; + } + + virtual void Render(CairoContext& context, + double zoom) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + virtual void MouseUp() + { + if (accessor_.IsValid() && + accessor_.GetBitmap().IsResizeable()) + { + undoRedoStack_.Add(new UndoRedoCommand(*this)); + } + } + + virtual void MouseMove(int displayX, + int displayY, + double sceneX, + double sceneY) + { + static const double ROUND_SCALING = 0.1; + + if (accessor_.IsValid() && + accessor_.GetBitmap().IsResizeable()) + { + double scaling = ComputeDistance(oppositeX_, oppositeY_, sceneX, sceneY) * baseScaling_; + + if (roundScaling_) + { + scaling = round(scaling / ROUND_SCALING) * ROUND_SCALING; + } + + BitmapStack::Bitmap& bitmap = accessor_.GetBitmap(); + bitmap.SetPixelSpacing(scaling * originalSpacingX_, + scaling * originalSpacingY_); + + // Keep the opposite corner at a fixed location + double ox, oy; + bitmap.GetCorner(ox, oy, oppositeCorner_); + bitmap.SetPan(bitmap.GetPanX() + oppositeX_ - ox, + bitmap.GetPanY() + oppositeY_ - oy); + } + } + }; + + + class WindowingTracker : public IWorldSceneMouseTracker + { + public: + enum Action + { + Action_IncreaseWidth, + Action_DecreaseWidth, + Action_IncreaseCenter, + Action_DecreaseCenter + }; + + private: + UndoRedoStack& undoRedoStack_; + BitmapStack& stack_; + int clickX_; + int clickY_; + Action leftAction_; + Action rightAction_; + Action upAction_; + Action downAction_; + float strength_; + float sourceCenter_; + float sourceWidth_; + + static void ComputeAxisEffect(int& deltaCenter, + int& deltaWidth, + int delta, + Action actionNegative, + Action actionPositive) + { + if (delta < 0) + { + switch (actionNegative) + { + case Action_IncreaseWidth: + deltaWidth = -delta; + break; + + case Action_DecreaseWidth: + deltaWidth = delta; + break; + + case Action_IncreaseCenter: + deltaCenter = -delta; + break; + + case Action_DecreaseCenter: + deltaCenter = delta; + break; + + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + } + else if (delta > 0) + { + switch (actionPositive) + { + case Action_IncreaseWidth: + deltaWidth = delta; + break; + + case Action_DecreaseWidth: + deltaWidth = -delta; + break; + + case Action_IncreaseCenter: + deltaCenter = delta; + break; + + case Action_DecreaseCenter: + deltaCenter = -delta; + break; + + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + } + } + + + class UndoRedoCommand : public UndoRedoStack::ICommand + { + private: + BitmapStack& stack_; + float sourceCenter_; + float sourceWidth_; + float targetCenter_; + float targetWidth_; + + public: + UndoRedoCommand(const WindowingTracker& tracker) : + stack_(tracker.stack_), + sourceCenter_(tracker.sourceCenter_), + sourceWidth_(tracker.sourceWidth_) + { + stack_.GetWindowingWithDefault(targetCenter_, targetWidth_); + } + + virtual void Undo() const + { + stack_.SetWindowing(sourceCenter_, sourceWidth_); + } + + virtual void Redo() const + { + stack_.SetWindowing(targetCenter_, targetWidth_); + } + }; + + + public: + WindowingTracker(UndoRedoStack& undoRedoStack, + BitmapStack& stack, + int x, + int y, + Action leftAction, + Action rightAction, + Action upAction, + Action downAction) : + undoRedoStack_(undoRedoStack), + stack_(stack), + clickX_(x), + clickY_(y), + leftAction_(leftAction), + rightAction_(rightAction), + upAction_(upAction), + downAction_(downAction) + { + stack_.GetWindowingWithDefault(sourceCenter_, sourceWidth_); + + float minValue, maxValue; + stack.GetRange(minValue, maxValue); + + assert(minValue <= maxValue); + + float tmp; + + float delta = (maxValue - minValue); + if (delta <= 1) + { + tmp = 0; + } + else + { + tmp = log2(delta); + } + + strength_ = tmp - 7; + if (strength_ < 1) + { + strength_ = 1; + } + } + + virtual bool HasRender() const + { + return false; + } + + virtual void Render(CairoContext& context, + double zoom) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + virtual void MouseUp() + { + undoRedoStack_.Add(new UndoRedoCommand(*this)); + } + + + virtual void MouseMove(int displayX, + int displayY, + double sceneX, + double sceneY) + { + // https://bitbucket.org/osimis/osimis-webviewer-plugin/src/master/frontend/src/app/viewport/image-plugins/windowing-viewport-tool.class.js + + static const float SCALE = 1.0; + + int deltaCenter = 0; + int deltaWidth = 0; + + ComputeAxisEffect(deltaCenter, deltaWidth, displayX - clickX_, leftAction_, rightAction_); + ComputeAxisEffect(deltaCenter, deltaWidth, displayY - clickY_, upAction_, downAction_); + + float newCenter = sourceCenter_ + (deltaCenter / SCALE * strength_); + float newWidth = sourceWidth_ + (deltaWidth / SCALE * strength_); + stack_.SetWindowing(newCenter, newWidth); + } + }; + + + class BitmapStackWidget : + public WorldSceneWidget, + public IObservable, + public IObserver + { + private: + BitmapStack& stack_; + std::auto_ptr<Orthanc::Image> floatBuffer_; + std::auto_ptr<CairoSurface> cairoBuffer_; + bool invert_; + ImageInterpolation interpolation_; + + virtual bool RenderInternal(unsigned int width, + unsigned int height, + ImageInterpolation interpolation) + { + float windowCenter, windowWidth; + stack_.GetWindowingWithDefault(windowCenter, windowWidth); + + float x0 = windowCenter - windowWidth / 2.0f; + float x1 = windowCenter + windowWidth / 2.0f; + + if (windowWidth <= 0.001f) // Avoid division by zero at (*) + { + return false; + } + else + { + if (floatBuffer_.get() == NULL || + floatBuffer_->GetWidth() != width || + floatBuffer_->GetHeight() != height) + { + floatBuffer_.reset(new Orthanc::Image(Orthanc::PixelFormat_Float32, width, height, false)); + } + + if (cairoBuffer_.get() == NULL || + cairoBuffer_->GetWidth() != width || + cairoBuffer_->GetHeight() != height) + { + cairoBuffer_.reset(new CairoSurface(width, height)); + } + + stack_.Render(*floatBuffer_, GetView().GetMatrix(), interpolation); + + // Conversion from Float32 to BGRA32 (cairo). Very similar to + // GrayscaleFrameRenderer => TODO MERGE? + + Orthanc::ImageAccessor target; + cairoBuffer_->GetWriteableAccessor(target); + + float scaling = 255.0f / (x1 - x0); + + for (unsigned int y = 0; y < height; y++) + { + const float* p = reinterpret_cast<const float*>(floatBuffer_->GetConstRow(y)); + uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y)); + + for (unsigned int x = 0; x < width; x++, p++, q += 4) + { + uint8_t v = 0; + if (*p >= x1) + { + v = 255; + } + else if (*p <= x0) + { + v = 0; + } + else + { + // https://en.wikipedia.org/wiki/Linear_interpolation + v = static_cast<uint8_t>(scaling * (*p - x0)); // (*) + } + + if (invert_) + { + v = 255 - v; + } + + q[0] = v; + q[1] = v; + q[2] = v; + q[3] = 255; + } + } + + return true; + } + } + + + protected: + virtual Extent2D GetSceneExtent() + { + return stack_.GetSceneExtent(); + } + + virtual bool RenderScene(CairoContext& context, + const ViewportGeometry& view) + { + cairo_t* cr = context.GetObject(); + + if (RenderInternal(context.GetWidth(), context.GetHeight(), interpolation_)) + { + // https://www.cairographics.org/FAQ/#paint_from_a_surface + cairo_save(cr); + cairo_identity_matrix(cr); + cairo_set_source_surface(cr, cairoBuffer_->GetObject(), 0, 0); + cairo_paint(cr); + cairo_restore(cr); + } + else + { + // https://www.cairographics.org/FAQ/#clear_a_surface + context.SetSourceColor(0, 0, 0); + cairo_paint(cr); + } + + stack_.DrawControls(context, view.GetZoom()); + + return true; + } + + public: + BitmapStackWidget(MessageBroker& broker, + BitmapStack& stack, + const std::string& name) : + WorldSceneWidget(name), + IObservable(broker), + IObserver(broker), + stack_(stack), + invert_(false), + interpolation_(ImageInterpolation_Nearest) + { + stack.RegisterObserverCallback(new Callable<BitmapStackWidget, BitmapStack::GeometryChangedMessage>(*this, &BitmapStackWidget::OnGeometryChanged)); + stack.RegisterObserverCallback(new Callable<BitmapStackWidget, BitmapStack::ContentChangedMessage>(*this, &BitmapStackWidget::OnContentChanged)); + } + + BitmapStack& GetStack() const + { + return stack_; + } + + void OnGeometryChanged(const BitmapStack::GeometryChangedMessage& message) + { + LOG(INFO) << "Geometry has changed"; + FitContent(); + } + + void OnContentChanged(const BitmapStack::ContentChangedMessage& message) + { + LOG(INFO) << "Content has changed"; + NotifyContentChanged(); + } + + void SetInvert(bool invert) + { + if (invert_ != invert) + { + invert_ = invert; + NotifyContentChanged(); + } + } + + void SwitchInvert() + { + invert_ = !invert_; + NotifyContentChanged(); + } + + bool IsInvert() const + { + return invert_; + } + + void SetInterpolation(ImageInterpolation interpolation) + { + if (interpolation_ != interpolation) + { + interpolation_ = interpolation; + NotifyContentChanged(); + } + } + + ImageInterpolation GetInterpolation() const + { + return interpolation_; + } + }; + + + class BitmapStackInteractor : + public IWorldSceneInteractor, + public IObserver + { + private: + enum Tool + { + Tool_Move, + Tool_Rotate, + Tool_Crop, + Tool_Resize, + Tool_Windowing + }; + + + UndoRedoStack undoRedoStack_; + Tool tool_; + OrthancApiClient *orthanc_; + + + static double GetHandleSize() + { + return 10.0; + } + + + static BitmapStackWidget& GetWidget(WorldSceneWidget& widget) + { + return dynamic_cast<BitmapStackWidget&>(widget); + } + + + static BitmapStack& GetStack(WorldSceneWidget& widget) + { + return GetWidget(widget).GetStack(); + } + + + public: + BitmapStackInteractor(MessageBroker& broker) : + IObserver(broker), + tool_(Tool_Move), + orthanc_(NULL) + { + } + + virtual IWorldSceneMouseTracker* CreateMouseTracker(WorldSceneWidget& widget, + const ViewportGeometry& view, + MouseButton button, + KeyboardModifiers modifiers, + int viewportX, + int viewportY, + double x, + double y, + IStatusBar* statusBar) + { + if (button == MouseButton_Left) + { + size_t selected; + + if (tool_ == Tool_Windowing) + { + return new WindowingTracker(undoRedoStack_, GetStack(widget), + viewportX, viewportY, + WindowingTracker::Action_DecreaseWidth, + WindowingTracker::Action_IncreaseWidth, + WindowingTracker::Action_DecreaseCenter, + WindowingTracker::Action_IncreaseCenter); + } + else if (!GetStack(widget).GetSelectedBitmap(selected)) + { + size_t bitmap; + if (GetStack(widget).LookupBitmap(bitmap, x, y)) + { + LOG(INFO) << "Click on bitmap " << bitmap; + GetStack(widget).Select(bitmap); + } + + return NULL; + } + else if (tool_ == Tool_Crop || + tool_ == Tool_Resize) + { + BitmapStack::BitmapAccessor accessor(GetStack(widget), selected); + BitmapStack::Corner corner; + if (accessor.GetBitmap().LookupCorner(corner, x, y, view.GetZoom(), GetHandleSize())) + { + switch (tool_) + { + case Tool_Crop: + return new CropBitmapTracker(undoRedoStack_, GetStack(widget), view, selected, x, y, corner); + + case Tool_Resize: + return new ResizeBitmapTracker(undoRedoStack_, GetStack(widget), selected, x, y, corner, + (modifiers & KeyboardModifiers_Shift)); + + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + } + else + { + size_t bitmap; + + if (!GetStack(widget).LookupBitmap(bitmap, x, y) || + bitmap != selected) + { + GetStack(widget).Unselect(); + } + + return NULL; + } + } + else + { + size_t bitmap; + + if (GetStack(widget).LookupBitmap(bitmap, x, y) && + bitmap == selected) + { + switch (tool_) + { + case Tool_Move: + return new MoveBitmapTracker(undoRedoStack_, GetStack(widget), bitmap, x, y, + (modifiers & KeyboardModifiers_Shift)); + + case Tool_Rotate: + return new RotateBitmapTracker(undoRedoStack_, GetStack(widget), view, bitmap, x, y, + (modifiers & KeyboardModifiers_Shift)); + + default: + break; + } + + return NULL; + } + else + { + LOG(INFO) << "Click out of any bitmap"; + GetStack(widget).Unselect(); + return NULL; + } + } + } + else + { + return NULL; + } + } + + virtual void MouseOver(CairoContext& context, + WorldSceneWidget& widget, + const ViewportGeometry& view, + double x, + double y, + IStatusBar* statusBar) + { +#if 0 + if (statusBar != NULL) + { + char buf[64]; + sprintf(buf, "X = %.02f Y = %.02f (in cm)", x / 10.0, y / 10.0); + statusBar->SetMessage(buf); + } +#endif + + size_t selected; + if (GetStack(widget).GetSelectedBitmap(selected) && + (tool_ == Tool_Crop || + tool_ == Tool_Resize)) + { + BitmapStack::BitmapAccessor accessor(GetStack(widget), selected); + + BitmapStack::Corner corner; + if (accessor.GetBitmap().LookupCorner(corner, x, y, view.GetZoom(), GetHandleSize())) + { + accessor.GetBitmap().GetCorner(x, y, corner); + + double z = 1.0 / view.GetZoom(); + + context.SetSourceColor(255, 0, 0); + cairo_t* cr = context.GetObject(); + cairo_set_line_width(cr, 2.0 * z); + cairo_move_to(cr, x - GetHandleSize() * z, y - GetHandleSize() * z); + cairo_line_to(cr, x + GetHandleSize() * z, y - GetHandleSize() * z); + cairo_line_to(cr, x + GetHandleSize() * z, y + GetHandleSize() * z); + cairo_line_to(cr, x - GetHandleSize() * z, y + GetHandleSize() * z); + cairo_line_to(cr, x - GetHandleSize() * z, y - GetHandleSize() * z); + cairo_stroke(cr); + } + } + } + + virtual void MouseWheel(WorldSceneWidget& widget, + MouseWheelDirection direction, + KeyboardModifiers modifiers, + IStatusBar* statusBar) + { + } + + virtual void KeyPressed(WorldSceneWidget& widget, + KeyboardKeys key, + char keyChar, + KeyboardModifiers modifiers, + IStatusBar* statusBar) + { + switch (keyChar) + { + case 'a': + widget.FitContent(); + break; + + case 'c': + tool_ = Tool_Crop; + break; + + case 'e': + { + Orthanc::DicomMap tags; + + // Minimal set of tags to generate a valid CR image + tags.SetValue(Orthanc::DICOM_TAG_ACCESSION_NUMBER, "NOPE", false); + tags.SetValue(Orthanc::DICOM_TAG_BODY_PART_EXAMINED, "PELVIS", false); + tags.SetValue(Orthanc::DICOM_TAG_INSTANCE_NUMBER, "1", false); + //tags.SetValue(Orthanc::DICOM_TAG_LATERALITY, "", false); + tags.SetValue(Orthanc::DICOM_TAG_MANUFACTURER, "OSIMIS", false); + tags.SetValue(Orthanc::DICOM_TAG_MODALITY, "CR", false); + tags.SetValue(Orthanc::DICOM_TAG_PATIENT_BIRTH_DATE, "20000101", false); + tags.SetValue(Orthanc::DICOM_TAG_PATIENT_ID, "hello", false); + tags.SetValue(Orthanc::DICOM_TAG_PATIENT_NAME, "HELLO^WORLD", false); + tags.SetValue(Orthanc::DICOM_TAG_PATIENT_ORIENTATION, "", false); + tags.SetValue(Orthanc::DICOM_TAG_PATIENT_SEX, "M", false); + tags.SetValue(Orthanc::DICOM_TAG_REFERRING_PHYSICIAN_NAME, "HOUSE^MD", false); + tags.SetValue(Orthanc::DICOM_TAG_SERIES_NUMBER, "1", false); + tags.SetValue(Orthanc::DICOM_TAG_SOP_CLASS_UID, "1.2.840.10008.5.1.4.1.1.1", false); + tags.SetValue(Orthanc::DICOM_TAG_STUDY_ID, "STUDY", false); + tags.SetValue(Orthanc::DICOM_TAG_VIEW_POSITION, "", false); + + Export(GetWidget(widget), 0.1, 0.1, tags); + break; + } + + case 'i': + GetWidget(widget).SwitchInvert(); + break; + + case 'm': + tool_ = Tool_Move; + break; + + case 'n': + { + switch (GetWidget(widget).GetInterpolation()) + { + case ImageInterpolation_Nearest: + LOG(INFO) << "Switching to bilinear interpolation"; + GetWidget(widget).SetInterpolation(ImageInterpolation_Bilinear); + break; + + case ImageInterpolation_Bilinear: + LOG(INFO) << "Switching to nearest neighbor interpolation"; + GetWidget(widget).SetInterpolation(ImageInterpolation_Nearest); + break; + + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + break; + } + + case 'r': + tool_ = Tool_Rotate; + break; + + case 's': + tool_ = Tool_Resize; + break; + + case 'w': + tool_ = Tool_Windowing; + break; + + case 'y': + if (modifiers & KeyboardModifiers_Control) + { + undoRedoStack_.Redo(); + widget.NotifyContentChanged(); + } + break; + + case 'z': + if (modifiers & KeyboardModifiers_Control) + { + undoRedoStack_.Undo(); + widget.NotifyContentChanged(); + } + break; + + default: + break; + } + } + + + void SetOrthanc(OrthancApiClient& orthanc) + { + orthanc_ = &orthanc; + } + + + void Export(const BitmapStackWidget& widget, + double pixelSpacingX, + double pixelSpacingY, + const Orthanc::DicomMap& dicom) + { + if (pixelSpacingX <= 0 || + pixelSpacingY <= 0) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + + if (orthanc_ == NULL) + { + return; + } + + LOG(WARNING) << "Exporting DICOM"; + + Extent2D extent = widget.GetStack().GetSceneExtent(); + + int w = std::ceil(extent.GetWidth() / pixelSpacingX); + int h = std::ceil(extent.GetHeight() / pixelSpacingY); + + if (w < 0 || h < 0) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + Orthanc::Image layers(Orthanc::PixelFormat_Float32, + static_cast<unsigned int>(w), + static_cast<unsigned int>(h), false); + + Matrix view = LinearAlgebra::Product( + CreateScalingMatrix(1.0 / pixelSpacingX, 1.0 / pixelSpacingY), + CreateOffsetMatrix(-extent.GetX1(), -extent.GetY1())); + + widget.GetStack().Render(layers, view, widget.GetInterpolation()); + + Orthanc::Image rendered(Orthanc::PixelFormat_Grayscale16, + layers.GetWidth(), layers.GetHeight(), false); + Orthanc::ImageProcessing::Convert(rendered, layers); + + std::string base64; + + { + std::string content; + +#if EXPORT_USING_PAM == 1 + { + Orthanc::PamWriter writer; + writer.WriteToMemory(content, rendered); + } +#else + { + Orthanc::PngWriter writer; + writer.WriteToMemory(content, rendered); + } +#endif + + Orthanc::Toolbox::EncodeBase64(base64, content); + } + + std::set<Orthanc::DicomTag> tags; + dicom.GetTags(tags); + + Json::Value json = Json::objectValue; + json["Tags"] = Json::objectValue; + + for (std::set<Orthanc::DicomTag>::const_iterator + tag = tags.begin(); tag != tags.end(); ++tag) + { + const Orthanc::DicomValue& value = dicom.GetValue(*tag); + if (!value.IsNull() && + !value.IsBinary()) + { + json["Tags"][tag->Format()] = value.GetContent(); + } + } + + json["Tags"][Orthanc::DICOM_TAG_PHOTOMETRIC_INTERPRETATION.Format()] = + (widget.IsInvert() ? "MONOCHROME1" : "MONOCHROME2"); + + + // WARNING: The order of PixelSpacing is Y/X + char buf[32]; + sprintf(buf, "%0.8f\\%0.8f", pixelSpacingY, pixelSpacingX); + + json["Tags"][Orthanc::DICOM_TAG_PIXEL_SPACING.Format()] = buf; + + float center, width; + if (widget.GetStack().GetWindowing(center, width)) + { + json["Tags"][Orthanc::DICOM_TAG_WINDOW_CENTER.Format()] = + boost::lexical_cast<std::string>(lroundf(center)); + + json["Tags"][Orthanc::DICOM_TAG_WINDOW_WIDTH.Format()] = + boost::lexical_cast<std::string>(lroundf(width)); + } + +#if EXPORT_USING_PAM == 1 + json["Content"] = "data:" + std::string(Orthanc::MIME_PAM) + ";base64," + base64; +#else + json["Content"] = "data:" + std::string(Orthanc::MIME_PNG) + ";base64," + base64; +#endif + + orthanc_->PostJsonAsyncExpectJson( + "/tools/create-dicom", json, + new Callable<BitmapStackInteractor, OrthancApiClient::JsonResponseReadyMessage> + (*this, &BitmapStackInteractor::OnDicomExported), + NULL, NULL); + } + + + void OnDicomExported(const OrthancApiClient::JsonResponseReadyMessage& message) + { + LOG(WARNING) << "DICOM export was successful:" + << message.Response.toStyledString(); + } + }; + + + + namespace Samples + { + class SingleFrameEditorApplication : + public SampleSingleCanvasApplicationBase, + public IObserver + { + private: + std::auto_ptr<OrthancApiClient> orthancApiClient_; + std::auto_ptr<BitmapStack> stack_; + BitmapStackInteractor interactor_; + + public: + SingleFrameEditorApplication(MessageBroker& broker) : + IObserver(broker), + interactor_(broker) + { + } + + virtual void DeclareStartupOptions(boost::program_options::options_description& options) + { + boost::program_options::options_description generic("Sample options"); + generic.add_options() + ("instance", boost::program_options::value<std::string>(), + "Orthanc ID of the instance") + ("frame", boost::program_options::value<unsigned int>()->default_value(0), + "Number of the frame, for multi-frame DICOM instances") + ; + + options.add(generic); + } + + virtual void Initialize(StoneApplicationContext* context, + IStatusBar& statusBar, + const boost::program_options::variables_map& parameters) + { + using namespace OrthancStone; + + context_ = context; + + statusBar.SetMessage("Use the key \"a\" to reinitialize the layout"); + statusBar.SetMessage("Use the key \"c\" to crop"); + statusBar.SetMessage("Use the key \"e\" to export DICOM to the Orthanc server"); + statusBar.SetMessage("Use the key \"f\" to switch full screen"); + statusBar.SetMessage("Use the key \"i\" to invert contrast"); + statusBar.SetMessage("Use the key \"m\" to move objects"); + statusBar.SetMessage("Use the key \"n\" to switch between nearest neighbor and bilinear interpolation"); + statusBar.SetMessage("Use the key \"r\" to rotate objects"); + statusBar.SetMessage("Use the key \"s\" to resize objects (not applicable to DICOM bitmaps)"); + statusBar.SetMessage("Use the key \"w\" to change windowing"); + + statusBar.SetMessage("Use the key \"ctrl-z\" to undo action"); + statusBar.SetMessage("Use the key \"ctrl-y\" to redo action"); + + if (parameters.count("instance") != 1) + { + LOG(ERROR) << "The instance ID is missing"; + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + + std::string instance = parameters["instance"].as<std::string>(); + int frame = parameters["frame"].as<unsigned int>(); + + orthancApiClient_.reset(new OrthancApiClient(IObserver::broker_, context_->GetWebService())); + interactor_.SetOrthanc(*orthancApiClient_); + + Orthanc::FontRegistry fonts; + fonts.AddFromResource(Orthanc::EmbeddedResources::FONT_UBUNTU_MONO_BOLD_16); + + stack_.reset(new BitmapStack(IObserver::broker_, *orthancApiClient_)); + stack_->LoadFrame(instance, frame, false); //.SetPan(200, 0); + //stack_->LoadFrame("61f3143e-96f34791-ad6bbb8d-62559e75-45943e1b", 0, false); + + { + BitmapStack::Bitmap& bitmap = stack_->LoadText(fonts.GetFont(0), "Hello\nworld"); + //dynamic_cast<BitmapStack::AlphaBitmap&>(bitmap).SetForegroundValue(256); + dynamic_cast<BitmapStack::AlphaBitmap&>(bitmap).SetResizeable(true); + } + + { + BitmapStack::Bitmap& bitmap = stack_->LoadTestBlock(100, 50); + //dynamic_cast<BitmapStack::AlphaBitmap&>(bitmap).SetForegroundValue(256); + dynamic_cast<BitmapStack::AlphaBitmap&>(bitmap).SetResizeable(true); + dynamic_cast<BitmapStack::AlphaBitmap&>(bitmap).SetPan(0, 200); + } + + + mainWidget_ = new BitmapStackWidget(IObserver::broker_, *stack_, "main-widget"); + mainWidget_->SetTransmitMouseOver(true); + mainWidget_->SetInteractor(interactor_); + + //stack_->SetWindowing(128, 256); + } + }; + } +}
--- a/Applications/Samples/SingleVolumeApplication.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Applications/Samples/SingleVolumeApplication.h Mon Nov 05 10:05:33 2018 +0100 @@ -89,7 +89,7 @@ public: - virtual void DeclareCommandLineOptions(boost::program_options::options_description& options) + virtual void DeclareStartupOptions(boost::program_options::options_description& options) { boost::program_options::options_description generic("Sample options"); generic.add_options() @@ -108,8 +108,7 @@ options.add(generic); } - virtual void Initialize(BasicApplicationContext& context, - IStatusBar& statusBar, + virtual void Initialize(IStatusBar& statusBar, const boost::program_options::variables_map& parameters) { using namespace OrthancStone; @@ -147,8 +146,8 @@ throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); } - unsigned int threads = parameters["threads"].as<unsigned int>(); - bool reverse = parameters["reverse"].as<bool>(); + //unsigned int threads = parameters["threads"].as<unsigned int>(); + //bool reverse = parameters["reverse"].as<bool>(); std::string tmp = parameters["projection"].as<std::string>(); Orthanc::Toolbox::ToLowerCase(tmp); @@ -187,8 +186,8 @@ widget->AddLayer(new VolumeImageSource(*volume)); - context.AddInteractor(new Interactor(*volume, *widget, projection, 0)); - context.AddSlicedVolume(volume.release()); + context_->AddInteractor(new Interactor(*volume, *widget, projection, 0)); + context_->AddSlicedVolume(volume.release()); if (1) { @@ -208,14 +207,14 @@ widget->SetLayerStyle(0, s); } #else - std::auto_ptr<OrthancVolumeImage> ct(new OrthancVolumeImage(context.GetWebService(), false)); + std::auto_ptr<OrthancVolumeImage> ct(new OrthancVolumeImage(context_->GetWebService(), false)); //ct->ScheduleLoadSeries("15a6f44a-ac7b88fe-19c462d9-dddd918e-b01550d8"); // 0178023P //ct->ScheduleLoadSeries("dd069910-4f090474-7d2bba07-e5c10783-f9e4fb1d"); //ct->ScheduleLoadSeries("a04ecf01-79b2fc33-58239f7e-ad9db983-28e81afa"); // IBA //ct->ScheduleLoadSeries("03677739-1d8bca40-db1daf59-d74ff548-7f6fc9c0"); // 0522c0001 TCIA ct->ScheduleLoadSeries("295e8a13-dfed1320-ba6aebb2-9a13e20f-1b3eb953"); // Captain - std::auto_ptr<OrthancVolumeImage> pet(new OrthancVolumeImage(context.GetWebService(), true)); + std::auto_ptr<OrthancVolumeImage> pet(new OrthancVolumeImage(context_->GetWebService(), true)); //pet->ScheduleLoadSeries("48d2997f-8e25cd81-dd715b64-bd79cdcc-e8fcee53"); // 0178023P //pet->ScheduleLoadSeries("aabad2e7-80702b5d-e599d26c-4f13398e-38d58a9e"); //pet->ScheduleLoadInstance("830a69ff-8e4b5ee3-b7f966c8-bccc20fb-d322dceb"); // IBA 1 @@ -225,7 +224,7 @@ pet->ScheduleLoadInstance("f080888c-0ab7528a-f7d9c28c-84980eb1-ff3b0ae6"); // Captain 1 //pet->ScheduleLoadInstance("4f78055b-6499a2c5-1e089290-394acc05-3ec781c1"); // Captain 2 - std::auto_ptr<StructureSetLoader> rtStruct(new StructureSetLoader(context.GetWebService())); + std::auto_ptr<StructureSetLoader> rtStruct(new StructureSetLoader(context_->GetWebService())); //rtStruct->ScheduleLoadInstance("c2ebc17b-6b3548db-5e5da170-b8ecab71-ea03add3"); // 0178023P //rtStruct->ScheduleLoadInstance("54460695-ba3885ee-ddf61ac0-f028e31d-a6e474d9"); // IBA //rtStruct->ScheduleLoadInstance("17cd032b-ad92a438-ca05f06a-f9e96668-7e3e9e20"); // 0522c0001 TCIA @@ -235,12 +234,12 @@ widget->AddLayer(new VolumeImageSource(*pet)); widget->AddLayer(new DicomStructureSetRendererFactory(*rtStruct)); - context.AddInteractor(new Interactor(*pet, *widget, projection, 1)); - //context.AddInteractor(new VolumeImageInteractor(*ct, *widget, projection)); + context_->AddInteractor(new Interactor(*pet, *widget, projection, 1)); + //context_->AddInteractor(new VolumeImageInteractor(*ct, *widget, projection)); - context.AddSlicedVolume(ct.release()); - context.AddSlicedVolume(pet.release()); - context.AddVolumeLoader(rtStruct.release()); + context_->AddSlicedVolume(ct.release()); + context_->AddSlicedVolume(pet.release()); + context_->AddVolumeLoader(rtStruct.release()); { RenderStyle s; @@ -272,7 +271,7 @@ statusBar.SetMessage("Use the keys \"c\" to draw circles"); widget->SetTransmitMouseOver(true); - context.SetCentralWidget(widget.release()); + context_->SetCentralWidget(widget.release()); } }; }
--- a/Applications/Samples/TestPatternApplication.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Applications/Samples/TestPatternApplication.h Mon Nov 05 10:05:33 2018 +0100 @@ -34,7 +34,7 @@ class TestPatternApplication : public SampleApplicationBase { public: - virtual void DeclareCommandLineOptions(boost::program_options::options_description& options) + virtual void DeclareStartupOptions(boost::program_options::options_description& options) { boost::program_options::options_description generic("Sample options"); generic.add_options() @@ -44,8 +44,7 @@ options.add(generic); } - virtual void Initialize(BasicApplicationContext& context, - IStatusBar& statusBar, + virtual void Initialize(IStatusBar& statusBar, const boost::program_options::variables_map& parameters) { using namespace OrthancStone; @@ -56,8 +55,8 @@ layout->AddWidget(new TestCairoWidget(parameters["animate"].as<bool>())); layout->AddWidget(new TestWorldSceneWidget(parameters["animate"].as<bool>())); - context.SetCentralWidget(layout.release()); - context.SetUpdateDelay(25); // If animation, update the content each 25ms + context_->SetCentralWidget(layout.release()); + context_->SetUpdateDelay(25); // If animation, update the content each 25ms } }; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Web/index.html Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,24 @@ +<!doctype html> + +<html lang="us"> + <head> + <meta charset="utf-8" /> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> + + <!-- Disable pinch zoom on mobile devices --> + <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" /> + <meta name="HandheldFriendly" content="true" /> + + <title>Wasm Samples</title> + <link href="samples-styles.css" rel="stylesheet" /> + +<body> + <ul> + <li><a href="simple-viewer/simple-viewer.html">Simple Viewer Project (you may add ?studyId=XXX in the url)</a></li> + <li><a href="single-frame.html?instance=XXX">Single frame application (you must replace XXX by a valid instance id in the url)</a></li> + <li><a href="single-frame-editor.html?instance=XXX">Single frame editor application (you must replace XXX by a valid instance id in the url)</a></li> + <li><a href="simple-viewer-single-file.html">Simple Viewer Single file (to be replaced by other samples)</a></li> + </ul> +</body> + +</html> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Web/simple-viewer-single-file.html Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,34 @@ +<!doctype html> + +<html lang="us"> + <head> + <meta charset="utf-8" /> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> + + <!-- Disable pinch zoom on mobile devices --> + <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" /> + <meta name="HandheldFriendly" content="true" /> + + <title>Simple Viewer</title> + <link href="samples-styles.css" rel="stylesheet" /> + +<body> + <div id="breadcrumb"> + <span id="patient-id"></span> + <span id="study-description"></span> + <span id="series-description"></span> + </div> + <div> + <canvas id="canvas" data-width-ratio="20" data-height-ratio="50"></canvas> + <canvas id="canvas2" data-width-ratio="70" data-height-ratio="50"></canvas> + </div> + <div id="toolbox"> + <input tool-selector="line-measure" type="radio" name="radio-tool-selector" class="tool-selector">line + <input tool-selector="circle-measure" type="radio" name="radio-tool-selector" class="tool-selector">circle + <button action-trigger="action1" class="action-trigger">action1</button> + <button action-trigger="action2" class="action-trigger">action2</button> + </div> + <script type="text/javascript" src="app-simple-viewer-single-file.js"></script> +</body> + +</html> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Web/simple-viewer-single-file.ts Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,51 @@ +///<reference path='../../../Platforms/Wasm/wasm-application-runner.ts'/> + +InitializeWasmApplication("OrthancStoneSimpleViewerSingleFile", "/orthanc"); + +function SelectTool(toolName: string) { + var command = { + command: "selectTool", + args: { + toolName: toolName + } + }; + SendMessageToStoneApplication(JSON.stringify(command)); + +} + +function PerformAction(commandName: string) { + var command = { + command: commandName, + commandType: "simple", + args: {} + }; + SendMessageToStoneApplication(JSON.stringify(command)); +} + +//initializes the buttons +//----------------------- +// install "SelectTool" handlers +document.querySelectorAll("[tool-selector]").forEach((e) => { + console.log(e); + (e as HTMLInputElement).addEventListener("click", () => { + console.log(e); + SelectTool(e.attributes["tool-selector"].value); + }); +}); + +// install "PerformAction" handlers +document.querySelectorAll("[action-trigger]").forEach((e) => { + (e as HTMLInputElement).addEventListener("click", () => { + PerformAction(e.attributes["action-trigger"].value); + }); +}); + +// this method is called "from the C++ code" when the StoneApplication is updated. +// it can be used to update the UI of the application +function UpdateWebApplication(statusUpdateMessage: string) { + console.log(statusUpdateMessage); + + if (statusUpdateMessage.startsWith("series-description=")) { + document.getElementById("series-description").innerText = statusUpdateMessage.split("=")[1]; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Web/simple-viewer-single-file.tsconfig.json Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,9 @@ +{ + "extends" : "./tsconfig-samples", + "compilerOptions": { + "outFile": "../build-web/app-simple-viewer-single-file.js" + }, + "include" : [ + "simple-viewer-single-file.ts" + ] +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Web/single-frame-editor.html Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,22 @@ +<!doctype html> + +<html lang="us"> + <head> + <meta charset="utf-8" /> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> + + <!-- Disable pinch zoom on mobile devices --> + <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" /> + <meta name="HandheldFriendly" content="true" /> + + <title>Simple Viewer</title> + <link href="samples-styles.css" rel="stylesheet" /> + +<body> + <div> + <canvas id="canvas" data-width-ratio="100" data-height-ratio="100"></canvas> + </div> + <script type="text/javascript" src="app-single-frame-editor.js"></script> +</body> + +</html> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Web/single-frame-editor.ts Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,3 @@ +///<reference path='../../../Platforms/Wasm/wasm-application-runner.ts'/> + +InitializeWasmApplication("OrthancStoneSingleFrameEditor", "/orthanc");
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Web/single-frame-editor.tsconfig.json Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,9 @@ +{ + "extends" : "./tsconfig-samples", + "compilerOptions": { + "outFile": "../build-web/app-single-frame-editor.js" + }, + "include" : [ + "single-frame-editor.ts" + ] +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Web/single-frame.html Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,22 @@ +<!doctype html> + +<html lang="us"> + <head> + <meta charset="utf-8" /> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> + + <!-- Disable pinch zoom on mobile devices --> + <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" /> + <meta name="HandheldFriendly" content="true" /> + + <title>Simple Viewer</title> + <link href="samples-styles.css" rel="stylesheet" /> + +<body> + <div> + <canvas id="canvas" data-width-ratio="100" data-height-ratio="100"></canvas> + </div> + <script type="text/javascript" src="app-single-frame.js"></script> +</body> + +</html> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Web/single-frame.ts Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,3 @@ +///<reference path='../../../Platforms/Wasm/wasm-application-runner.ts'/> + +InitializeWasmApplication("OrthancStoneSingleFrame", "/orthanc");
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Web/single-frame.tsconfig.json Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,9 @@ +{ + "extends" : "./tsconfig-samples", + "compilerOptions": { + "outFile": "../build-web/app-single-frame.js" + }, + "include" : [ + "single-frame.ts" + ] +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/Web/tsconfig-samples.json Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,11 @@ +{ + "extends" : "../../../Platforms/Wasm/tsconfig-stone", + "compilerOptions": { + "sourceMap": false, + "lib" : [ + "es2017", + "dom", + "dom.iterable" + ] + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/build-wasm.sh Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,17 @@ +#!/bin/bash + +set -e + +currentDir=$(pwd) +samplesRootDir=$(pwd) + +mkdir -p $samplesRootDir/build-wasm +cd $samplesRootDir/build-wasm + +source ~/Downloads/emsdk/emsdk_env.sh +cmake -DCMAKE_TOOLCHAIN_FILE=${EMSCRIPTEN}/cmake/Modules/Platform/Emscripten.cmake -DCMAKE_BUILD_TYPE=Release -DSTONE_SOURCES_DIR=$currentDir/../../../orthanc-stone -DORTHANC_FRAMEWORK_SOURCE=path -DORTHANC_FRAMEWORK_ROOT=$currentDir/../../../orthanc -DALLOW_DOWNLOADS=ON .. -DENABLE_WASM=ON +make -j 5 + +echo "-- building the web application -- " +cd $currentDir +./build-web.sh \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/build-web.sh Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,43 @@ +#!/bin/bash + +set -e + +# this script currently assumes that the wasm code has been built on its side and is availabie in build-wasm/ + +currentDir=$(pwd) +samplesRootDir=$(pwd) + +outputDir=$samplesRootDir/build-web/ +mkdir -p $outputDir + +# files used by all single files samples +cp $samplesRootDir/Web/index.html $outputDir +cp $samplesRootDir/Web/samples-styles.css $outputDir + +# build simple-viewer-single-file (obsolete project) +cp $samplesRootDir/Web/simple-viewer-single-file.html $outputDir +tsc --allowJs --project $samplesRootDir/Web/simple-viewer-single-file.tsconfig.json +cp $currentDir/build-wasm/OrthancStoneSimpleViewerSingleFile.js $outputDir +cp $currentDir/build-wasm/OrthancStoneSimpleViewerSingleFile.wasm $outputDir + +# build single-frame +cp $samplesRootDir/Web/single-frame.html $outputDir +tsc --allowJs --project $samplesRootDir/Web/single-frame.tsconfig.json +cp $currentDir/build-wasm/OrthancStoneSingleFrame.js $outputDir +cp $currentDir/build-wasm/OrthancStoneSingleFrame.wasm $outputDir + +# build single-frame-editor +cp $samplesRootDir/Web/single-frame-editor.html $outputDir +tsc --allowJs --project $samplesRootDir/Web/single-frame-editor.tsconfig.json +cp $currentDir/build-wasm/OrthancStoneSingleFrameEditor.js $outputDir +cp $currentDir/build-wasm/OrthancStoneSingleFrameEditor.wasm $outputDir + +# build simple-viewer project +mkdir -p $outputDir/simple-viewer/ +cp $samplesRootDir/SimpleViewer/Wasm/simple-viewer.html $outputDir/simple-viewer/ +cp $samplesRootDir/SimpleViewer/Wasm/styles.css $outputDir/simple-viewer/ +tsc --allowJs --project $samplesRootDir/SimpleViewer/Wasm/tsconfig-simple-viewer.json +cp $currentDir/build-wasm/OrthancStoneSimpleViewer.js $outputDir/simple-viewer/ +cp $currentDir/build-wasm/OrthancStoneSimpleViewer.wasm $outputDir/simple-viewer/ + +cd $currentDir
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/nginx.local.conf Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,44 @@ +# Local config to serve the WASM samples static files and reverse proxy Orthanc. +# Uses port 9977 instead of 80. + +# `events` section is mandatory +events { + worker_connections 1024; # Default: 1024 +} + +http { + + # prevent nginx sync issues on OSX + proxy_buffering off; + + server { + listen 9977 default_server; + client_max_body_size 4G; + + # location may have to be adjusted depending on your OS and nginx install + include /etc/nginx/mime.types; + # if not in your system mime.types, add this line to support WASM: + # types { + # application/wasm wasm; + # } + + # serve WASM static files + root build-web/; + location / { + } + + # reverse proxy orthanc + location /orthanc/ { + rewrite /orthanc(.*) $1 break; + proxy_pass http://127.0.0.1:8042; + proxy_set_header Host $http_host; + proxy_set_header my-auth-header good-token; + proxy_request_buffering off; + proxy_max_temp_file_size 0; + client_max_body_size 0; + } + + + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/samples-library.js Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,8 @@ +// this file contains the JS method you want to expose to C++ code + +// mergeInto(LibraryManager.library, { +// ScheduleRedraw: function() { +// ScheduleRedraw(); +// } +// }); + \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Samples/tsconfig-stone.json Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,7 @@ +{ + "include" : [ + "../../Platforms/Wasm/stone-framework-loader.ts", + "../../Platforms/Wasm/wasm-application-runner.ts", + "../../Platforms/Wasm/wasm-viewport.ts" + ] +}
--- a/Applications/Sdl/SdlEngine.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Applications/Sdl/SdlEngine.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -29,21 +29,20 @@ namespace OrthancStone { - void SdlEngine::SetSize(BasicApplicationContext::ViewportLocker& locker, - unsigned int width, + void SdlEngine::SetSize(unsigned int width, unsigned int height) { - locker.GetViewport().SetSize(width, height); + context_.GetCentralViewport().SetSize(width, height); surface_.SetSize(width, height); } - + void SdlEngine::RenderFrame() { if (viewportChanged_) { - BasicApplicationContext::ViewportLocker locker(context_); - surface_.Render(locker.GetViewport()); + NativeStoneApplicationContext::GlobalMutexLocker locker(context_); + surface_.Render(context_.GetCentralViewport()); viewportChanged_ = false; } @@ -99,7 +98,7 @@ SdlEngine::SdlEngine(SdlWindow& window, - BasicApplicationContext& context) : + NativeStoneApplicationContext& context) : window_(window), context_(context), surface_(window), @@ -119,9 +118,9 @@ const uint8_t* keyboardState = SDL_GetKeyboardState(&scancodeCount); { - BasicApplicationContext::ViewportLocker locker(context_); - SetSize(locker, window_.GetWidth(), window_.GetHeight()); - locker.GetViewport().SetDefaultView(); + NativeStoneApplicationContext::GlobalMutexLocker locker(context_); + SetSize(window_.GetWidth(), window_.GetHeight()); + context_.GetCentralViewport().FitContent(); } bool stop = false; @@ -134,9 +133,9 @@ while (!stop && SDL_PollEvent(&event)) { - BasicApplicationContext::ViewportLocker locker(context_); + NativeStoneApplicationContext::GlobalMutexLocker locker(context_); - if (event.type == SDL_QUIT) + if (event.type == SDL_QUIT) { stop = true; break; @@ -147,48 +146,48 @@ switch (event.button.button) { - case SDL_BUTTON_LEFT: - locker.GetViewport().MouseDown(MouseButton_Left, event.button.x, event.button.y, modifiers); - break; + case SDL_BUTTON_LEFT: + context_.GetCentralViewport().MouseDown(MouseButton_Left, event.button.x, event.button.y, modifiers); + break; - case SDL_BUTTON_RIGHT: - locker.GetViewport().MouseDown(MouseButton_Right, event.button.x, event.button.y, modifiers); - break; + case SDL_BUTTON_RIGHT: + context_.GetCentralViewport().MouseDown(MouseButton_Right, event.button.x, event.button.y, modifiers); + break; - case SDL_BUTTON_MIDDLE: - locker.GetViewport().MouseDown(MouseButton_Middle, event.button.x, event.button.y, modifiers); - break; + case SDL_BUTTON_MIDDLE: + context_.GetCentralViewport().MouseDown(MouseButton_Middle, event.button.x, event.button.y, modifiers); + break; - default: - break; + default: + break; } } else if (event.type == SDL_MOUSEMOTION) { - locker.GetViewport().MouseMove(event.button.x, event.button.y); + context_.GetCentralViewport().MouseMove(event.button.x, event.button.y); } else if (event.type == SDL_MOUSEBUTTONUP) { - locker.GetViewport().MouseUp(); + context_.GetCentralViewport().MouseUp(); } else if (event.type == SDL_WINDOWEVENT) { switch (event.window.event) { - case SDL_WINDOWEVENT_LEAVE: - locker.GetViewport().MouseLeave(); - break; + case SDL_WINDOWEVENT_LEAVE: + context_.GetCentralViewport().MouseLeave(); + break; - case SDL_WINDOWEVENT_ENTER: - locker.GetViewport().MouseEnter(); - break; + case SDL_WINDOWEVENT_ENTER: + context_.GetCentralViewport().MouseEnter(); + break; - case SDL_WINDOWEVENT_SIZE_CHANGED: - SetSize(locker, event.window.data1, event.window.data2); - break; + case SDL_WINDOWEVENT_SIZE_CHANGED: + SetSize(event.window.data1, event.window.data2); + break; - default: - break; + default: + break; } } else if (event.type == SDL_MOUSEWHEEL) @@ -200,11 +199,11 @@ if (event.wheel.y > 0) { - locker.GetViewport().MouseWheel(MouseWheelDirection_Up, x, y, modifiers); + context_.GetCentralViewport().MouseWheel(MouseWheelDirection_Up, x, y, modifiers); } else if (event.wheel.y < 0) { - locker.GetViewport().MouseWheel(MouseWheelDirection_Down, x, y, modifiers); + context_.GetCentralViewport().MouseWheel(MouseWheelDirection_Down, x, y, modifiers); } } else if (event.type == SDL_KEYDOWN && @@ -214,53 +213,61 @@ switch (event.key.keysym.sym) { - case SDLK_a: locker.GetViewport().KeyPressed('a', modifiers); break; - case SDLK_b: locker.GetViewport().KeyPressed('b', modifiers); break; - case SDLK_c: locker.GetViewport().KeyPressed('c', modifiers); break; - case SDLK_d: locker.GetViewport().KeyPressed('d', modifiers); break; - case SDLK_e: locker.GetViewport().KeyPressed('e', modifiers); break; - case SDLK_f: window_.ToggleMaximize(); break; - case SDLK_g: locker.GetViewport().KeyPressed('g', modifiers); break; - case SDLK_h: locker.GetViewport().KeyPressed('h', modifiers); break; - case SDLK_i: locker.GetViewport().KeyPressed('i', modifiers); break; - case SDLK_j: locker.GetViewport().KeyPressed('j', modifiers); break; - case SDLK_k: locker.GetViewport().KeyPressed('k', modifiers); break; - case SDLK_l: locker.GetViewport().KeyPressed('l', modifiers); break; - case SDLK_m: locker.GetViewport().KeyPressed('m', modifiers); break; - case SDLK_n: locker.GetViewport().KeyPressed('n', modifiers); break; - case SDLK_o: locker.GetViewport().KeyPressed('o', modifiers); break; - case SDLK_p: locker.GetViewport().KeyPressed('p', modifiers); break; - case SDLK_q: stop = true; break; - case SDLK_r: locker.GetViewport().KeyPressed('r', modifiers); break; - case SDLK_s: locker.GetViewport().KeyPressed('s', modifiers); break; - case SDLK_t: locker.GetViewport().KeyPressed('t', modifiers); break; - case SDLK_u: locker.GetViewport().KeyPressed('u', modifiers); break; - case SDLK_v: locker.GetViewport().KeyPressed('v', modifiers); break; - case SDLK_w: locker.GetViewport().KeyPressed('w', modifiers); break; - case SDLK_x: locker.GetViewport().KeyPressed('x', modifiers); break; - case SDLK_y: locker.GetViewport().KeyPressed('y', modifiers); break; - case SDLK_z: locker.GetViewport().KeyPressed('z', modifiers); break; - case SDLK_KP_0: locker.GetViewport().KeyPressed('0', modifiers); break; - case SDLK_KP_1: locker.GetViewport().KeyPressed('1', modifiers); break; - case SDLK_KP_2: locker.GetViewport().KeyPressed('2', modifiers); break; - case SDLK_KP_3: locker.GetViewport().KeyPressed('3', modifiers); break; - case SDLK_KP_4: locker.GetViewport().KeyPressed('4', modifiers); break; - case SDLK_KP_5: locker.GetViewport().KeyPressed('5', modifiers); break; - case SDLK_KP_6: locker.GetViewport().KeyPressed('6', modifiers); break; - case SDLK_KP_7: locker.GetViewport().KeyPressed('7', modifiers); break; - case SDLK_KP_8: locker.GetViewport().KeyPressed('8', modifiers); break; - case SDLK_KP_9: locker.GetViewport().KeyPressed('9', modifiers); break; + case SDLK_a: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'a', modifiers); break; + case SDLK_b: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'b', modifiers); break; + case SDLK_c: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'c', modifiers); break; + case SDLK_d: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'd', modifiers); break; + case SDLK_e: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'e', modifiers); break; + case SDLK_f: window_.ToggleMaximize(); break; + case SDLK_g: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'g', modifiers); break; + case SDLK_h: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'h', modifiers); break; + case SDLK_i: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'i', modifiers); break; + case SDLK_j: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'j', modifiers); break; + case SDLK_k: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'k', modifiers); break; + case SDLK_l: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'l', modifiers); break; + case SDLK_m: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'm', modifiers); break; + case SDLK_n: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'n', modifiers); break; + case SDLK_o: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'o', modifiers); break; + case SDLK_p: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'p', modifiers); break; + case SDLK_q: stop = true; break; + case SDLK_r: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'r', modifiers); break; + case SDLK_s: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 's', modifiers); break; + case SDLK_t: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 't', modifiers); break; + case SDLK_u: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'u', modifiers); break; + case SDLK_v: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'v', modifiers); break; + case SDLK_w: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'w', modifiers); break; + case SDLK_x: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'x', modifiers); break; + case SDLK_y: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'y', modifiers); break; + case SDLK_z: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, 'z', modifiers); break; + case SDLK_KP_0: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, '0', modifiers); break; + case SDLK_KP_1: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, '1', modifiers); break; + case SDLK_KP_2: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, '2', modifiers); break; + case SDLK_KP_3: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, '3', modifiers); break; + case SDLK_KP_4: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, '4', modifiers); break; + case SDLK_KP_5: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, '5', modifiers); break; + case SDLK_KP_6: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, '6', modifiers); break; + case SDLK_KP_7: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, '7', modifiers); break; + case SDLK_KP_8: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, '8', modifiers); break; + case SDLK_KP_9: context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, '9', modifiers); break; - case SDLK_PLUS: - case SDLK_KP_PLUS: - locker.GetViewport().KeyPressed('+', modifiers); break; + case SDLK_PLUS: + case SDLK_KP_PLUS: + context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, '+', modifiers); break; + + case SDLK_MINUS: + case SDLK_KP_MINUS: + context_.GetCentralViewport().KeyPressed(KeyboardKeys_Generic, '-', modifiers); break; - case SDLK_MINUS: - case SDLK_KP_MINUS: - locker.GetViewport().KeyPressed('-', modifiers); break; - - default: - break; + case SDLK_RIGHT: + context_.GetCentralViewport().KeyPressed(KeyboardKeys_Right, 0, modifiers); break; + case SDLK_LEFT: + context_.GetCentralViewport().KeyPressed(KeyboardKeys_Left, 0, modifiers); break; + case SDLK_UP: + context_.GetCentralViewport().KeyPressed(KeyboardKeys_Up, 0, modifiers); break; + case SDLK_DOWN: + context_.GetCentralViewport().KeyPressed(KeyboardKeys_Down, 0, modifiers); break; + default: + break; } } }
--- a/Applications/Sdl/SdlEngine.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Applications/Sdl/SdlEngine.h Mon Nov 05 10:05:33 2018 +0100 @@ -24,7 +24,7 @@ #if ORTHANC_ENABLE_SDL == 1 #include "SdlCairoSurface.h" -#include "../BasicApplicationContext.h" +#include "../Generic/NativeStoneApplicationContext.h" namespace OrthancStone { @@ -32,12 +32,11 @@ { private: SdlWindow& window_; - BasicApplicationContext& context_; + NativeStoneApplicationContext& context_; SdlCairoSurface surface_; bool viewportChanged_; - void SetSize(BasicApplicationContext::ViewportLocker& locker, - unsigned int width, + void SetSize(unsigned int width, unsigned int height); void RenderFrame(); @@ -47,11 +46,11 @@ public: SdlEngine(SdlWindow& window, - BasicApplicationContext& context); + NativeStoneApplicationContext& context); virtual ~SdlEngine(); - virtual void NotifyChange(const IViewport& viewport) + virtual void OnViewportContentChanged(const IViewport& viewport) { viewportChanged_ = true; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Sdl/SdlStoneApplicationRunner.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,127 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#if ORTHANC_ENABLE_SDL != 1 +#error this file shall be included only with the ORTHANC_ENABLE_SDL set to 1 +#endif + +#include "SdlStoneApplicationRunner.h" +#include <boost/program_options.hpp> + +#include "../../Framework/Toolbox/MessagingToolbox.h" +#include "SdlEngine.h" + +#include <Core/Logging.h> +#include <Core/HttpClient.h> +#include <Core/Toolbox.h> +#include <Plugins/Samples/Common/OrthancHttpConnection.h> +#include "../../Platforms/Generic/OracleWebService.h" + +namespace OrthancStone +{ + void SdlStoneApplicationRunner::Initialize() + { + SdlWindow::GlobalInitialize(); + } + + void SdlStoneApplicationRunner::DeclareCommandLineOptions(boost::program_options::options_description& options) + { + boost::program_options::options_description sdl("SDL options"); + sdl.add_options() + ("width", boost::program_options::value<int>()->default_value(1024), "Initial width of the SDL window") + ("height", boost::program_options::value<int>()->default_value(768), "Initial height of the SDL window") + ("opengl", boost::program_options::value<bool>()->default_value(true), "Enable OpenGL in SDL") + ; + + options.add(sdl); + } + + void SdlStoneApplicationRunner::ParseCommandLineOptions(const boost::program_options::variables_map& parameters) + { + if (!parameters.count("width") || + !parameters.count("height") || + !parameters.count("opengl")) + { + LOG(ERROR) << "Parameter \"width\", \"height\" or \"opengl\" is missing"; + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + + int w = parameters["width"].as<int>(); + int h = parameters["height"].as<int>(); + if (w <= 0 || h <= 0) + { + LOG(ERROR) << "Parameters \"width\" and \"height\" must be positive"; + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + + width_ = static_cast<unsigned int>(w); + height_ = static_cast<unsigned int>(h); + LOG(WARNING) << "Initial display size: " << width_ << "x" << height_; + + enableOpenGl_ = parameters["opengl"].as<bool>(); + if (enableOpenGl_) + { + LOG(WARNING) << "OpenGL is enabled, disable it with option \"--opengl=off\" if the application crashes"; + } + else + { + LOG(WARNING) << "OpenGL is disabled, enable it with option \"--opengl=on\" for best performance"; + } + + } + + void SdlStoneApplicationRunner::Run(NativeStoneApplicationContext& context, const std::string& title, int argc, char* argv[]) + { + /************************************************************** + * Run the application inside a SDL window + **************************************************************/ + + LOG(WARNING) << "Starting the application"; + + SdlWindow window(title.c_str(), width_, height_, enableOpenGl_); + SdlEngine sdl(window, context); + + { + NativeStoneApplicationContext::GlobalMutexLocker locker(context); + context.GetCentralViewport().Register(sdl); // (*) + } + + context.Start(); + sdl.Run(); + + LOG(WARNING) << "Stopping the application"; + + // Don't move the "Stop()" command below out of the block, + // otherwise the application might crash, because the + // "SdlEngine" is an observer of the viewport (*) and the + // update thread started by "context.Start()" would call a + // destructed object (the "SdlEngine" is deleted with the + // lexical scope). + context.Stop(); + } + + void SdlStoneApplicationRunner::Finalize() + { + SdlWindow::GlobalFinalize(); + } + + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Sdl/SdlStoneApplicationRunner.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,53 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "../Generic/NativeStoneApplicationRunner.h" + +#if ORTHANC_ENABLE_SDL != 1 +#error this file shall be included only with the ORTHANC_ENABLE_SDL set to 1 +#endif + +#include <SDL.h> // Necessary to avoid undefined reference to `SDL_main' + +namespace OrthancStone +{ + class SdlStoneApplicationRunner : public NativeStoneApplicationRunner + { + unsigned int width_; + unsigned int height_; + bool enableOpenGl_; + public: + SdlStoneApplicationRunner(MessageBroker& broker, + IStoneApplication& application) + : NativeStoneApplicationRunner(broker, application) + { + } + + virtual void Initialize(); + virtual void DeclareCommandLineOptions(boost::program_options::options_description& options); + virtual void Run(NativeStoneApplicationContext& context, const std::string& title, int argc, char* argv[]); + virtual void ParseCommandLineOptions(const boost::program_options::variables_map& parameters); + virtual void Finalize(); + }; + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/StoneApplicationContext.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,26 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#include "StoneApplicationContext.h" + +namespace OrthancStone +{ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/StoneApplicationContext.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,56 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "../Framework/Toolbox/IWebService.h" +#include "../Framework/Viewport/WidgetViewport.h" + +#include <list> + +namespace OrthancStone +{ + // a StoneApplicationContext contains the services that a StoneApplication + // uses and that depends on the environment in which the Application executes. + // I.e, the StoneApplicationContext provides a WebService interface such that + // the StoneApplication can perform HTTP requests. In a WASM environment, + // the WebService is provided by the browser while, in a native environment, + // the WebService is provided by the OracleWebService (a C++ Http client) + class StoneApplicationContext : public boost::noncopyable + { + + protected: + IWebService* webService_; + public: + StoneApplicationContext() + : webService_(NULL) + { + } + + IWebService& GetWebService() {return *webService_;} + void SetWebService(IWebService& webService) + { + webService_ = &webService; + } + + virtual ~StoneApplicationContext() {} + }; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Wasm/StartupParametersBuilder.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,43 @@ +#include "StartupParametersBuilder.h" + +namespace OrthancStone +{ + void StartupParametersBuilder::Clear() { + startupParameters_.clear(); + } + + void StartupParametersBuilder::SetStartupParameter(const char* name, const char* value) { + startupParameters_.push_back(std::make_tuple(name, value)); + } + + void StartupParametersBuilder::GetStartupParameters(boost::program_options::variables_map& parameters, const boost::program_options::options_description& options) { + + const char* argv[startupParameters_.size() + 1]; + int argCounter = 0; + argv[0] = "Toto.exe"; + argCounter++; + + std::string cmdLine = ""; + for (StartupParameters::const_iterator it = startupParameters_.begin(); it != startupParameters_.end(); it++) { + char* arg = new char[128]; + snprintf(arg, 128, "--%s=%s", std::get<0>(*it).c_str(), std::get<1>(*it).c_str()); + argv[argCounter] = arg; + cmdLine = cmdLine + " --" + std::get<0>(*it) + "=" + std::get<1>(*it); + argCounter++; + } + + printf("simulated cmdLine = %s\n", cmdLine.c_str()); + + try + { + boost::program_options::store(boost::program_options::command_line_parser(argCounter, argv). + options(options).run(), parameters); + boost::program_options::notify(parameters); + } + catch (boost::program_options::error& e) + { + printf("Error while parsing the command-line arguments: %s\n", e.what()); + } + + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Applications/Wasm/StartupParametersBuilder.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,50 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include <boost/program_options.hpp> +#include <tuple> + +#if ORTHANC_ENABLE_SDL == 1 +#error this file shall be included only with the ORTHANC_ENABLE_SDL set to 0 +#endif + +namespace OrthancStone +{ + // This class is used to generate boost program options from a dico. + // In a Wasm context, startup options are passed as URI arguments that + // are then passed to this class as a dico. + // This class regenerates a fake command-line and parses it to produce + // the same output as if the app was started at command-line. + class StartupParametersBuilder + { + typedef std::list<std::tuple<std::string, std::string>> StartupParameters; + StartupParameters startupParameters_; + + public: + + void Clear(); + void SetStartupParameter(const char* name, const char* value); + void GetStartupParameters(boost::program_options::variables_map& parameters_, const boost::program_options::options_description& options); + }; + +}
--- a/Framework/Layers/CircleMeasureTracker.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Layers/CircleMeasureTracker.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -24,8 +24,6 @@ #include "CircleMeasureTracker.h" -#include "../Viewport/CairoFont.h" - #include <stdio.h> namespace OrthancStone @@ -37,14 +35,14 @@ uint8_t red, uint8_t green, uint8_t blue, - unsigned int fontSize) : + const Orthanc::Font& font) : statusBar_(statusBar), slice_(slice), x1_(x), y1_(y), x2_(x), y2_(y), - fontSize_(fontSize) + font_(font) { color_[0] = red; color_[1] = green; @@ -73,12 +71,7 @@ cairo_stroke(cr); cairo_restore(cr); - if (fontSize_ != 0) - { - cairo_move_to(cr, x, y); - CairoFont font("sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); - font.Draw(context, FormatRadius(), static_cast<double>(fontSize_) / zoom); - } + context.DrawText(font_, FormatRadius(), x, y, BitmapAnchor_Center); } @@ -97,7 +90,9 @@ return buf; } - void CircleMeasureTracker::MouseMove(double x, + void CircleMeasureTracker::MouseMove(int displayX, + int displayY, + double x, double y) { x2_ = x;
--- a/Framework/Layers/CircleMeasureTracker.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Layers/CircleMeasureTracker.h Mon Nov 05 10:05:33 2018 +0100 @@ -26,19 +26,21 @@ #include "../Viewport/IStatusBar.h" #include "../Toolbox/CoordinateSystem3D.h" +#include <Core/Images/Font.h> + namespace OrthancStone { class CircleMeasureTracker : public IWorldSceneMouseTracker { private: - IStatusBar* statusBar_; - CoordinateSystem3D slice_; - double x1_; - double y1_; - double x2_; - double y2_; - uint8_t color_[3]; - unsigned int fontSize_; + IStatusBar* statusBar_; + CoordinateSystem3D slice_; + double x1_; + double y1_; + double x2_; + double y2_; + uint8_t color_[3]; + const Orthanc::Font& font_; public: CircleMeasureTracker(IStatusBar* statusBar, @@ -48,8 +50,13 @@ uint8_t red, uint8_t green, uint8_t blue, - unsigned int fontSize); + const Orthanc::Font& font); + virtual bool HasRender() const + { + return true; + } + virtual void Render(CairoContext& context, double zoom); @@ -62,7 +69,9 @@ // Possibly create a new landmark "volume" with the circle in subclasses } - virtual void MouseMove(double x, + virtual void MouseMove(int displayX, + int displayY, + double x, double y); }; }
--- a/Framework/Layers/DicomStructureSetRendererFactory.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Layers/DicomStructureSetRendererFactory.h Mon Nov 05 10:05:33 2018 +0100 @@ -37,21 +37,22 @@ { LayerSourceBase::NotifyGeometryReady(); } - + virtual void NotifyGeometryError(const IVolumeLoader& loader) { LayerSourceBase::NotifyGeometryError(); } - + virtual void NotifyContentChange(const IVolumeLoader& loader) { LayerSourceBase::NotifyContentChange(); } - + StructureSetLoader& loader_; public: - DicomStructureSetRendererFactory(StructureSetLoader& loader) : + DicomStructureSetRendererFactory(MessageBroker& broker, StructureSetLoader& loader) : + LayerSourceBase(broker), loader_(loader) { loader_.Register(*this);
--- a/Framework/Layers/GrayscaleFrameRenderer.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Layers/GrayscaleFrameRenderer.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -27,6 +27,8 @@ { CairoSurface* GrayscaleFrameRenderer::GenerateDisplay(const RenderStyle& style) { + assert(frame_->GetFormat() == Orthanc::PixelFormat_Float32); + std::auto_ptr<CairoSurface> result; float windowCenter, windowWidth; @@ -82,7 +84,7 @@ v = static_cast<uint8_t>(255.0f * (*p - x0) / (x1 - x0)); } - if (style.reverse_) + if (style.reverse_ ^ (photometric_ == Orthanc::PhotometricInterpretation_Monochrome1)) { v = 255 - v; } @@ -119,14 +121,15 @@ FrameRenderer(frameSlice, pixelSpacingX, pixelSpacingY, isFullQuality), frame_(frame), defaultWindowCenter_(converter.GetDefaultWindowCenter()), - defaultWindowWidth_(converter.GetDefaultWindowWidth()) + defaultWindowWidth_(converter.GetDefaultWindowWidth()), + photometric_(converter.GetPhotometricInterpretation()) { if (frame == NULL) { throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); } - converter.ConvertFrame(frame_); + converter.ConvertFrameInplace(frame_); assert(frame_.get() != NULL); if (frame_->GetFormat() != Orthanc::PixelFormat_Float32)
--- a/Framework/Layers/GrayscaleFrameRenderer.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Layers/GrayscaleFrameRenderer.h Mon Nov 05 10:05:33 2018 +0100 @@ -32,6 +32,7 @@ std::auto_ptr<Orthanc::ImageAccessor> frame_; // In Float32 float defaultWindowCenter_; float defaultWindowWidth_; + Orthanc::PhotometricInterpretation photometric_; protected: virtual CairoSurface* GenerateDisplay(const RenderStyle& style);
--- a/Framework/Layers/ILayerSource.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Layers/ILayerSource.h Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -23,48 +23,77 @@ #include "ILayerRenderer.h" #include "../Toolbox/Slice.h" +#include "../../Framework/Messages/IObservable.h" +#include "../../Framework/Messages/IMessage.h" +#include "Core/Images/Image.h" +#include <boost/shared_ptr.hpp> namespace OrthancStone { - class ILayerSource : public boost::noncopyable + class ILayerSource : public IObservable { public: - class IObserver : public boost::noncopyable + + typedef OriginMessage<MessageType_LayerSource_GeometryReady, ILayerSource> GeometryReadyMessage; + typedef OriginMessage<MessageType_LayerSource_GeometryError, ILayerSource> GeometryErrorMessage; + typedef OriginMessage<MessageType_LayerSource_ContentChanged, ILayerSource> ContentChangedMessage; + + struct SliceChangedMessage : public OriginMessage<MessageType_LayerSource_SliceChanged, ILayerSource> { - public: - virtual ~IObserver() + const Slice& slice_; + SliceChangedMessage(ILayerSource& origin, const Slice& slice) + : OriginMessage(origin), + slice_(slice) { } + }; - // Triggered as soon as the source has enough information to - // answer to "GetExtent()" - virtual void NotifyGeometryReady(const ILayerSource& source) = 0; - - virtual void NotifyGeometryError(const ILayerSource& source) = 0; - - // Triggered if the content of several slices in the source - // volume has changed - virtual void NotifyContentChange(const ILayerSource& source) = 0; + struct LayerReadyMessage : public OriginMessage<MessageType_LayerSource_LayerReady, ILayerSource> + { + std::auto_ptr<ILayerRenderer>& renderer_; + const CoordinateSystem3D& slice_; + bool isError_; - // Triggered if the content of some individual slice in the - // source volume has changed - virtual void NotifySliceChange(const ILayerSource& source, - const Slice& slice) = 0; - - // The layer must be deleted by the observer that releases the - // std::auto_ptr - virtual void NotifyLayerReady(std::auto_ptr<ILayerRenderer>& layer, - const ILayerSource& source, - const CoordinateSystem3D& slice, - bool isError) = 0; // TODO Shouldn't this be separate as NotifyLayerError? + LayerReadyMessage(ILayerSource& origin, + std::auto_ptr<ILayerRenderer>& layer, + const CoordinateSystem3D& slice, + bool isError // TODO Shouldn't this be separate as NotifyLayerError? + ) + : OriginMessage(origin), + renderer_(layer), + slice_(slice), + isError_(isError) + { + } + }; + + struct ImageReadyMessage : public OriginMessage<MessageType_LayerSource_ImageReady, ILayerSource> + { + boost::shared_ptr<Orthanc::ImageAccessor> image_; + SliceImageQuality imageQuality_; + const Slice& slice_; + + ImageReadyMessage(ILayerSource& origin, + boost::shared_ptr<Orthanc::ImageAccessor> image, + SliceImageQuality imageQuality, + const Slice& slice + ) + : OriginMessage(origin), + image_(image), + imageQuality_(imageQuality), + slice_(slice) + { + } }; + ILayerSource(MessageBroker& broker) + : IObservable(broker) + {} + virtual ~ILayerSource() { } - virtual void Register(IObserver& observer) = 0; - virtual bool GetExtent(std::vector<Vector>& points, const CoordinateSystem3D& viewportSlice) = 0;
--- a/Framework/Layers/LayerSourceBase.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Layers/LayerSourceBase.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -25,63 +25,39 @@ namespace OrthancStone { - namespace - { - class LayerReadyFunctor : public boost::noncopyable - { - private: - std::auto_ptr<ILayerRenderer> layer_; - const CoordinateSystem3D& slice_; - bool isError_; - - public: - LayerReadyFunctor(ILayerRenderer* layer, - const CoordinateSystem3D& slice, - bool isError) : - layer_(layer), - slice_(slice), - isError_(isError) - { - } - - void operator() (ILayerSource::IObserver& observer, - const ILayerSource& source) - { - observer.NotifyLayerReady(layer_, source, slice_, isError_); - } - }; - } - void LayerSourceBase::NotifyGeometryReady() { - observers_.Apply(*this, &IObserver::NotifyGeometryReady); + EmitMessage(ILayerSource::GeometryReadyMessage(*this)); } void LayerSourceBase::NotifyGeometryError() { - observers_.Apply(*this, &IObserver::NotifyGeometryError); - } + EmitMessage(ILayerSource::GeometryErrorMessage(*this)); + } void LayerSourceBase::NotifyContentChange() { - observers_.Apply(*this, &IObserver::NotifyContentChange); + EmitMessage(ILayerSource::ContentChangedMessage(*this)); } void LayerSourceBase::NotifySliceChange(const Slice& slice) { - observers_.Apply(*this, &IObserver::NotifySliceChange, slice); + EmitMessage(ILayerSource::SliceChangedMessage(*this, slice)); } void LayerSourceBase::NotifyLayerReady(ILayerRenderer* layer, const CoordinateSystem3D& slice, bool isError) { - LayerReadyFunctor functor(layer, slice, isError); - observers_.Notify(*this, functor); + std::auto_ptr<ILayerRenderer> renderer(layer); + EmitMessage(ILayerSource::LayerReadyMessage(*this, renderer, slice, isError)); } - void LayerSourceBase::Register(IObserver& observer) + void LayerSourceBase::NotifyImageReady(boost::shared_ptr<Orthanc::ImageAccessor> image, + SliceImageQuality imageQuality, + const Slice& slice) { - observers_.Register(observer); + EmitMessage(ILayerSource::ImageReadyMessage(*this, image, imageQuality, slice)); } + }
--- a/Framework/Layers/LayerSourceBase.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Layers/LayerSourceBase.h Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -26,13 +26,10 @@ namespace OrthancStone { + class SmartLoader; + class LayerSourceBase : public ILayerSource { - private: - typedef ObserversRegistry<ILayerSource, IObserver> Observers; - - Observers observers_; - protected: void NotifyGeometryReady(); @@ -46,7 +43,15 @@ const CoordinateSystem3D& slice, bool isError); - public: - virtual void Register(IObserver& observer); + void NotifyImageReady(boost::shared_ptr<Orthanc::ImageAccessor> image, + SliceImageQuality imageQuality, + const Slice& slice); + + LayerSourceBase(MessageBroker& broker) + : ILayerSource(broker) + { + } + + friend class SmartLoader; }; }
--- a/Framework/Layers/LineMeasureTracker.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Layers/LineMeasureTracker.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -21,8 +21,6 @@ #include "LineMeasureTracker.h" -#include "../Viewport/CairoFont.h" - #include <stdio.h> namespace OrthancStone @@ -34,14 +32,14 @@ uint8_t red, uint8_t green, uint8_t blue, - unsigned int fontSize) : + const Orthanc::Font& font) : statusBar_(statusBar), slice_(slice), x1_(x), y1_(y), x2_(x), y2_(y), - fontSize_(fontSize) + font_(font) { color_[0] = red; color_[1] = green; @@ -60,11 +58,13 @@ cairo_line_to(cr, x2_, y2_); cairo_stroke(cr); - if (fontSize_ != 0) + if (y2_ - y1_ < 0) { - cairo_move_to(cr, x2_, y2_ - static_cast<double>(fontSize_) / zoom); - CairoFont font("sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); - font.Draw(context, FormatLength(), static_cast<double>(fontSize_) / zoom); + context.DrawText(font_, FormatLength(), x2_, y2_ - 5, BitmapAnchor_BottomCenter); + } + else + { + context.DrawText(font_, FormatLength(), x2_, y2_ + 5, BitmapAnchor_TopCenter); } } @@ -84,7 +84,9 @@ return buf; } - void LineMeasureTracker::MouseMove(double x, + void LineMeasureTracker::MouseMove(int displayX, + int displayY, + double x, double y) { x2_ = x;
--- a/Framework/Layers/LineMeasureTracker.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Layers/LineMeasureTracker.h Mon Nov 05 10:05:33 2018 +0100 @@ -31,14 +31,15 @@ class LineMeasureTracker : public IWorldSceneMouseTracker { private: - IStatusBar* statusBar_; - CoordinateSystem3D slice_; - double x1_; - double y1_; - double x2_; - double y2_; - uint8_t color_[3]; - unsigned int fontSize_; + IStatusBar* statusBar_; + CoordinateSystem3D slice_; + double x1_; + double y1_; + double x2_; + double y2_; + uint8_t color_[3]; + unsigned int fontSize_; + const Orthanc::Font& font_; public: LineMeasureTracker(IStatusBar* statusBar, @@ -48,8 +49,13 @@ uint8_t red, uint8_t green, uint8_t blue, - unsigned int fontSize); - + const Orthanc::Font& font); + + virtual bool HasRender() const + { + return true; + } + virtual void Render(CairoContext& context, double zoom); @@ -62,7 +68,9 @@ // Possibly create a new landmark "volume" with the line in subclasses } - virtual void MouseMove(double x, + virtual void MouseMove(int displayX, + int displayY, + double x, double y); }; }
--- a/Framework/Layers/OrthancFrameLayerSource.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Layers/OrthancFrameLayerSource.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -31,9 +31,10 @@ namespace OrthancStone { - void OrthancFrameLayerSource::NotifyGeometryReady(const OrthancSlicesLoader& loader) + + void OrthancFrameLayerSource::OnSliceGeometryReady(const OrthancSlicesLoader::SliceGeometryReadyMessage& message) { - if (loader.GetSliceCount() > 0) + if (message.origin_.GetSliceCount() > 0) { LayerSourceBase::NotifyGeometryReady(); } @@ -43,35 +44,41 @@ } } - void OrthancFrameLayerSource::NotifyGeometryError(const OrthancSlicesLoader& loader) + void OrthancFrameLayerSource::OnSliceGeometryError(const OrthancSlicesLoader::SliceGeometryErrorMessage& message) { LayerSourceBase::NotifyGeometryError(); } - void OrthancFrameLayerSource::NotifySliceImageReady(const OrthancSlicesLoader& loader, - unsigned int sliceIndex, - const Slice& slice, - std::auto_ptr<Orthanc::ImageAccessor>& image, - SliceImageQuality quality) + void OrthancFrameLayerSource::OnSliceImageReady(const OrthancSlicesLoader::SliceImageReadyMessage& message) { - bool isFull = (quality == SliceImageQuality_Full); - LayerSourceBase::NotifyLayerReady(FrameRenderer::CreateRenderer(image.release(), slice, isFull), - slice.GetGeometry(), false); + // first notify that the image is ready (targeted to, i.e: an image cache) + LayerSourceBase::NotifyImageReady(message.image_, message.effectiveQuality_, message.slice_); + + // then notify that the layer is ready for render + bool isFull = (message.effectiveQuality_ == SliceImageQuality_FullPng || message.effectiveQuality_ == SliceImageQuality_FullPam); + std::auto_ptr<Orthanc::ImageAccessor> accessor(new Orthanc::ImageAccessor()); + message.image_->GetReadOnlyAccessor(*accessor); + + LayerSourceBase::NotifyLayerReady(FrameRenderer::CreateRenderer(accessor.release(), message.slice_, isFull), + message.slice_.GetGeometry(), false); + } - void OrthancFrameLayerSource::NotifySliceImageError(const OrthancSlicesLoader& loader, - unsigned int sliceIndex, - const Slice& slice, - SliceImageQuality quality) + void OrthancFrameLayerSource::OnSliceImageError(const OrthancSlicesLoader::SliceImageErrorMessage& message) { - LayerSourceBase::NotifyLayerReady(NULL, slice.GetGeometry(), true); + LayerSourceBase::NotifyLayerReady(NULL, message.slice_.GetGeometry(), true); } - - OrthancFrameLayerSource::OrthancFrameLayerSource(IWebService& orthanc) : - loader_(*this, orthanc), - quality_(SliceImageQuality_Full) + OrthancFrameLayerSource::OrthancFrameLayerSource(MessageBroker& broker, OrthancApiClient& orthanc) : + LayerSourceBase(broker), + IObserver(broker), + loader_(broker, orthanc), + quality_(SliceImageQuality_FullPng) { + loader_.RegisterObserverCallback(new Callable<OrthancFrameLayerSource, OrthancSlicesLoader::SliceGeometryReadyMessage>(*this, &OrthancFrameLayerSource::OnSliceGeometryReady)); + loader_.RegisterObserverCallback(new Callable<OrthancFrameLayerSource, OrthancSlicesLoader::SliceGeometryErrorMessage>(*this, &OrthancFrameLayerSource::OnSliceGeometryError)); + loader_.RegisterObserverCallback(new Callable<OrthancFrameLayerSource, OrthancSlicesLoader::SliceImageReadyMessage>(*this, &OrthancFrameLayerSource::OnSliceImageReady)); + loader_.RegisterObserverCallback(new Callable<OrthancFrameLayerSource, OrthancSlicesLoader::SliceImageErrorMessage>(*this, &OrthancFrameLayerSource::OnSliceImageError)); } @@ -98,6 +105,7 @@ const CoordinateSystem3D& viewportSlice) { size_t index; + if (loader_.IsGeometryReady() && loader_.LookupSlice(index, viewportSlice)) { @@ -115,17 +123,10 @@ { size_t index; - if (loader_.IsGeometryReady()) + if (loader_.IsGeometryReady() && + loader_.LookupSlice(index, viewportSlice)) { - if (loader_.LookupSlice(index, viewportSlice)) - { - loader_.ScheduleLoadSliceImage(index, quality_); - } - else - { - Slice slice; - LayerSourceBase::NotifyLayerReady(NULL, slice.GetGeometry(), true); - } + loader_.ScheduleLoadSliceImage(index, quality_); } } }
--- a/Framework/Layers/OrthancFrameLayerSource.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Layers/OrthancFrameLayerSource.h Mon Nov 05 10:05:33 2018 +0100 @@ -24,34 +24,24 @@ #include "LayerSourceBase.h" #include "../Toolbox/IWebService.h" #include "../Toolbox/OrthancSlicesLoader.h" +#include "../Toolbox/OrthancApiClient.h" namespace OrthancStone { + // this class is in charge of loading a Frame. + // once it's been loaded (first the geometry and then the image), + // messages are sent to observers so they can use it class OrthancFrameLayerSource : public LayerSourceBase, - private OrthancSlicesLoader::ICallback + public IObserver + //private OrthancSlicesLoader::ISliceLoaderObserver { private: OrthancSlicesLoader loader_; SliceImageQuality quality_; - virtual void NotifyGeometryReady(const OrthancSlicesLoader& loader); - - virtual void NotifyGeometryError(const OrthancSlicesLoader& loader); - - virtual void NotifySliceImageReady(const OrthancSlicesLoader& loader, - unsigned int sliceIndex, - const Slice& slice, - std::auto_ptr<Orthanc::ImageAccessor>& image, - SliceImageQuality quality); - - virtual void NotifySliceImageError(const OrthancSlicesLoader& loader, - unsigned int sliceIndex, - const Slice& slice, - SliceImageQuality quality); - public: - OrthancFrameLayerSource(IWebService& orthanc); + OrthancFrameLayerSource(MessageBroker& broker, OrthancApiClient& orthanc); void LoadSeries(const std::string& seriesId); @@ -65,6 +55,11 @@ quality_ = quality; } + SliceImageQuality GetImageQuality() const + { + return quality_; + } + size_t GetSliceCount() const { return loader_.GetSliceCount(); @@ -79,5 +74,11 @@ const CoordinateSystem3D& viewportSlice); virtual void ScheduleLayerCreation(const CoordinateSystem3D& viewportSlice); + +protected: + void OnSliceGeometryReady(const OrthancSlicesLoader::SliceGeometryReadyMessage& message); + void OnSliceGeometryError(const OrthancSlicesLoader::SliceGeometryErrorMessage& message); + void OnSliceImageReady(const OrthancSlicesLoader::SliceImageReadyMessage& message); + void OnSliceImageError(const OrthancSlicesLoader::SliceImageErrorMessage& message); }; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Messages/ICallable.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,92 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "IMessage.h" + +#include <boost/noncopyable.hpp> + +namespace OrthancStone { + + class IObserver; + + // This is referencing an object and member function that can be notified + // by an IObservable. The object must derive from IO + // The member functions must be of type "void Function(const IMessage& message)" or reference a derived class of IMessage + class ICallable : public boost::noncopyable + { + public: + virtual ~ICallable() + { + } + + virtual void Apply(const IMessage& message) = 0; + + virtual MessageType GetMessageType() const = 0; + virtual IObserver* GetObserver() const = 0; + }; + + template <typename TMessage> + class MessageHandler: public ICallable + { + }; + + + template <typename TObserver, + typename TMessage> + class Callable : public MessageHandler<TMessage> + { + private: + typedef void (TObserver::* MemberFunction) (const TMessage&); + + TObserver& observer_; + MemberFunction function_; + + public: + Callable(TObserver& observer, + MemberFunction function) : + observer_(observer), + function_(function) + { + } + + void ApplyInternal(const TMessage& message) + { + (observer_.*function_) (message); + } + + virtual void Apply(const IMessage& message) + { + ApplyInternal(dynamic_cast<const TMessage&>(message)); + } + + virtual MessageType GetMessageType() const + { + return static_cast<MessageType>(TMessage::Type); + } + + virtual IObserver* GetObserver() const + { + return &observer_; + } + }; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Messages/IMessage.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,87 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "MessageType.h" + +#include <boost/noncopyable.hpp> + +namespace OrthancStone { + + + // base message that are exchanged between IObservable and IObserver + struct IMessage : public boost::noncopyable + { + int messageType_; + protected: + IMessage(const int& messageType) + : messageType_(messageType) + {} + public: + virtual ~IMessage() {} + + virtual int GetType() const {return messageType_;} + }; + + + // base class to derive from to implement your own messages + // it handles the message type for you + template <int type> + struct BaseMessage : public IMessage + { + enum + { + Type = type + }; + + BaseMessage() + : IMessage(static_cast<int>(Type)) + {} + }; + + // simple message implementation when no payload is needed + // sample usage: + // typedef NoPayloadMessage<MessageType_LayerSource_GeometryReady> GeometryReadyMessage; + template <int type> + struct NoPayloadMessage : public BaseMessage<type> + { + NoPayloadMessage() + : BaseMessage<type>() + {} + + }; + + // simple message implementation when no payload is needed but the origin is required + // sample usage: + // typedef OriginMessage<MessageType_SliceLoader_GeometryError, OrthancSlicesLoader> SliceGeometryErrorMessage; + template <int type, typename TOrigin> + struct OriginMessage : public BaseMessage<type> + { + TOrigin& origin_; + OriginMessage(TOrigin& origin) + : BaseMessage<type>(), + origin_(origin) + {} + + }; + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Messages/IObservable.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,110 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include <set> +#include <assert.h> +#include <algorithm> +#include <iostream> +#include <map> + + +#include "MessageBroker.h" +#include "MessageType.h" +#include "ICallable.h" +#include "IObserver.h" +#include "MessageForwarder.h" + +namespace OrthancStone { + + + class IObservable : public boost::noncopyable + { + protected: + MessageBroker& broker_; + + typedef std::map<int, std::set<ICallable*> > Callables; + Callables callables_; + + typedef std::set<IMessageForwarder*> Forwarders; + Forwarders forwarders_; + + public: + + IObservable(MessageBroker& broker) + : broker_(broker) + { + } + virtual ~IObservable() + { + // delete all callables (this will also unregister them from the broker) + for (Callables::const_iterator it = callables_.begin(); + it != callables_.end(); ++it) + { + for (std::set<ICallable*>::const_iterator + it2 = it->second.begin(); it2 != it->second.end(); ++it2) + { + delete *it2; + } + } + + // unregister the forwarders but don't delete them (they'll be deleted by the observable they are observing as any other callable) + for (Forwarders::iterator it = forwarders_.begin(); + it != forwarders_.end(); ++it) + { + IMessageForwarder* fw = *it; + broker_.Unregister(dynamic_cast<IObserver&>(*fw)); + } + } + + void RegisterObserverCallback(ICallable* callable) + { + MessageType messageType = callable->GetMessageType(); + + callables_[messageType].insert(callable); + } + + void EmitMessage(const IMessage& message) + { + Callables::const_iterator found = callables_.find(message.GetType()); + + if (found != callables_.end()) + { + for (std::set<ICallable*>::const_iterator + it = found->second.begin(); it != found->second.end(); ++it) + { + if (broker_.IsActive((*it)->GetObserver())) + { + (*it)->Apply(message); + } + } + } + } + + void RegisterForwarder(IMessageForwarder* forwarder) + { + forwarders_.insert(forwarder); + } + + }; + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Messages/IObserver.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,51 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "MessageBroker.h" +#include "IMessage.h" +#include <set> +#include <assert.h> + +namespace OrthancStone { + + class IObservable; + + class IObserver : public boost::noncopyable + { + protected: + MessageBroker& broker_; + + public: + IObserver(MessageBroker& broker) + : broker_(broker) + { + broker_.Register(*this); + } + + virtual ~IObserver() + { + broker_.Unregister(*this); + } + }; + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Messages/MessageBroker.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,60 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "boost/noncopyable.hpp" +#include <set> + +namespace OrthancStone +{ + class IObserver; + class IObservable; + + /* + * This is a central message broker. It keeps track of all observers and knows + * when an observer is deleted. + * This way, it can prevent an observable to send a message to a deleted observer. + */ + class MessageBroker : public boost::noncopyable + { + + std::set<IObserver*> activeObservers_; // the list of observers that are currently alive (that have not been deleted) + + public: + + void Register(IObserver& observer) + { + activeObservers_.insert(&observer); + } + + void Unregister(IObserver& observer) + { + activeObservers_.erase(&observer); + } + + bool IsActive(IObserver* observer) + { + return activeObservers_.find(observer) != activeObservers_.end(); + } + }; + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Messages/MessageForwarder.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,38 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#include "MessageForwarder.h" + +#include "IObservable.h" + +namespace OrthancStone +{ + + void IMessageForwarder::ForwardMessageInternal(const IMessage& message) + { + emitter_.EmitMessage(message); + } + + void IMessageForwarder::RegisterForwarderInEmitter() + { + emitter_.RegisterForwarder(this); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Messages/MessageForwarder.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,87 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "ICallable.h" +#include "IObserver.h" + +#include <boost/noncopyable.hpp> + +namespace OrthancStone +{ + + class IObservable; + + class IMessageForwarder : public IObserver + { + IObservable& emitter_; + public: + IMessageForwarder(MessageBroker& broker, IObservable& emitter) + : IObserver(broker), + emitter_(emitter) + {} + virtual ~IMessageForwarder() {} + + protected: + void ForwardMessageInternal(const IMessage& message); + void RegisterForwarderInEmitter(); + + }; + + /* When an Observer (B) simply needs to re-emit a message it has received, instead of implementing + * a specific member function to forward the message, it can create a MessageForwarder. + * The MessageForwarder will re-emit the message "in the name of (B)" + * + * Consider the chain where + * A is an observable + * | + * B is an observer of A and observable + * | + * C is an observer of B and knows that B is re-emitting many messages from A + * + * instead of implementing a callback, B will create a MessageForwarder that will emit the messages in his name: + * A.RegisterObserverCallback(new MessageForwarder<A::MessageType>(broker, *this) // where this is B + * + * in C: + * B.RegisterObserverCallback(new Callable<C, A:MessageTyper>(*this, &B::MyCallback)) // where this is C + */ + template<typename TMessage> + class MessageForwarder : public IMessageForwarder, public Callable<MessageForwarder<TMessage>, TMessage> + { + public: + MessageForwarder(MessageBroker& broker, + IObservable& emitter // the object that will emit the messages to forward + ) + : IMessageForwarder(broker, emitter), + Callable<MessageForwarder<TMessage>, TMessage>(*this, &MessageForwarder::ForwardMessage) + { + RegisterForwarderInEmitter(); + } + +protected: + void ForwardMessage(const TMessage& message) + { + ForwardMessageInternal(message); + } + + }; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Messages/MessageType.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,59 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#pragma once + +namespace OrthancStone { + + enum MessageType + { + MessageType_Widget_GeometryChanged, + MessageType_Widget_ContentChanged, + + MessageType_LayerSource_GeometryReady, // instance tags have been loaded + MessageType_LayerSource_GeometryError, + MessageType_LayerSource_ContentChanged, + MessageType_LayerSource_SliceChanged, + MessageType_LayerSource_ImageReady, // instance pixels data have been loaded + MessageType_LayerSource_LayerReady, // layer is ready to be rendered + + MessageType_SliceLoader_GeometryReady, + MessageType_SliceLoader_GeometryError, + MessageType_SliceLoader_ImageReady, + MessageType_SliceLoader_ImageError, + + MessageType_HttpRequestSuccess, + MessageType_HttpRequestError, + + MessageType_OrthancApi_InternalGetJsonResponseReady, + MessageType_OrthancApi_InternalGetJsonResponseError, + + MessageType_OrthancApi_GenericGetJson_Ready, + MessageType_OrthancApi_GenericGetBinary_Ready, + MessageType_OrthancApi_GenericHttpError_Ready, + MessageType_OrthancApi_GenericEmptyResponse_Ready, + + // used in unit tests only + MessageType_Test1, + MessageType_Test2, + + MessageType_CustomMessage // Custom messages ids ust be greater than this (this one must remain in last position) + }; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Messages/Promise.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,88 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "MessageBroker.h" +#include "ICallable.h" +#include "IMessage.h" + +#include <boost/noncopyable.hpp> +#include <memory> + +namespace OrthancStone { + + class Promise : public boost::noncopyable + { + protected: + MessageBroker& broker_; + + std::auto_ptr<ICallable> successCallable_; + std::auto_ptr<ICallable> failureCallable_; + + public: + Promise(MessageBroker& broker) + : broker_(broker) + { + } + + void Success(const IMessage& message) + { + // check the target is still alive in the broker + if (broker_.IsActive(successCallable_->GetObserver())) + { + successCallable_->Apply(message); + } + } + + void Failure(const IMessage& message) + { + // check the target is still alive in the broker + if (broker_.IsActive(failureCallable_->GetObserver())) + { + failureCallable_->Apply(message); + } + } + + Promise& Then(ICallable* successCallable) + { + if (successCallable_.get() != NULL) + { + // TODO: throw throw new "Promise may only have a single success target" + } + successCallable_.reset(successCallable); + return *this; + } + + Promise& Else(ICallable* failureCallable) + { + if (failureCallable_.get() != NULL) + { + // TODO: throw throw new "Promise may only have a single failure target" + } + failureCallable_.reset(failureCallable); + return *this; + } + + }; + + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/SmartLoader.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,272 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#include "SmartLoader.h" +#include "Layers/OrthancFrameLayerSource.h" +#include "Messages/MessageForwarder.h" +#include "Core/Images/Image.h" +#include "Framework/Widgets/LayerWidget.h" +#include "Framework/StoneException.h" +#include "Framework/Layers/FrameRenderer.h" +#include "Core/Logging.h" + +namespace OrthancStone +{ + enum CachedSliceStatus + { + CachedSliceStatus_ScheduledToLoad, + CachedSliceStatus_GeometryLoaded, + CachedSliceStatus_ImageLoaded + }; + + class SmartLoader::CachedSlice : public LayerSourceBase + { + public: + unsigned int sliceIndex_; + std::auto_ptr<Slice> slice_; + boost::shared_ptr<Orthanc::ImageAccessor> image_; + SliceImageQuality effectiveQuality_; + CachedSliceStatus status_; + + public: + CachedSlice(MessageBroker& broker) : + LayerSourceBase(broker) + { + } + + virtual ~CachedSlice() + { + } + + virtual bool GetExtent(std::vector<Vector>& points, + const CoordinateSystem3D& viewportSlice) + { + // TODO: viewportSlice is not used !!!! + slice_->GetExtent(points); + return true; + } + + virtual void ScheduleLayerCreation(const CoordinateSystem3D& viewportSlice) + { + // TODO: viewportSlice is not used !!!! + + // it has already been loaded -> trigger the "layer ready" message immediately otherwise, do nothing now. The LayerReady will be triggered + // once the LayerSource is ready + if (status_ == CachedSliceStatus_ImageLoaded) + { + LOG(WARNING) << "ScheduleLayerCreation for CachedSlice (image is loaded): " << slice_->GetOrthancInstanceId(); + bool isFull = (effectiveQuality_ == SliceImageQuality_FullPng || effectiveQuality_ == SliceImageQuality_FullPam); + std::auto_ptr<Orthanc::ImageAccessor> accessor(new Orthanc::ImageAccessor()); + image_->GetReadOnlyAccessor(*accessor); + LayerSourceBase::NotifyLayerReady(FrameRenderer::CreateRenderer(accessor.release(), *slice_, isFull), + slice_->GetGeometry(), false); + } + else + { + LOG(WARNING) << "ScheduleLayerCreation for CachedSlice (image is not loaded yet): " << slice_->GetOrthancInstanceId(); + } + } + + CachedSlice* Clone() const + { + CachedSlice* output = new CachedSlice(broker_); + output->sliceIndex_ = sliceIndex_; + output->slice_.reset(slice_->Clone()); + output->image_ = image_; + output->effectiveQuality_ = effectiveQuality_; + output->status_ = status_; + + return output; + } + + }; + + + SmartLoader::SmartLoader(MessageBroker& broker, + OrthancApiClient& orthancApiClient) : + IObservable(broker), + IObserver(broker), + imageQuality_(SliceImageQuality_FullPam), + orthancApiClient_(orthancApiClient) + { + } + + void SmartLoader::SetFrameInWidget(LayerWidget& layerWidget, + size_t layerIndex, + const std::string& instanceId, + unsigned int frame) + { + // TODO: check if this frame has already been loaded or is already being loaded. + // - if already loaded: create a "clone" that will emit the GeometryReady/ImageReady messages "immediately" + // (it can not be immediate because Observers needs to register first and this is done after this method returns) + // - if currently loading, we need to return an object that will observe the existing LayerSource and forward + // the messages to its observables + // in both cases, we must be carefull about objects lifecycle !!! + + std::auto_ptr<ILayerSource> layerSource; + std::string sliceKeyId = instanceId + ":" + boost::lexical_cast<std::string>(frame); + SmartLoader::CachedSlice* cachedSlice = NULL; + + if (cachedSlices_.find(sliceKeyId) != cachedSlices_.end()) // && cachedSlices_[sliceKeyId]->status_ == CachedSliceStatus_Loaded) + { + layerSource.reset(cachedSlices_[sliceKeyId]->Clone()); + cachedSlice = dynamic_cast<SmartLoader::CachedSlice*>(layerSource.get()); + } + else + { + layerSource.reset(new OrthancFrameLayerSource(IObserver::broker_, orthancApiClient_)); + dynamic_cast<OrthancFrameLayerSource*>(layerSource.get())->SetImageQuality(imageQuality_); + layerSource->RegisterObserverCallback(new Callable<SmartLoader, ILayerSource::GeometryReadyMessage>(*this, &SmartLoader::OnLayerGeometryReady)); + layerSource->RegisterObserverCallback(new Callable<SmartLoader, ILayerSource::ImageReadyMessage>(*this, &SmartLoader::OnImageReady)); + layerSource->RegisterObserverCallback(new Callable<SmartLoader, ILayerSource::LayerReadyMessage>(*this, &SmartLoader::OnLayerReady)); + dynamic_cast<OrthancFrameLayerSource*>(layerSource.get())->LoadFrame(instanceId, frame); + } + + // make sure that the widget registers the events before we trigger them + if (layerWidget.GetLayerCount() == layerIndex) + { + layerWidget.AddLayer(layerSource.release()); + } + else if (layerWidget.GetLayerCount() > layerIndex) + { + layerWidget.ReplaceLayer(layerIndex, layerSource.release()); + } + else + { + throw StoneException(ErrorCode_CanOnlyAddOneLayerAtATime); + } + + if (cachedSlice != NULL) + { + cachedSlice->NotifyGeometryReady(); + } + + } + + void SmartLoader::PreloadSlice(const std::string instanceId, + unsigned int frame) + { + // TODO: reactivate -> need to be able to ScheduleLayerLoading in ILayerSource without calling ScheduleLayerCreation + return; + // TODO: check if it is already in the cache + + + + // create the slice in the cache with "empty" data + boost::shared_ptr<CachedSlice> cachedSlice(new CachedSlice(IObserver::broker_)); + cachedSlice->slice_.reset(new Slice(instanceId, frame)); + cachedSlice->status_ = CachedSliceStatus_ScheduledToLoad; + std::string sliceKeyId = instanceId + ":" + boost::lexical_cast<std::string>(frame); + + LOG(WARNING) << "Will preload: " << sliceKeyId; + + cachedSlices_[sliceKeyId] = boost::shared_ptr<CachedSlice>(cachedSlice); + + std::auto_ptr<ILayerSource> layerSource(new OrthancFrameLayerSource(IObserver::broker_, orthancApiClient_)); + + dynamic_cast<OrthancFrameLayerSource*>(layerSource.get())->SetImageQuality(imageQuality_); + layerSource->RegisterObserverCallback(new Callable<SmartLoader, ILayerSource::GeometryReadyMessage>(*this, &SmartLoader::OnLayerGeometryReady)); + layerSource->RegisterObserverCallback(new Callable<SmartLoader, ILayerSource::ImageReadyMessage>(*this, &SmartLoader::OnImageReady)); + layerSource->RegisterObserverCallback(new Callable<SmartLoader, ILayerSource::LayerReadyMessage>(*this, &SmartLoader::OnLayerReady)); + dynamic_cast<OrthancFrameLayerSource*>(layerSource.get())->LoadFrame(instanceId, frame); + + // keep a ref to the LayerSource until the slice is fully loaded and saved to cache + preloadingInstances_[sliceKeyId] = boost::shared_ptr<ILayerSource>(layerSource.release()); + } + + +// void PreloadStudy(const std::string studyId) +// { +// /* TODO */ +// } + +// void PreloadSeries(const std::string seriesId) +// { +// /* TODO */ +// } + + + void SmartLoader::OnLayerGeometryReady(const ILayerSource::GeometryReadyMessage& message) + { + OrthancFrameLayerSource& source = dynamic_cast<OrthancFrameLayerSource&>(message.origin_); + + // save/replace the slice in cache + const Slice& slice = source.GetSlice(0); // TODO handle GetSliceCount() + std::string sliceKeyId = (slice.GetOrthancInstanceId() + ":" + + boost::lexical_cast<std::string>(slice.GetFrame())); + + LOG(WARNING) << "Geometry ready: " << sliceKeyId; + + boost::shared_ptr<CachedSlice> cachedSlice(new CachedSlice(IObserver::broker_)); + cachedSlice->slice_.reset(slice.Clone()); + cachedSlice->effectiveQuality_ = source.GetImageQuality(); + cachedSlice->status_ = CachedSliceStatus_GeometryLoaded; + + cachedSlices_[sliceKeyId] = boost::shared_ptr<CachedSlice>(cachedSlice); + + // re-emit original Layer message to observers + EmitMessage(message); + } + + + void SmartLoader::OnImageReady(const ILayerSource::ImageReadyMessage& message) + { + OrthancFrameLayerSource& source = dynamic_cast<OrthancFrameLayerSource&>(message.origin_); + + // save/replace the slice in cache + const Slice& slice = source.GetSlice(0); // TODO handle GetSliceCount() ? + std::string sliceKeyId = (slice.GetOrthancInstanceId() + ":" + + boost::lexical_cast<std::string>(slice.GetFrame())); + + LOG(WARNING) << "Image ready: " << sliceKeyId; + + boost::shared_ptr<CachedSlice> cachedSlice(new CachedSlice(IObserver::broker_)); + cachedSlice->image_ = message.image_; + cachedSlice->effectiveQuality_ = message.imageQuality_; + cachedSlice->slice_.reset(message.slice_.Clone()); + cachedSlice->status_ = CachedSliceStatus_ImageLoaded; + + cachedSlices_[sliceKeyId] = cachedSlice; + + // re-emit original Layer message to observers + EmitMessage(message); + } + + + void SmartLoader::OnLayerReady(const ILayerSource::LayerReadyMessage& message) + { + OrthancFrameLayerSource& source = dynamic_cast<OrthancFrameLayerSource&>(message.origin_); + const Slice& slice = source.GetSlice(0); // TODO handle GetSliceCount() ? + std::string sliceKeyId = (slice.GetOrthancInstanceId() + ":" + + boost::lexical_cast<std::string>(slice.GetFrame())); + + LOG(WARNING) << "Layer ready: " << sliceKeyId; + + // remove the slice from the preloading slices now that it has been fully loaded and it is referenced in the cache + if (preloadingInstances_.find(sliceKeyId) != preloadingInstances_.end()) + { + preloadingInstances_.erase(sliceKeyId); + } + + // re-emit original Layer message to observers + EmitMessage(message); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/SmartLoader.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,67 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once +#include <map> + +#include "Layers/ILayerSource.h" +#include "Messages/IObservable.h" +#include "Toolbox/OrthancApiClient.h" + +namespace OrthancStone +{ + class LayerWidget; + + class SmartLoader : public IObservable, public IObserver + { + class CachedSlice; + + protected: + typedef std::map<std::string, boost::shared_ptr<SmartLoader::CachedSlice> > CachedSlices; + CachedSlices cachedSlices_; + + typedef std::map<std::string, boost::shared_ptr<ILayerSource> > PreloadingInstances; + PreloadingInstances preloadingInstances_; + + SliceImageQuality imageQuality_; + OrthancApiClient& orthancApiClient_; + + public: + SmartLoader(MessageBroker& broker, OrthancApiClient& orthancApiClient); // TODO: add maxPreloadStorageSizeInBytes + +// void PreloadStudy(const std::string studyId); +// void PreloadSeries(const std::string seriesId); + void PreloadSlice(const std::string instanceId, unsigned int frame); + + void SetImageQuality(SliceImageQuality imageQuality) { imageQuality_ = imageQuality; } + + void SetFrameInWidget(LayerWidget& layerWidget, size_t layerIndex, const std::string& instanceId, unsigned int frame); + + void GetFirstInstanceIdForSeries(std::string& output, const std::string& seriesId); + + private: + void OnLayerGeometryReady(const ILayerSource::GeometryReadyMessage& message); + void OnImageReady(const ILayerSource::ImageReadyMessage& message); + void OnLayerReady(const ILayerSource::LayerReadyMessage& message); + + }; + +}
--- a/Framework/StoneEnumerations.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/StoneEnumerations.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -72,4 +72,66 @@ throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); } } + + + void ComputeAnchorTranslation(double& deltaX, + double& deltaY, + BitmapAnchor anchor, + unsigned int bitmapWidth, + unsigned int bitmapHeight) + { + double dw = static_cast<double>(bitmapWidth); + double dh = static_cast<double>(bitmapHeight); + + switch (anchor) + { + case BitmapAnchor_TopLeft: + deltaX = 0; + deltaY = 0; + break; + + case BitmapAnchor_TopCenter: + deltaX = -dw / 2.0; + deltaY = 0; + break; + + case BitmapAnchor_TopRight: + deltaX = -dw; + deltaY = 0; + break; + + case BitmapAnchor_CenterLeft: + deltaX = 0; + deltaY = -dh / 2.0; + break; + + case BitmapAnchor_Center: + deltaX = -dw / 2.0; + deltaY = -dh / 2.0; + break; + + case BitmapAnchor_CenterRight: + deltaX = -dw; + deltaY = -dh / 2.0; + break; + + case BitmapAnchor_BottomLeft: + deltaX = 0; + deltaY = -dh; + break; + + case BitmapAnchor_BottomCenter: + deltaX = -dw / 2.0; + deltaY = -dh; + break; + + case BitmapAnchor_BottomRight: + deltaX = -dw; + deltaY = -dh; + break; + + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + } }
--- a/Framework/StoneEnumerations.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/StoneEnumerations.h Mon Nov 05 10:05:33 2018 +0100 @@ -75,12 +75,26 @@ KeyboardModifiers_Alt = (1 << 2) }; + enum KeyboardKeys + { + KeyboardKeys_Generic = 0, + + // let's use the same ids as in javascript to avoid some conversion in WASM: https://css-tricks.com/snippets/javascript/javascript-keycodes/ + KeyboardKeys_Left = 37, + KeyboardKeys_Up = 38, + KeyboardKeys_Right = 39, + KeyboardKeys_Down = 40 + }; + enum SliceImageQuality { - SliceImageQuality_Full, + SliceImageQuality_FullPng, // smaller to transmit but longer to generate on Orthanc side (better choice when on low bandwidth) + SliceImageQuality_FullPam, // bigger to transmit but faster to generate on Orthanc side (better choice when on localhost or LAN) SliceImageQuality_Jpeg50, SliceImageQuality_Jpeg90, - SliceImageQuality_Jpeg95 + SliceImageQuality_Jpeg95, + + SliceImageQuality_InternalRaw // downloads the raw pixels data as they are stored in the DICOM file (internal use only) }; enum SopClassUid @@ -88,6 +102,19 @@ SopClassUid_RTDose }; + enum BitmapAnchor + { + BitmapAnchor_BottomLeft, + BitmapAnchor_BottomCenter, + BitmapAnchor_BottomRight, + BitmapAnchor_CenterLeft, + BitmapAnchor_Center, + BitmapAnchor_CenterRight, + BitmapAnchor_TopLeft, + BitmapAnchor_TopCenter, + BitmapAnchor_TopRight + }; + bool StringToSopClassUid(SopClassUid& result, const std::string& source); @@ -96,4 +123,10 @@ ImageWindowing windowing, float defaultCenter, float defaultWidth); + + void ComputeAnchorTranslation(double& deltaX /* out */, + double& deltaY /* out */, + BitmapAnchor anchor, + unsigned int bitmapWidth, + unsigned int bitmapHeight); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/StoneException.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,115 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "Core/OrthancException.h" +#include <boost/lexical_cast.hpp> + +namespace OrthancStone +{ + enum ErrorCode + { + ErrorCode_Success, + ErrorCode_OrthancError, // this StoneException is actually an OrthancException with an Orthanc error code + ErrorCode_ApplicationException, // this StoneException is specific to an application (and should have its own internal error code) + ErrorCode_NotImplemented, // case not implemented + + ErrorCode_PromiseSingleSuccessHandler, // a Promise can only have a single success handler + ErrorCode_PromiseSingleFailureHandler, // a Promise can only have a single failure handler + + ErrorCode_CanOnlyAddOneLayerAtATime, + ErrorCode_CommandJsonInvalidFormat, + ErrorCode_Last + }; + + + + class StoneException + { + protected: + OrthancStone::ErrorCode errorCode_; + + public: + explicit StoneException(ErrorCode errorCode) : + errorCode_(errorCode) + { + } + + ErrorCode GetErrorCode() const + { + return errorCode_; + } + + virtual const char* What() const + { + return "TODO: EnumerationToString for StoneException"; + } + }; + + class StoneOrthancException : public StoneException + { + protected: + Orthanc::OrthancException& orthancException_; + + public: + explicit StoneOrthancException(Orthanc::OrthancException& orthancException) : + StoneException(ErrorCode_OrthancError), + orthancException_(orthancException) + { + } + + Orthanc::ErrorCode GetOrthancErrorCode() const + { + return orthancException_.GetErrorCode(); + } + + virtual const char* What() const + { + return orthancException_.What(); + } + }; + + class StoneApplicationException : public StoneException + { + protected: + int applicationErrorCode_; + + public: + explicit StoneApplicationException(int applicationErrorCode) : + StoneException(ErrorCode_ApplicationException), + applicationErrorCode_(applicationErrorCode) + { + } + + int GetApplicationErrorCode() const + { + return applicationErrorCode_; + } + + virtual const char* What() const + { + return boost::lexical_cast<std::string>(applicationErrorCode_).c_str(); + } + }; + +} +
--- a/Framework/Toolbox/DicomFrameConverter.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Toolbox/DicomFrameConverter.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -30,6 +30,19 @@ namespace OrthancStone { + static const Orthanc::DicomTag IMAGE_TAGS[] = + { + Orthanc::DICOM_TAG_BITS_STORED, + Orthanc::DICOM_TAG_DOSE_GRID_SCALING, + Orthanc::DICOM_TAG_PHOTOMETRIC_INTERPRETATION, + Orthanc::DICOM_TAG_PIXEL_REPRESENTATION, + Orthanc::DICOM_TAG_RESCALE_INTERCEPT, + Orthanc::DICOM_TAG_RESCALE_SLOPE, + Orthanc::DICOM_TAG_WINDOW_CENTER, + Orthanc::DICOM_TAG_WINDOW_WIDTH + }; + + void DicomFrameConverter::SetDefaultParameters() { isSigned_ = true; @@ -37,6 +50,7 @@ hasRescale_ = false; rescaleIntercept_ = 0; rescaleSlope_ = 1; + hasDefaultWindow_ = false; defaultWindowCenter_ = 128; defaultWindowWidth_ = 256; expectedPixelFormat_ = Orthanc::PixelFormat_Grayscale16; @@ -53,6 +67,7 @@ c.size() > 0 && w.size() > 0) { + hasDefaultWindow_ = true; defaultWindowCenter_ = static_cast<float>(c[0]); defaultWindowWidth_ = static_cast<float>(w[0]); } @@ -113,6 +128,8 @@ // Type 1 tag, must be present throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); } + + photometric_ = Orthanc::StringToPhotometricInterpretation(photometric.c_str()); isColor_ = (photometric != "MONOCHROME1" && photometric != "MONOCHROME2"); @@ -137,8 +154,27 @@ } } + + void DicomFrameConverter::ReadParameters(const OrthancPlugins::IDicomDataset& dicom) + { + Orthanc::DicomMap converted; - void DicomFrameConverter::ConvertFrame(std::auto_ptr<Orthanc::ImageAccessor>& source) const + for (size_t i = 0; i < sizeof(IMAGE_TAGS) / sizeof(Orthanc::DicomTag); i++) + { + OrthancPlugins::DicomTag tag(IMAGE_TAGS[i].GetGroup(), IMAGE_TAGS[i].GetElement()); + + std::string value; + if (dicom.GetStringValue(value, tag)) + { + converted.SetValue(IMAGE_TAGS[i], value, false); + } + } + + ReadParameters(converted); + } + + + void DicomFrameConverter::ConvertFrameInplace(std::auto_ptr<Orthanc::ImageAccessor>& source) const { assert(sizeof(float) == 4); @@ -147,7 +183,24 @@ throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); } - Orthanc::PixelFormat sourceFormat = source->GetFormat(); + if (source->GetFormat() == GetExpectedPixelFormat() && + source->GetFormat() == Orthanc::PixelFormat_RGB24) + { + // No conversion has to be done, check out (*) + return; + } + else + { + source.reset(ConvertFrame(*source)); + } + } + + + Orthanc::ImageAccessor* DicomFrameConverter::ConvertFrame(const Orthanc::ImageAccessor& source) const + { + assert(sizeof(float) == 4); + + Orthanc::PixelFormat sourceFormat = source.GetFormat(); if (sourceFormat != GetExpectedPixelFormat()) { @@ -156,27 +209,32 @@ if (sourceFormat == Orthanc::PixelFormat_RGB24) { - // No conversion has to be done - return; + // This is the case of a color image. No conversion has to be done (*) + std::auto_ptr<Orthanc::Image> converted(new Orthanc::Image(Orthanc::PixelFormat_RGB24, + source.GetWidth(), + source.GetHeight(), + false)); + Orthanc::ImageProcessing::Copy(*converted, source); + return converted.release(); } - - assert(sourceFormat == Orthanc::PixelFormat_Grayscale16 || - sourceFormat == Orthanc::PixelFormat_Grayscale32 || - sourceFormat == Orthanc::PixelFormat_SignedGrayscale16); + else + { + assert(sourceFormat == Orthanc::PixelFormat_Grayscale16 || + sourceFormat == Orthanc::PixelFormat_Grayscale32 || + sourceFormat == Orthanc::PixelFormat_SignedGrayscale16); - // This is the case of a grayscale frame. Convert it to Float32. - std::auto_ptr<Orthanc::Image> converted(new Orthanc::Image(Orthanc::PixelFormat_Float32, - source->GetWidth(), - source->GetHeight(), - false)); - Orthanc::ImageProcessing::Convert(*converted, *source); + // This is the case of a grayscale frame. Convert it to Float32. + std::auto_ptr<Orthanc::Image> converted(new Orthanc::Image(Orthanc::PixelFormat_Float32, + source.GetWidth(), + source.GetHeight(), + false)); + Orthanc::ImageProcessing::Convert(*converted, source); - source.reset(NULL); // We don't need the source frame anymore - - // Correct rescale slope/intercept if need be - ApplyRescale(*converted, sourceFormat != Orthanc::PixelFormat_Grayscale32); + // Correct rescale slope/intercept if need be + ApplyRescale(*converted, sourceFormat != Orthanc::PixelFormat_Grayscale32); - source = converted; + return converted.release(); + } }
--- a/Framework/Toolbox/DicomFrameConverter.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Toolbox/DicomFrameConverter.h Mon Nov 05 10:05:33 2018 +0100 @@ -21,6 +21,7 @@ #pragma once +#include <Plugins/Samples/Common/IDicomDataset.h> #include <Core/DicomFormat/DicomMap.h> #include <Core/Images/ImageAccessor.h> @@ -43,10 +44,12 @@ bool hasRescale_; double rescaleIntercept_; double rescaleSlope_; + bool hasDefaultWindow_; double defaultWindowCenter_; double defaultWindowWidth_; - - Orthanc::PixelFormat expectedPixelFormat_; + + Orthanc::PhotometricInterpretation photometric_; + Orthanc::PixelFormat expectedPixelFormat_; void SetDefaultParameters(); @@ -61,8 +64,20 @@ return expectedPixelFormat_; } + Orthanc::PhotometricInterpretation GetPhotometricInterpretation() const + { + return photometric_; + } + void ReadParameters(const Orthanc::DicomMap& dicom); + void ReadParameters(const OrthancPlugins::IDicomDataset& dicom); + + bool HasDefaultWindow() const + { + return hasDefaultWindow_; + } + double GetDefaultWindowCenter() const { return defaultWindowCenter_; @@ -83,7 +98,9 @@ return rescaleSlope_; } - void ConvertFrame(std::auto_ptr<Orthanc::ImageAccessor>& source) const; + void ConvertFrameInplace(std::auto_ptr<Orthanc::ImageAccessor>& source) const; + + Orthanc::ImageAccessor* ConvertFrame(const Orthanc::ImageAccessor& source) const; void ApplyRescale(Orthanc::ImageAccessor& image, bool useDouble) const;
--- a/Framework/Toolbox/GeometryToolbox.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Toolbox/GeometryToolbox.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -260,8 +260,9 @@ } else { - spacingX = v[0]; - spacingY = v[1]; + // WARNING: X/Y are swapped (Y comes first) + spacingX = v[1]; + spacingY = v[0]; } } else
--- a/Framework/Toolbox/IWebService.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Toolbox/IWebService.h Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -22,41 +22,86 @@ #pragma once #include <Core/IDynamicObject.h> - +#include "../../Framework/Messages/IObserver.h" +#include "../../Framework/Messages/ICallable.h" #include <string> +#include <map> +#include <Core/Logging.h> namespace OrthancStone { - class IWebService : public boost::noncopyable + // The IWebService performs HTTP requests. + // Since applications can run in native or WASM environment and, since + // in a WASM environment, the WebService is asynchronous, the IWebservice + // also implements an asynchronous interface: you must schedule a request + // and you'll be notified when the response/error is ready. + class IWebService { + protected: + MessageBroker& broker_; public: - class ICallback : public boost::noncopyable - { - public: - virtual ~ICallback() - { - } + typedef std::map<std::string, std::string> Headers; - virtual void NotifyError(const std::string& uri, - Orthanc::IDynamicObject* payload) = 0; + struct HttpRequestSuccessMessage: public BaseMessage<MessageType_HttpRequestSuccess> + { + const std::string& uri_; + const void* answer_; + size_t answerSize_; + Orthanc::IDynamicObject* payload_; + HttpRequestSuccessMessage(const std::string& uri, + const void* answer, + size_t answerSize, + Orthanc::IDynamicObject* payload) + : BaseMessage(), + uri_(uri), + answer_(answer), + answerSize_(answerSize), + payload_(payload) + {} + }; - virtual void NotifySuccess(const std::string& uri, - const void* answer, - size_t answerSize, - Orthanc::IDynamicObject* payload) = 0; + struct HttpRequestErrorMessage: public BaseMessage<MessageType_HttpRequestError> + { + const std::string& uri_; + Orthanc::IDynamicObject* payload_; + HttpRequestErrorMessage(const std::string& uri, + Orthanc::IDynamicObject* payload) + : BaseMessage(), + uri_(uri), + payload_(payload) + {} }; - + + + + IWebService(MessageBroker& broker) + : broker_(broker) + {} + virtual ~IWebService() { } - virtual void ScheduleGetRequest(ICallback& callback, - const std::string& uri, - Orthanc::IDynamicObject* payload) = 0; + virtual void GetAsync(const std::string& uri, + const Headers& headers, + Orthanc::IDynamicObject* payload, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallback, + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback = NULL, + unsigned int timeoutInSeconds = 60) = 0; - virtual void SchedulePostRequest(ICallback& callback, - const std::string& uri, - const std::string& body, - Orthanc::IDynamicObject* payload) = 0; + virtual void PostAsync(const std::string& uri, + const Headers& headers, + const std::string& body, + Orthanc::IDynamicObject* payload, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallback, + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback = NULL, + unsigned int timeoutInSeconds = 60) = 0; + + virtual void DeleteAsync(const std::string& uri, + const Headers& headers, + Orthanc::IDynamicObject* payload, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallback, + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback = NULL, + unsigned int timeoutInSeconds = 60) = 0; }; }
--- a/Framework/Toolbox/ImageGeometry.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Toolbox/ImageGeometry.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -152,10 +152,6 @@ { *p = value; } - else - { - Reader::Traits::SetZero(*p); - } if (HasOffsetX) { @@ -174,7 +170,8 @@ ImageInterpolation Interpolation> static void ApplyAffineInternal(Orthanc::ImageAccessor& target, const Orthanc::ImageAccessor& source, - const Matrix& a) + const Matrix& a, + bool clear) { assert(target.GetFormat() == Format && source.GetFormat() == Format); @@ -182,13 +179,16 @@ typedef SubpixelReader<Format, Interpolation> Reader; typedef typename Reader::PixelType PixelType; - if (Format == Orthanc::PixelFormat_RGB24) + if (clear) { - Orthanc::ImageProcessing::Set(target, 0, 0, 0, 255); - } - else - { - Orthanc::ImageProcessing::Set(target, 0); + if (Format == Orthanc::PixelFormat_RGB24) + { + Orthanc::ImageProcessing::Set(target, 0, 0, 0, 255); + } + else + { + Orthanc::ImageProcessing::Set(target, 0); + } } Matrix inva; @@ -260,7 +260,8 @@ double a21, double a22, double b2, - ImageInterpolation interpolation) + ImageInterpolation interpolation, + bool clear) { if (source.GetFormat() != target.GetFormat()) { @@ -292,12 +293,12 @@ { case ImageInterpolation_Nearest: ApplyAffineInternal<Orthanc::PixelFormat_Grayscale8, - ImageInterpolation_Nearest>(target, source, a); + ImageInterpolation_Nearest>(target, source, a, clear); break; case ImageInterpolation_Bilinear: ApplyAffineInternal<Orthanc::PixelFormat_Grayscale8, - ImageInterpolation_Bilinear>(target, source, a); + ImageInterpolation_Bilinear>(target, source, a, clear); break; default: @@ -310,12 +311,12 @@ { case ImageInterpolation_Nearest: ApplyAffineInternal<Orthanc::PixelFormat_Grayscale16, - ImageInterpolation_Nearest>(target, source, a); + ImageInterpolation_Nearest>(target, source, a, clear); break; case ImageInterpolation_Bilinear: ApplyAffineInternal<Orthanc::PixelFormat_Grayscale16, - ImageInterpolation_Bilinear>(target, source, a); + ImageInterpolation_Bilinear>(target, source, a, clear); break; default: @@ -328,12 +329,30 @@ { case ImageInterpolation_Nearest: ApplyAffineInternal<Orthanc::PixelFormat_SignedGrayscale16, - ImageInterpolation_Nearest>(target, source, a); + ImageInterpolation_Nearest>(target, source, a, clear); break; case ImageInterpolation_Bilinear: ApplyAffineInternal<Orthanc::PixelFormat_SignedGrayscale16, - ImageInterpolation_Bilinear>(target, source, a); + ImageInterpolation_Bilinear>(target, source, a, clear); + break; + + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); + } + break; + + case Orthanc::PixelFormat_Float32: + switch (interpolation) + { + case ImageInterpolation_Nearest: + ApplyAffineInternal<Orthanc::PixelFormat_Float32, + ImageInterpolation_Nearest>(target, source, a, clear); + break; + + case ImageInterpolation_Bilinear: + ApplyAffineInternal<Orthanc::PixelFormat_Float32, + ImageInterpolation_Bilinear>(target, source, a, clear); break; default: @@ -346,7 +365,7 @@ { case ImageInterpolation_Nearest: ApplyAffineInternal<Orthanc::PixelFormat_RGB24, - ImageInterpolation_Nearest>(target, source, a); + ImageInterpolation_Nearest>(target, source, a, clear); break; default: @@ -412,10 +431,6 @@ { reader.GetValue(*p, sourceX, sourceY); } - else - { - Reader::Traits::SetZero(*p); - } p++; } @@ -429,7 +444,8 @@ void ApplyProjectiveTransform(Orthanc::ImageAccessor& target, const Orthanc::ImageAccessor& source, const Matrix& a, - ImageInterpolation interpolation) + ImageInterpolation interpolation, + bool clear) { if (source.GetFormat() != target.GetFormat()) { @@ -463,18 +479,21 @@ ApplyAffineTransform(target, source, a(0, 0) / w, a(0, 1) / w, a(0, 2) / w, a(1, 0) / w, a(1, 1) / w, a(1, 2) / w, - interpolation); + interpolation, clear); return; } } - if (target.GetFormat() == Orthanc::PixelFormat_RGB24) + if (clear) { - Orthanc::ImageProcessing::Set(target, 0, 0, 0, 255); - } - else - { - Orthanc::ImageProcessing::Set(target, 0); + if (target.GetFormat() == Orthanc::PixelFormat_RGB24) + { + Orthanc::ImageProcessing::Set(target, 0, 0, 0, 255); + } + else + { + Orthanc::ImageProcessing::Set(target, 0); + } } Matrix inva; @@ -539,6 +558,24 @@ } break; + case Orthanc::PixelFormat_Float32: + switch (interpolation) + { + case ImageInterpolation_Nearest: + ApplyProjectiveInternal<Orthanc::PixelFormat_Float32, + ImageInterpolation_Nearest>(target, source, a, inva); + break; + + case ImageInterpolation_Bilinear: + ApplyProjectiveInternal<Orthanc::PixelFormat_Float32, + ImageInterpolation_Bilinear>(target, source, a, inva); + break; + + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); + } + break; + case Orthanc::PixelFormat_RGB24: switch (interpolation) {
--- a/Framework/Toolbox/ImageGeometry.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Toolbox/ImageGeometry.h Mon Nov 05 10:05:33 2018 +0100 @@ -50,10 +50,12 @@ double a21, double a22, double b2, - ImageInterpolation interpolation); + ImageInterpolation interpolation, + bool clear); void ApplyProjectiveTransform(Orthanc::ImageAccessor& target, const Orthanc::ImageAccessor& source, const Matrix& a, - ImageInterpolation interpolation); + ImageInterpolation interpolation, + bool clear); }
--- a/Framework/Toolbox/MessagingToolbox.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Toolbox/MessagingToolbox.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -31,6 +31,7 @@ #include <boost/lexical_cast.hpp> #include <json/reader.h> +#include <json/writer.h> namespace OrthancStone { @@ -114,6 +115,12 @@ target); } + void JsonToString(std::string& target, + const Json::Value& source) + { + Json::FastWriter writer; + target = writer.write(source); + } static void ParseJsonException(Json::Value& target, const std::string& source)
--- a/Framework/Toolbox/MessagingToolbox.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Toolbox/MessagingToolbox.h Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -38,6 +38,10 @@ const void* content, size_t size); + void JsonToString(std::string& target, + const Json::Value& source); + + void RestApiGet(Json::Value& target, OrthancPlugins::IOrthancConnection& orthanc, const std::string& uri);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Toolbox/OrthancApiClient.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,232 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + +#include "OrthancApiClient.h" + +#include "MessagingToolbox.h" +#include <Core/OrthancException.h> +#include "Framework/Toolbox/MessagingToolbox.h" + +namespace OrthancStone { + + OrthancApiClient::OrthancApiClient(MessageBroker &broker, IWebService &orthanc) + : IObservable(broker), + orthanc_(orthanc) + { + } + + // performs the translation between IWebService messages and OrthancApiClient messages + // TODO: handle destruction of this object (with shared_ptr ?::delete_later ???) + class HttpResponseToJsonConverter : public IObserver, IObservable + { + private: + std::auto_ptr<MessageHandler<OrthancApiClient::JsonResponseReadyMessage> > orthancApiSuccessCallback_; + std::auto_ptr<MessageHandler<OrthancApiClient::HttpErrorMessage> > orthancApiFailureCallback_; + + public: + HttpResponseToJsonConverter(MessageBroker& broker, + MessageHandler<OrthancApiClient::JsonResponseReadyMessage>* orthancApiSuccessCallback, + MessageHandler<OrthancApiClient::HttpErrorMessage>* orthancApiFailureCallback) + : IObserver(broker), + IObservable(broker), + orthancApiSuccessCallback_(orthancApiSuccessCallback), + orthancApiFailureCallback_(orthancApiFailureCallback) + { + } + + void ConvertResponseToJson(const IWebService::HttpRequestSuccessMessage& message) + { + Json::Value response; + if (MessagingToolbox::ParseJson(response, message.answer_, message.answerSize_)) + { + if (orthancApiSuccessCallback_.get() != NULL) + { + orthancApiSuccessCallback_->Apply(OrthancApiClient::JsonResponseReadyMessage(message.uri_, response, message.payload_)); + } + } + else if (orthancApiFailureCallback_.get() != NULL) + { + orthancApiFailureCallback_->Apply(OrthancApiClient::HttpErrorMessage(message.uri_, message.payload_)); + } + + delete this; // hack untill we find someone to take ownership of this object (https://isocpp.org/wiki/faq/freestore-mgmt#delete-this) + } + + void ConvertError(const IWebService::HttpRequestErrorMessage& message) + { + if (orthancApiFailureCallback_.get() != NULL) + { + orthancApiFailureCallback_->Apply(OrthancApiClient::HttpErrorMessage(message.uri_)); + } + + delete this; // hack untill we find someone to take ownership of this object (https://isocpp.org/wiki/faq/freestore-mgmt#delete-this) + } + }; + + // performs the translation between IWebService messages and OrthancApiClient messages + // TODO: handle destruction of this object (with shared_ptr ?::delete_later ???) + class HttpResponseToBinaryConverter : public IObserver, IObservable + { + private: + std::auto_ptr<MessageHandler<OrthancApiClient::BinaryResponseReadyMessage> > orthancApiSuccessCallback_; + std::auto_ptr<MessageHandler<OrthancApiClient::HttpErrorMessage> > orthancApiFailureCallback_; + + public: + HttpResponseToBinaryConverter(MessageBroker& broker, + MessageHandler<OrthancApiClient::BinaryResponseReadyMessage>* orthancApiSuccessCallback, + MessageHandler<OrthancApiClient::HttpErrorMessage>* orthancApiFailureCallback) + : IObserver(broker), + IObservable(broker), + orthancApiSuccessCallback_(orthancApiSuccessCallback), + orthancApiFailureCallback_(orthancApiFailureCallback) + { + } + + void ConvertResponseToBinary(const IWebService::HttpRequestSuccessMessage& message) + { + if (orthancApiSuccessCallback_.get() != NULL) + { + orthancApiSuccessCallback_->Apply(OrthancApiClient::BinaryResponseReadyMessage(message.uri_, message.answer_, message.answerSize_, message.payload_)); + } + else if (orthancApiFailureCallback_.get() != NULL) + { + orthancApiFailureCallback_->Apply(OrthancApiClient::HttpErrorMessage(message.uri_, message.payload_)); + } + + delete this; // hack untill we find someone to take ownership of this object (https://isocpp.org/wiki/faq/freestore-mgmt#delete-this) + } + + void ConvertError(const IWebService::HttpRequestErrorMessage& message) + { + if (orthancApiFailureCallback_.get() != NULL) + { + orthancApiFailureCallback_->Apply(OrthancApiClient::HttpErrorMessage(message.uri_)); + } + + delete this; // hack untill we find someone to take ownership of this object (https://isocpp.org/wiki/faq/freestore-mgmt#delete-this) + } + }; + + // performs the translation between IWebService messages and OrthancApiClient messages + // TODO: handle destruction of this object (with shared_ptr ?::delete_later ???) + class HttpResponseToEmptyConverter : public IObserver, IObservable + { + private: + std::auto_ptr<MessageHandler<OrthancApiClient::EmptyResponseReadyMessage> > orthancApiSuccessCallback_; + std::auto_ptr<MessageHandler<OrthancApiClient::HttpErrorMessage> > orthancApiFailureCallback_; + + public: + HttpResponseToEmptyConverter(MessageBroker& broker, + MessageHandler<OrthancApiClient::EmptyResponseReadyMessage>* orthancApiSuccessCallback, + MessageHandler<OrthancApiClient::HttpErrorMessage>* orthancApiFailureCallback) + : IObserver(broker), + IObservable(broker), + orthancApiSuccessCallback_(orthancApiSuccessCallback), + orthancApiFailureCallback_(orthancApiFailureCallback) + { + } + + void ConvertResponseToEmpty(const IWebService::HttpRequestSuccessMessage& message) + { + if (orthancApiSuccessCallback_.get() != NULL) + { + orthancApiSuccessCallback_->Apply(OrthancApiClient::EmptyResponseReadyMessage(message.uri_, message.payload_)); + } + else if (orthancApiFailureCallback_.get() != NULL) + { + orthancApiFailureCallback_->Apply(OrthancApiClient::HttpErrorMessage(message.uri_, message.payload_)); + } + + delete this; // hack untill we find someone to take ownership of this object (https://isocpp.org/wiki/faq/freestore-mgmt#delete-this) + } + + void ConvertError(const IWebService::HttpRequestErrorMessage& message) + { + if (orthancApiFailureCallback_.get() != NULL) + { + orthancApiFailureCallback_->Apply(OrthancApiClient::HttpErrorMessage(message.uri_)); + } + + delete this; // hack untill we find someone to take ownership of this object (https://isocpp.org/wiki/faq/freestore-mgmt#delete-this) + } + }; + + + void OrthancApiClient::GetJsonAsync(const std::string& uri, + MessageHandler<JsonResponseReadyMessage>* successCallback, + MessageHandler<HttpErrorMessage>* failureCallback, + Orthanc::IDynamicObject* payload) + { + HttpResponseToJsonConverter* converter = new HttpResponseToJsonConverter(broker_, successCallback, failureCallback); // it is currently deleting itself after being used + orthanc_.GetAsync(uri, IWebService::Headers(), payload, + new Callable<HttpResponseToJsonConverter, IWebService::HttpRequestSuccessMessage>(*converter, &HttpResponseToJsonConverter::ConvertResponseToJson), + new Callable<HttpResponseToJsonConverter, IWebService::HttpRequestErrorMessage>(*converter, &HttpResponseToJsonConverter::ConvertError)); + + } + + void OrthancApiClient::GetBinaryAsync(const std::string& uri, + const IWebService::Headers& headers, + MessageHandler<BinaryResponseReadyMessage>* successCallback, + MessageHandler<HttpErrorMessage>* failureCallback, + Orthanc::IDynamicObject* payload) + { + HttpResponseToBinaryConverter* converter = new HttpResponseToBinaryConverter(broker_, successCallback, failureCallback); // it is currently deleting itself after being used + orthanc_.GetAsync(uri, headers, payload, + new Callable<HttpResponseToBinaryConverter, IWebService::HttpRequestSuccessMessage>(*converter, &HttpResponseToBinaryConverter::ConvertResponseToBinary), + new Callable<HttpResponseToBinaryConverter, IWebService::HttpRequestErrorMessage>(*converter, &HttpResponseToBinaryConverter::ConvertError)); + } + + void OrthancApiClient::PostBinaryAsyncExpectJson(const std::string& uri, + const std::string& body, + MessageHandler<JsonResponseReadyMessage>* successCallback, + MessageHandler<HttpErrorMessage>* failureCallback, + Orthanc::IDynamicObject* payload) + { + HttpResponseToJsonConverter* converter = new HttpResponseToJsonConverter(broker_, successCallback, failureCallback); // it is currently deleting itself after being used + orthanc_.PostAsync(uri, IWebService::Headers(), body, payload, + new Callable<HttpResponseToJsonConverter, IWebService::HttpRequestSuccessMessage>(*converter, &HttpResponseToJsonConverter::ConvertResponseToJson), + new Callable<HttpResponseToJsonConverter, IWebService::HttpRequestErrorMessage>(*converter, &HttpResponseToJsonConverter::ConvertError)); + + } + + void OrthancApiClient::PostJsonAsyncExpectJson(const std::string& uri, + const Json::Value& data, + MessageHandler<JsonResponseReadyMessage>* successCallback, + MessageHandler<HttpErrorMessage>* failureCallback, + Orthanc::IDynamicObject* payload) + { + std::string body; + MessagingToolbox::JsonToString(body, data); + return PostBinaryAsyncExpectJson(uri, body, successCallback, failureCallback, payload); + } + + void OrthancApiClient::DeleteAsync(const std::string& uri, + MessageHandler<EmptyResponseReadyMessage>* successCallback, + MessageHandler<HttpErrorMessage>* failureCallback, + Orthanc::IDynamicObject* payload) + { + HttpResponseToEmptyConverter* converter = new HttpResponseToEmptyConverter(broker_, successCallback, failureCallback); // it is currently deleting itself after being used + orthanc_.DeleteAsync(uri, IWebService::Headers(), payload, + new Callable<HttpResponseToEmptyConverter, IWebService::HttpRequestSuccessMessage>(*converter, &HttpResponseToEmptyConverter::ConvertResponseToEmpty), + new Callable<HttpResponseToEmptyConverter, IWebService::HttpRequestErrorMessage>(*converter, &HttpResponseToEmptyConverter::ConvertError)); + } + + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Toolbox/OrthancApiClient.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,167 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include <boost/shared_ptr.hpp> +#include <json/json.h> + +#include "IWebService.h" +#include "../Messages/IObservable.h" +#include "../Messages/Promise.h" + +namespace OrthancStone +{ + class OrthancApiClient: + public IObservable + { + public: + + struct JsonResponseReadyMessage : public BaseMessage<MessageType_OrthancApi_GenericGetJson_Ready> + { + Json::Value Response; + std::string Uri; + std::auto_ptr<Orthanc::IDynamicObject> Payload; + + JsonResponseReadyMessage(const std::string& uri, + const Json::Value& response, + Orthanc::IDynamicObject* payload = NULL) + : BaseMessage(), + Response(response), + Uri(uri), + Payload(payload) + { + } + }; + + struct EmptyResponseReadyMessage : public BaseMessage<MessageType_OrthancApi_GenericEmptyResponse_Ready> + { + std::string Uri; + std::auto_ptr<Orthanc::IDynamicObject> Payload; + + EmptyResponseReadyMessage(const std::string& uri, + Orthanc::IDynamicObject* payload = NULL) + : BaseMessage(), + Uri(uri), + Payload(payload) + { + } + }; + + struct HttpErrorMessage : public BaseMessage<MessageType_OrthancApi_GenericHttpError_Ready> + { + std::string Uri; + std::auto_ptr<Orthanc::IDynamicObject> Payload; + + HttpErrorMessage(const std::string& uri, + Orthanc::IDynamicObject* payload = NULL) + : BaseMessage(), + Uri(uri), + Payload(payload) + { + } + }; + + struct BinaryResponseReadyMessage : public BaseMessage<MessageType_OrthancApi_GenericGetBinary_Ready> + { + const void* Answer; + size_t AnswerSize; + std::string Uri; + std::auto_ptr<Orthanc::IDynamicObject> Payload; + + BinaryResponseReadyMessage(const std::string& uri, + const void* answer, + size_t answerSize, + Orthanc::IDynamicObject* payload = NULL) + : BaseMessage(), + Answer(answer), + AnswerSize(answerSize), + Uri(uri), + Payload(payload) + { + } + }; + + + + public: + + enum Mode + { + Mode_GetJson + }; + + protected: + IWebService& orthanc_; + + public: + OrthancApiClient(MessageBroker& broker, + IWebService& orthanc); + virtual ~OrthancApiClient() {} + + // schedule a GET request expecting a JSON response. + void GetJsonAsync(const std::string& uri, + MessageHandler<JsonResponseReadyMessage>* successCallback, + MessageHandler<HttpErrorMessage>* failureCallback = NULL, + Orthanc::IDynamicObject* payload = NULL); + + // schedule a GET request expecting a binary response. + void GetBinaryAsync(const std::string& uri, + const std::string& contentType, + MessageHandler<BinaryResponseReadyMessage>* successCallback, + MessageHandler<HttpErrorMessage>* failureCallback = NULL, + Orthanc::IDynamicObject* payload = NULL) + { + IWebService::Headers headers; + headers["Accept"] = contentType; + GetBinaryAsync(uri, headers, successCallback, failureCallback, payload); + } + + // schedule a GET request expecting a binary response. + void GetBinaryAsync(const std::string& uri, + const IWebService::Headers& headers, + MessageHandler<BinaryResponseReadyMessage>* successCallback, + MessageHandler<HttpErrorMessage>* failureCallback = NULL, + Orthanc::IDynamicObject* payload = NULL); + + // schedule a POST request expecting a JSON response. + void PostBinaryAsyncExpectJson(const std::string& uri, + const std::string& body, + MessageHandler<JsonResponseReadyMessage>* successCallback, + MessageHandler<HttpErrorMessage>* failureCallback = NULL, + Orthanc::IDynamicObject* payload = NULL); + + // schedule a POST request expecting a JSON response. + void PostJsonAsyncExpectJson(const std::string& uri, + const Json::Value& data, + MessageHandler<JsonResponseReadyMessage>* successCallback, + MessageHandler<HttpErrorMessage>* failureCallback = NULL, + Orthanc::IDynamicObject* payload = NULL); + + // schedule a DELETE request expecting an empty response. + void DeleteAsync(const std::string& uri, + MessageHandler<EmptyResponseReadyMessage>* successCallback, + MessageHandler<HttpErrorMessage>* failureCallback = NULL, + Orthanc::IDynamicObject* payload = NULL); + + + }; +}
--- a/Framework/Toolbox/OrthancSlicesLoader.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Toolbox/OrthancSlicesLoader.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -29,6 +29,7 @@ #include <Core/Images/ImageProcessing.h> #include <Core/Images/JpegReader.h> #include <Core/Images/PngReader.h> +#include <Core/Images/PamReader.h> #include <Core/Logging.h> #include <Core/OrthancException.h> #include <Core/Toolbox.h> @@ -47,10 +48,10 @@ static std::string base64_decode(const std::string &in) { std::string out; - + std::vector<int> T(256,-1); - for (int i=0; i<64; i++) T["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[i]] = i; - + for (int i=0; i<64; i++) T["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[i]] = i; + int val=0, valb=-8; for (size_t i = 0; i < in.size(); i++) { unsigned char c = in[i]; @@ -117,18 +118,13 @@ assert(mode_ == Mode_FrameGeometry); return frame_; } - + const std::string& GetInstanceId() const { assert(mode_ == Mode_FrameGeometry || mode_ == Mode_InstanceGeometry); return instanceId_; } - - static Operation* DownloadSeriesGeometry() - { - return new Operation(Mode_SeriesGeometry); - } static Operation* DownloadInstanceGeometry(const std::string& instanceId) { @@ -163,103 +159,21 @@ std::auto_ptr<Operation> tmp(new Operation(Mode_LoadRawImage)); tmp->sliceIndex_ = sliceIndex; tmp->slice_ = &slice; - tmp->quality_ = SliceImageQuality_Full; + tmp->quality_ = SliceImageQuality_InternalRaw; return tmp.release(); } - }; - - - class OrthancSlicesLoader::WebCallback : public IWebService::ICallback - { - private: - OrthancSlicesLoader& that_; - - public: - WebCallback(OrthancSlicesLoader& that) : - that_(that) - { - } - virtual void NotifySuccess(const std::string& uri, - const void* answer, - size_t answerSize, - Orthanc::IDynamicObject* payload) + static Operation* DownloadDicomFile(const Slice& slice) { - std::auto_ptr<Operation> operation(dynamic_cast<Operation*>(payload)); - - switch (operation->GetMode()) - { - case Mode_SeriesGeometry: - that_.ParseSeriesGeometry(answer, answerSize); - break; - - case Mode_InstanceGeometry: - that_.ParseInstanceGeometry(operation->GetInstanceId(), answer, answerSize); - break; - - case Mode_FrameGeometry: - that_.ParseFrameGeometry(operation->GetInstanceId(), - operation->GetFrame(), answer, answerSize); - break; - - case Mode_LoadImage: - switch (operation->GetQuality()) - { - case SliceImageQuality_Full: - that_.ParseSliceImagePng(*operation, answer, answerSize); - break; - - case SliceImageQuality_Jpeg50: - case SliceImageQuality_Jpeg90: - case SliceImageQuality_Jpeg95: - that_.ParseSliceImageJpeg(*operation, answer, answerSize); - break; - - default: - throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); - } - - break; - - case Mode_LoadRawImage: - that_.ParseSliceRawImage(*operation, answer, answerSize); - break; - - default: - throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); - } + std::auto_ptr<Operation> tmp(new Operation(Mode_LoadDicomFile)); + tmp->slice_ = &slice; + return tmp.release(); } - virtual void NotifyError(const std::string& uri, - Orthanc::IDynamicObject* payload) - { - std::auto_ptr<Operation> operation(dynamic_cast<Operation*>(payload)); - LOG(ERROR) << "Cannot download " << uri; - - switch (operation->GetMode()) - { - case Mode_FrameGeometry: - case Mode_SeriesGeometry: - that_.userCallback_.NotifyGeometryError(that_); - that_.state_ = State_Error; - break; - - case Mode_LoadImage: - that_.userCallback_.NotifySliceImageError(that_, operation->GetSliceIndex(), - operation->GetSlice(), - operation->GetQuality()); - break; - - default: - throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); - } - } }; - - void OrthancSlicesLoader::NotifySliceImageSuccess(const Operation& operation, - std::auto_ptr<Orthanc::ImageAccessor>& image) const + boost::shared_ptr<Orthanc::ImageAccessor> image) { if (image.get() == NULL) { @@ -267,19 +181,19 @@ } else { - userCallback_.NotifySliceImageReady - (*this, operation.GetSliceIndex(), operation.GetSlice(), image, operation.GetQuality()); + OrthancSlicesLoader::SliceImageReadyMessage msg(operation.GetSliceIndex(), operation.GetSlice(), image, operation.GetQuality()); + EmitMessage(msg); } } - + - void OrthancSlicesLoader::NotifySliceImageError(const Operation& operation) const + void OrthancSlicesLoader::NotifySliceImageError(const Operation& operation) { - userCallback_.NotifySliceImageError - (*this, operation.GetSliceIndex(), operation.GetSlice(), operation.GetQuality()); + OrthancSlicesLoader::SliceImageErrorMessage msg(operation.GetSliceIndex(), operation.GetSlice(), operation.GetQuality()); + EmitMessage(msg); } - - + + void OrthancSlicesLoader::SortAndFinalizeSlices() { bool ok = false; @@ -295,41 +209,44 @@ ok = true; } } - + state_ = State_GeometryReady; - + if (ok) { LOG(INFO) << "Loaded a series with " << slices_.GetSliceCount() << " slice(s)"; - userCallback_.NotifyGeometryReady(*this); + EmitMessage(SliceGeometryReadyMessage(*this)); } else { LOG(ERROR) << "This series is empty"; - userCallback_.NotifyGeometryError(*this); + EmitMessage(SliceGeometryErrorMessage(*this)); } } + + void OrthancSlicesLoader::OnGeometryError(const OrthancApiClient::HttpErrorMessage& message) + { + EmitMessage(SliceGeometryErrorMessage(*this)); + state_ = State_Error; + } - - void OrthancSlicesLoader::ParseSeriesGeometry(const void* answer, - size_t size) + void OrthancSlicesLoader::OnSliceImageError(const OrthancApiClient::HttpErrorMessage& message) { - Json::Value series; - if (!MessagingToolbox::ParseJson(series, answer, size) || - series.type() != Json::objectValue) - { - userCallback_.NotifyGeometryError(*this); - return; - } + NotifySliceImageError(dynamic_cast<const Operation&>(*(message.Payload))); + state_ = State_Error; + } + void OrthancSlicesLoader::ParseSeriesGeometry(const OrthancApiClient::JsonResponseReadyMessage& message) + { + Json::Value series = message.Response; Json::Value::Members instances = series.getMemberNames(); - + slices_.Reserve(instances.size()); - + for (size_t i = 0; i < instances.size(); i++) { OrthancPlugins::FullOrthancDataset dataset(series[instances[i]]); - + Orthanc::DicomMap dicom; MessagingToolbox::ConvertDataset(dicom, dataset); @@ -338,7 +255,7 @@ { frames = 1; } - + for (unsigned int frame = 0; frame < frames; frame++) { std::auto_ptr<Slice> slice(new Slice); @@ -352,28 +269,20 @@ } } } - + SortAndFinalizeSlices(); } - - - void OrthancSlicesLoader::ParseInstanceGeometry(const std::string& instanceId, - const void* answer, - size_t size) + + void OrthancSlicesLoader::ParseInstanceGeometry(const OrthancApiClient::JsonResponseReadyMessage& message) { - Json::Value tags; - if (!MessagingToolbox::ParseJson(tags, answer, size) || - tags.type() != Json::objectValue) - { - userCallback_.NotifyGeometryError(*this); - return; - } + Json::Value tags = message.Response; + const std::string& instanceId = dynamic_cast<OrthancSlicesLoader::Operation*>(message.Payload.get())->GetInstanceId(); OrthancPlugins::FullOrthancDataset dataset(tags); - + Orthanc::DicomMap dicom; MessagingToolbox::ConvertDataset(dicom, dataset); - + unsigned int frames; if (!dicom.ParseUnsignedInteger32(frames, Orthanc::DICOM_TAG_NUMBER_OF_FRAMES)) { @@ -381,7 +290,7 @@ } LOG(INFO) << "Instance " << instanceId << " contains " << frames << " frame(s)"; - + for (unsigned int frame = 0; frame < frames; frame++) { std::auto_ptr<Slice> slice(new Slice); @@ -392,60 +301,92 @@ else { LOG(WARNING) << "Skipping invalid multi-frame instance " << instanceId; - userCallback_.NotifyGeometryError(*this); + EmitMessage(SliceGeometryErrorMessage(*this)); return; } } - + SortAndFinalizeSlices(); } - - - void OrthancSlicesLoader::ParseFrameGeometry(const std::string& instanceId, - unsigned int frame, - const void* answer, - size_t size) + + + void OrthancSlicesLoader::ParseFrameGeometry(const OrthancApiClient::JsonResponseReadyMessage& message) { - Json::Value tags; - if (!MessagingToolbox::ParseJson(tags, answer, size) || - tags.type() != Json::objectValue) - { - userCallback_.NotifyGeometryError(*this); - return; - } + Json::Value tags = message.Response; + const std::string& instanceId = dynamic_cast<OrthancSlicesLoader::Operation*>(message.Payload.get())->GetInstanceId(); + unsigned int frame = dynamic_cast<OrthancSlicesLoader::Operation*>(message.Payload.get())->GetFrame(); OrthancPlugins::FullOrthancDataset dataset(tags); - + state_ = State_GeometryReady; - + Orthanc::DicomMap dicom; MessagingToolbox::ConvertDataset(dicom, dataset); - + std::auto_ptr<Slice> slice(new Slice); if (slice->ParseOrthancFrame(dicom, instanceId, frame)) { - LOG(INFO) << "Loaded instance " << instanceId; + LOG(INFO) << "Loaded instance geometry " << instanceId; slices_.AddSlice(slice.release()); - userCallback_.NotifyGeometryReady(*this); + EmitMessage(SliceGeometryReadyMessage(*this)); } else { LOG(WARNING) << "Skipping invalid instance " << instanceId; - userCallback_.NotifyGeometryError(*this); + EmitMessage(SliceGeometryErrorMessage(*this)); } } - + + + void OrthancSlicesLoader::ParseSliceImagePng(const OrthancApiClient::BinaryResponseReadyMessage& message) + { + const Operation& operation = dynamic_cast<const OrthancSlicesLoader::Operation&>(*message.Payload.get()); + boost::shared_ptr<Orthanc::ImageAccessor> image; + + try + { + image.reset(new Orthanc::PngReader); + dynamic_cast<Orthanc::PngReader&>(*image).ReadFromMemory(message.Answer, message.AnswerSize); + } + catch (Orthanc::OrthancException&) + { + NotifySliceImageError(operation); + return; + } + + if (image->GetWidth() != operation.GetSlice().GetWidth() || + image->GetHeight() != operation.GetSlice().GetHeight()) + { + NotifySliceImageError(operation); + return; + } - void OrthancSlicesLoader::ParseSliceImagePng(const Operation& operation, - const void* answer, - size_t size) + if (operation.GetSlice().GetConverter().GetExpectedPixelFormat() == + Orthanc::PixelFormat_SignedGrayscale16) + { + if (image->GetFormat() == Orthanc::PixelFormat_Grayscale16) + { + image->SetFormat(Orthanc::PixelFormat_SignedGrayscale16); + } + else + { + NotifySliceImageError(operation); + return; + } + } + + NotifySliceImageSuccess(operation, image); + } + + void OrthancSlicesLoader::ParseSliceImagePam(const OrthancApiClient::BinaryResponseReadyMessage& message) { - std::auto_ptr<Orthanc::ImageAccessor> image; + const Operation& operation = dynamic_cast<const OrthancSlicesLoader::Operation&>(*message.Payload.get()); + boost::shared_ptr<Orthanc::ImageAccessor> image; try { - image.reset(new Orthanc::PngReader); - dynamic_cast<Orthanc::PngReader&>(*image).ReadFromMemory(answer, size); + image.reset(new Orthanc::PamReader); + dynamic_cast<Orthanc::PamReader&>(*image).ReadFromMemory(std::string(reinterpret_cast<const char*>(message.Answer), message.AnswerSize)); } catch (Orthanc::OrthancException&) { @@ -459,7 +400,7 @@ NotifySliceImageError(operation); return; } - + if (operation.GetSlice().GetConverter().GetExpectedPixelFormat() == Orthanc::PixelFormat_SignedGrayscale16) { @@ -475,23 +416,22 @@ } NotifySliceImageSuccess(operation, image); - } + } + - - void OrthancSlicesLoader::ParseSliceImageJpeg(const Operation& operation, - const void* answer, - size_t size) + void OrthancSlicesLoader::ParseSliceImageJpeg(const OrthancApiClient::JsonResponseReadyMessage& message) { - Json::Value encoded; - if (!MessagingToolbox::ParseJson(encoded, answer, size) || - encoded.type() != Json::objectValue || + const Operation& operation = dynamic_cast<const OrthancSlicesLoader::Operation&>(*message.Payload.get()); + + Json::Value encoded = message.Response; + if (encoded.type() != Json::objectValue || !encoded.isMember("Orthanc") || encoded["Orthanc"].type() != Json::objectValue) { NotifySliceImageError(operation); return; } - + Json::Value& info = encoded["Orthanc"]; if (!info.isMember("PixelData") || !info.isMember("Stretched") || @@ -504,30 +444,30 @@ NotifySliceImageError(operation); return; } - + bool isSigned = false; bool isStretched = info["Stretched"].asBool(); - + if (info.isMember("IsSigned")) { if (info["IsSigned"].type() != Json::booleanValue) { NotifySliceImageError(operation); return; - } + } else { isSigned = info["IsSigned"].asBool(); } } - - std::auto_ptr<Orthanc::ImageAccessor> reader; - + + boost::shared_ptr<Orthanc::ImageAccessor> reader; + { std::string jpeg; //Orthanc::Toolbox::DecodeBase64(jpeg, info["PixelData"].asString()); jpeg = base64_decode(info["PixelData"].asString()); - + try { reader.reset(new Orthanc::JpegReader); @@ -539,10 +479,10 @@ return; } } - + Orthanc::PixelFormat expectedFormat = - operation.GetSlice().GetConverter().GetExpectedPixelFormat(); - + operation.GetSlice().GetConverter().GetExpectedPixelFormat(); + if (reader->GetFormat() == Orthanc::PixelFormat_RGB24) // This is a color image { if (expectedFormat != Orthanc::PixelFormat_RGB24) @@ -550,7 +490,7 @@ NotifySliceImageError(operation); return; } - + if (isSigned || isStretched) { NotifySliceImageError(operation); @@ -562,13 +502,13 @@ return; } } - + if (reader->GetFormat() != Orthanc::PixelFormat_Grayscale8) { NotifySliceImageError(operation); return; } - + if (!isStretched) { if (expectedFormat != reader->GetFormat()) @@ -582,10 +522,10 @@ return; } } - + int32_t stretchLow = 0; int32_t stretchHigh = 0; - + if (!info.isMember("StretchLow") || !info.isMember("StretchHigh") || info["StretchLow"].type() != Json::intValue || @@ -594,10 +534,10 @@ NotifySliceImageError(operation); return; } - + stretchLow = info["StretchLow"].asInt(); stretchHigh = info["StretchHigh"].asInt(); - + if (stretchLow < -32768 || stretchHigh > 65535 || (stretchLow < 0 && stretchHigh > 32767)) @@ -606,22 +546,22 @@ NotifySliceImageError(operation); return; } - + // Decode a grayscale JPEG 8bpp image coming from the Web viewer - std::auto_ptr<Orthanc::ImageAccessor> image - (new Orthanc::Image(expectedFormat, reader->GetWidth(), reader->GetHeight(), false)); - + boost::shared_ptr<Orthanc::ImageAccessor> image + (new Orthanc::Image(expectedFormat, reader->GetWidth(), reader->GetHeight(), false)); + Orthanc::ImageProcessing::Convert(*image, *reader); - reader.reset(NULL); - + reader.reset(); + float scaling = static_cast<float>(stretchHigh - stretchLow) / 255.0f; - + if (!LinearAlgebra::IsCloseToZero(scaling)) { float offset = static_cast<float>(stretchLow) / scaling; Orthanc::ImageProcessing::ShiftScale(*image, offset, scaling, true); } - + NotifySliceImageSuccess(operation, image); } @@ -641,25 +581,23 @@ { throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageFormat); } - + buffer_.swap(buffer); // The source buffer is now empty - + void* data = (buffer_.empty() ? NULL : &buffer_[0]); - + AssignWritable(format, width, height, Orthanc::GetBytesPerPixel(format) * width, data); } }; - - void OrthancSlicesLoader::ParseSliceRawImage(const Operation& operation, - const void* answer, - size_t size) + void OrthancSlicesLoader::ParseSliceRawImage(const OrthancApiClient::BinaryResponseReadyMessage& message) { + const Operation& operation = dynamic_cast<const OrthancSlicesLoader::Operation&>(*message.Payload.get()); Orthanc::GzipCompressor compressor; - + std::string raw; - compressor.Uncompress(raw, answer, size); + compressor.Uncompress(raw, message.Answer, message.AnswerSize); const Orthanc::DicomImageInformation& info = operation.GetSlice().GetImageInformation(); @@ -673,10 +611,10 @@ { // This is the case of RT-DOSE (uint32_t values) - std::auto_ptr<Orthanc::ImageAccessor> image - (new StringImage(Orthanc::PixelFormat_Grayscale32, info.GetWidth(), - info.GetHeight(), raw)); - + boost::shared_ptr<Orthanc::ImageAccessor> image + (new StringImage(Orthanc::PixelFormat_Grayscale32, info.GetWidth(), + info.GetHeight(), raw)); + // TODO - Only for big endian for (unsigned int y = 0; y < image->GetHeight(); y++) { @@ -686,7 +624,7 @@ *p = le32toh(*p); } } - + NotifySliceImageSuccess(operation, image); } else if (info.GetBitsAllocated() == 16 && @@ -697,31 +635,31 @@ info.GetPhotometricInterpretation() == Orthanc::PhotometricInterpretation_Monochrome2 && raw.size() == info.GetWidth() * info.GetHeight() * 2) { - std::auto_ptr<Orthanc::ImageAccessor> image - (new StringImage(Orthanc::PixelFormat_Grayscale16, info.GetWidth(), - info.GetHeight(), raw)); - + boost::shared_ptr<Orthanc::ImageAccessor> image + (new StringImage(Orthanc::PixelFormat_Grayscale16, info.GetWidth(), + info.GetHeight(), raw)); + // TODO - Big endian ? - + NotifySliceImageSuccess(operation, image); } else { throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); } - + } - - - OrthancSlicesLoader::OrthancSlicesLoader(ICallback& callback, - IWebService& orthanc) : - webCallback_(new WebCallback(*this)), - userCallback_(callback), + + + OrthancSlicesLoader::OrthancSlicesLoader(MessageBroker& broker, + OrthancApiClient& orthanc) : + IObservable(broker), + IObserver(broker), orthanc_(orthanc), state_(State_Initialization) { } - + void OrthancSlicesLoader::ScheduleLoadSeries(const std::string& seriesId) { @@ -732,12 +670,13 @@ else { state_ = State_LoadingGeometry; - std::string uri = "/series/" + seriesId + "/instances-tags"; - orthanc_.ScheduleGetRequest(*webCallback_, uri, Operation::DownloadSeriesGeometry()); + orthanc_.GetJsonAsync("/series/" + seriesId + "/instances-tags", + new Callable<OrthancSlicesLoader, OrthancApiClient::JsonResponseReadyMessage>(*this, &OrthancSlicesLoader::ParseSeriesGeometry), + new Callable<OrthancSlicesLoader, OrthancApiClient::HttpErrorMessage>(*this, &OrthancSlicesLoader::OnGeometryError), + NULL); } } - - + void OrthancSlicesLoader::ScheduleLoadInstance(const std::string& instanceId) { if (state_ != State_Initialization) @@ -747,16 +686,17 @@ else { state_ = State_LoadingGeometry; - + // Tag "3004-000c" is "Grid Frame Offset Vector", which is // mandatory to read RT DOSE, but is too long to be returned by default - std::string uri = "/instances/" + instanceId + "/tags?ignore-length=3004-000c"; - orthanc_.ScheduleGetRequest - (*webCallback_, uri, Operation::DownloadInstanceGeometry(instanceId)); + orthanc_.GetJsonAsync("/instances/" + instanceId + "/tags?ignore-length=3004-000c", + new Callable<OrthancSlicesLoader, OrthancApiClient::JsonResponseReadyMessage>(*this, &OrthancSlicesLoader::ParseInstanceGeometry), + new Callable<OrthancSlicesLoader, OrthancApiClient::HttpErrorMessage>(*this, &OrthancSlicesLoader::OnGeometryError), + Operation::DownloadInstanceGeometry(instanceId)); } } - + void OrthancSlicesLoader::ScheduleLoadFrame(const std::string& instanceId, unsigned int frame) { @@ -767,29 +707,31 @@ else { state_ = State_LoadingGeometry; - std::string uri = "/instances/" + instanceId + "/tags"; - orthanc_.ScheduleGetRequest - (*webCallback_, uri, Operation::DownloadFrameGeometry(instanceId, frame)); + + orthanc_.GetJsonAsync("/instances/" + instanceId + "/tags", + new Callable<OrthancSlicesLoader, OrthancApiClient::JsonResponseReadyMessage>(*this, &OrthancSlicesLoader::ParseFrameGeometry), + new Callable<OrthancSlicesLoader, OrthancApiClient::HttpErrorMessage>(*this, &OrthancSlicesLoader::OnGeometryError), + Operation::DownloadFrameGeometry(instanceId, frame)); } } - + bool OrthancSlicesLoader::IsGeometryReady() const { return state_ == State_GeometryReady; } - - + + size_t OrthancSlicesLoader::GetSliceCount() const { if (state_ != State_GeometryReady) { throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); } - + return slices_.GetSliceCount(); } - + const Slice& OrthancSlicesLoader::GetSlice(size_t index) const { @@ -797,11 +739,11 @@ { throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); } - + return slices_.GetSlice(index); } - + bool OrthancSlicesLoader::LookupSlice(size_t& index, const CoordinateSystem3D& plane) const { @@ -809,76 +751,111 @@ { throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); } - + return slices_.LookupSlice(index, plane); } - + void OrthancSlicesLoader::ScheduleSliceImagePng(const Slice& slice, size_t index) { - std::string uri = ("/instances/" + slice.GetOrthancInstanceId() + "/frames/" + + std::string uri = ("/instances/" + slice.GetOrthancInstanceId() + "/frames/" + + boost::lexical_cast<std::string>(slice.GetFrame())); + + switch (slice.GetConverter().GetExpectedPixelFormat()) + { + case Orthanc::PixelFormat_RGB24: + uri += "/preview"; + break; + + case Orthanc::PixelFormat_Grayscale16: + uri += "/image-uint16"; + break; + + case Orthanc::PixelFormat_SignedGrayscale16: + uri += "/image-int16"; + break; + + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + + orthanc_.GetBinaryAsync(uri, "image/png", + new Callable<OrthancSlicesLoader, OrthancApiClient::BinaryResponseReadyMessage>(*this, &OrthancSlicesLoader::ParseSliceImagePng), + new Callable<OrthancSlicesLoader, OrthancApiClient::HttpErrorMessage>(*this, &OrthancSlicesLoader::OnSliceImageError), + Operation::DownloadSliceImage(index, slice, SliceImageQuality_FullPng)); + } + + void OrthancSlicesLoader::ScheduleSliceImagePam(const Slice& slice, + size_t index) + { + std::string uri = ("/instances/" + slice.GetOrthancInstanceId() + "/frames/" + boost::lexical_cast<std::string>(slice.GetFrame())); switch (slice.GetConverter().GetExpectedPixelFormat()) { - case Orthanc::PixelFormat_RGB24: - uri += "/preview"; - break; + case Orthanc::PixelFormat_RGB24: + uri += "/preview"; + break; - case Orthanc::PixelFormat_Grayscale16: - uri += "/image-uint16"; - break; + case Orthanc::PixelFormat_Grayscale16: + uri += "/image-uint16"; + break; - case Orthanc::PixelFormat_SignedGrayscale16: - uri += "/image-int16"; - break; + case Orthanc::PixelFormat_SignedGrayscale16: + uri += "/image-int16"; + break; - default: - throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); } - orthanc_.ScheduleGetRequest(*webCallback_, uri, - Operation::DownloadSliceImage(index, slice, SliceImageQuality_Full)); + orthanc_.GetBinaryAsync(uri, "image/x-portable-arbitrarymap", + new Callable<OrthancSlicesLoader, OrthancApiClient::BinaryResponseReadyMessage>(*this, &OrthancSlicesLoader::ParseSliceImagePam), + new Callable<OrthancSlicesLoader, OrthancApiClient::HttpErrorMessage>(*this, &OrthancSlicesLoader::OnSliceImageError), + Operation::DownloadSliceImage(index, slice, SliceImageQuality_FullPam)); } + void OrthancSlicesLoader::ScheduleSliceImageJpeg(const Slice& slice, size_t index, SliceImageQuality quality) { unsigned int value; - + switch (quality) { - case SliceImageQuality_Jpeg50: - value = 50; - break; - - case SliceImageQuality_Jpeg90: - value = 90; - break; - - case SliceImageQuality_Jpeg95: - value = 95; - break; + case SliceImageQuality_Jpeg50: + value = 50; + break; - default: - throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + case SliceImageQuality_Jpeg90: + value = 90; + break; + + case SliceImageQuality_Jpeg95: + value = 95; + break; + + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); } // This requires the official Web viewer plugin to be installed! - std::string uri = ("/web-viewer/instances/jpeg" + - boost::lexical_cast<std::string>(value) + - "-" + slice.GetOrthancInstanceId() + "_" + + std::string uri = ("/web-viewer/instances/jpeg" + + boost::lexical_cast<std::string>(value) + + "-" + slice.GetOrthancInstanceId() + "_" + boost::lexical_cast<std::string>(slice.GetFrame())); - - orthanc_.ScheduleGetRequest(*webCallback_, uri, - Operation::DownloadSliceImage(index, slice, quality)); + + orthanc_.GetJsonAsync(uri, + new Callable<OrthancSlicesLoader, OrthancApiClient::JsonResponseReadyMessage>(*this, &OrthancSlicesLoader::ParseSliceImageJpeg), + new Callable<OrthancSlicesLoader, OrthancApiClient::HttpErrorMessage>(*this, &OrthancSlicesLoader::OnSliceImageError), + Operation::DownloadSliceImage(index, slice, quality)); } - - - + + + void OrthancSlicesLoader::ScheduleLoadSliceImage(size_t index, SliceImageQuality quality) { @@ -886,26 +863,31 @@ { throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); } - + const Slice& slice = GetSlice(index); - + if (slice.HasOrthancDecoding()) { - if (quality == SliceImageQuality_Full) + switch (quality) { + case SliceImageQuality_FullPng: ScheduleSliceImagePng(slice, index); - } - else - { + break; + case SliceImageQuality_FullPam: + ScheduleSliceImagePam(slice, index); + break; + default: ScheduleSliceImageJpeg(slice, index, quality); } } else { - std::string uri = ("/instances/" + slice.GetOrthancInstanceId() + "/frames/" + + std::string uri = ("/instances/" + slice.GetOrthancInstanceId() + "/frames/" + boost::lexical_cast<std::string>(slice.GetFrame()) + "/raw.gz"); - orthanc_.ScheduleGetRequest(*webCallback_, uri, - Operation::DownloadSliceRawImage(index, slice)); + orthanc_.GetBinaryAsync(uri, IWebService::Headers(), + new Callable<OrthancSlicesLoader, OrthancApiClient::BinaryResponseReadyMessage>(*this, &OrthancSlicesLoader::ParseSliceRawImage), + new Callable<OrthancSlicesLoader, OrthancApiClient::HttpErrorMessage>(*this, &OrthancSlicesLoader::OnSliceImageError), + Operation::DownloadSliceRawImage(index, slice)); } } }
--- a/Framework/Toolbox/OrthancSlicesLoader.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Toolbox/OrthancSlicesLoader.h Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -24,35 +24,56 @@ #include "IWebService.h" #include "SlicesSorter.h" #include "../StoneEnumerations.h" +#include "../Messages/IObservable.h" +#include <boost/shared_ptr.hpp> +#include "OrthancApiClient.h" +#include "Core/Images/Image.h" -#include <boost/shared_ptr.hpp> namespace OrthancStone { - class OrthancSlicesLoader : public boost::noncopyable + class OrthancSlicesLoader : public IObservable, public IObserver { public: - class ICallback : public boost::noncopyable + + typedef OriginMessage<MessageType_SliceLoader_GeometryReady, OrthancSlicesLoader> SliceGeometryReadyMessage; + typedef OriginMessage<MessageType_SliceLoader_GeometryError, OrthancSlicesLoader> SliceGeometryErrorMessage; + + struct SliceImageReadyMessage : public BaseMessage<MessageType_SliceLoader_ImageReady> { - public: - virtual ~ICallback() + unsigned int sliceIndex_; + const Slice& slice_; + boost::shared_ptr<Orthanc::ImageAccessor> image_; + SliceImageQuality effectiveQuality_; + + SliceImageReadyMessage(unsigned int sliceIndex, + const Slice& slice, + boost::shared_ptr<Orthanc::ImageAccessor> image, + SliceImageQuality effectiveQuality) + : BaseMessage(), + sliceIndex_(sliceIndex), + slice_(slice), + image_(image), + effectiveQuality_(effectiveQuality) { } + }; - virtual void NotifyGeometryReady(const OrthancSlicesLoader& loader) = 0; - - virtual void NotifyGeometryError(const OrthancSlicesLoader& loader) = 0; + struct SliceImageErrorMessage : public BaseMessage<MessageType_SliceLoader_ImageError> + { + const Slice& slice_; + unsigned int sliceIndex_; + SliceImageQuality effectiveQuality_; - virtual void NotifySliceImageReady(const OrthancSlicesLoader& loader, - unsigned int sliceIndex, - const Slice& slice, - std::auto_ptr<Orthanc::ImageAccessor>& image, - SliceImageQuality effectiveQuality) = 0; - - virtual void NotifySliceImageError(const OrthancSlicesLoader& loader, - unsigned int sliceIndex, - const Slice& slice, - SliceImageQuality quality) = 0; + SliceImageErrorMessage(unsigned int sliceIndex, + const Slice& slice, + SliceImageQuality effectiveQuality) + : BaseMessage(), + slice_(slice), + sliceIndex_(sliceIndex), + effectiveQuality_(effectiveQuality) + { + } }; private: @@ -70,51 +91,44 @@ Mode_InstanceGeometry, Mode_FrameGeometry, Mode_LoadImage, - Mode_LoadRawImage + Mode_LoadRawImage, + Mode_LoadDicomFile }; class Operation; - class WebCallback; - boost::shared_ptr<WebCallback> webCallback_; // This is a PImpl pattern - - ICallback& userCallback_; - IWebService& orthanc_; + OrthancApiClient& orthanc_; State state_; SlicesSorter slices_; void NotifySliceImageSuccess(const Operation& operation, - std::auto_ptr<Orthanc::ImageAccessor>& image) const; - - void NotifySliceImageError(const Operation& operation) const; - - void ParseSeriesGeometry(const void* answer, - size_t size); + boost::shared_ptr<Orthanc::ImageAccessor> image); + + void NotifySliceImageError(const Operation& operation); - void ParseInstanceGeometry(const std::string& instanceId, - const void* answer, - size_t size); + void OnGeometryError(const OrthancApiClient::HttpErrorMessage& message); + void OnSliceImageError(const OrthancApiClient::HttpErrorMessage& message); + + void ParseSeriesGeometry(const OrthancApiClient::JsonResponseReadyMessage& message); - void ParseFrameGeometry(const std::string& instanceId, - unsigned int frame, - const void* answer, - size_t size); + void ParseInstanceGeometry(const OrthancApiClient::JsonResponseReadyMessage& message); + + void ParseFrameGeometry(const OrthancApiClient::JsonResponseReadyMessage& message); + + void ParseSliceImagePng(const OrthancApiClient::BinaryResponseReadyMessage& message); - void ParseSliceImagePng(const Operation& operation, - const void* answer, - size_t size); + void ParseSliceImagePam(const OrthancApiClient::BinaryResponseReadyMessage& message); - void ParseSliceImageJpeg(const Operation& operation, - const void* answer, - size_t size); + void ParseSliceImageJpeg(const OrthancApiClient::JsonResponseReadyMessage& message); - void ParseSliceRawImage(const Operation& operation, - const void* answer, - size_t size); + void ParseSliceRawImage(const OrthancApiClient::BinaryResponseReadyMessage& message); void ScheduleSliceImagePng(const Slice& slice, size_t index); - + + void ScheduleSliceImagePam(const Slice& slice, + size_t index); + void ScheduleSliceImageJpeg(const Slice& slice, size_t index, SliceImageQuality quality); @@ -122,8 +136,9 @@ void SortAndFinalizeSlices(); public: - OrthancSlicesLoader(ICallback& callback, - IWebService& orthanc); + OrthancSlicesLoader(MessageBroker& broker, + //ISliceLoaderObserver& callback, + OrthancApiClient& orthancApi); void ScheduleLoadSeries(const std::string& seriesId); @@ -143,5 +158,7 @@ void ScheduleLoadSliceImage(size_t index, SliceImageQuality requestedQuality); + + }; }
--- a/Framework/Toolbox/ShearWarpProjectiveTransform.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Toolbox/ShearWarpProjectiveTransform.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -476,7 +476,7 @@ ApplyAffineTransform(*intermediate, reader.GetAccessor(), a11, 0, b1, 0, a22, b2, - shearInterpolation); + shearInterpolation, true); } @@ -582,7 +582,7 @@ } // (5.b) Apply the projective transform to the image - ApplyProjectiveTransform(target, *intermediate, warp, warpInterpolation); + ApplyProjectiveTransform(target, *intermediate, warp, warpInterpolation, true); }
--- a/Framework/Toolbox/Slice.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Toolbox/Slice.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -45,6 +45,28 @@ return false; } } + + Slice* Slice::Clone() const + { + std::auto_ptr<Slice> target(new Slice()); + + target->type_ = type_; + target->orthancInstanceId_ = orthancInstanceId_; + target->sopClassUid_ = sopClassUid_; + target->frame_ = frame_; + target->frameCount_ = frameCount_; + target->geometry_ = geometry_; + target->pixelSpacingX_ = pixelSpacingX_; + target->pixelSpacingY_ = pixelSpacingY_; + target->thickness_ = thickness_; + target->width_ = width_; + target->height_ = height_; + target->converter_ = converter_; + if (imageInformation_.get() != NULL) + target->imageInformation_.reset(imageInformation_->Clone()); + + return target.release(); + } bool Slice::ComputeRTDoseGeometry(const Orthanc::DicomMap& dataset, unsigned int frame)
--- a/Framework/Toolbox/Slice.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Toolbox/Slice.h Mon Nov 05 10:05:33 2018 +0100 @@ -61,6 +61,16 @@ public: Slice() : type_(Type_Invalid) + { + } + + + // this constructor is used to reference, i.e, a slice that is being loaded + Slice(const std::string& orthancInstanceId, + unsigned int frame) : + type_(Type_Invalid), + orthancInstanceId_(orthancInstanceId), + frame_(frame) { } @@ -136,5 +146,7 @@ void GetExtent(std::vector<Vector>& points) const; const Orthanc::DicomImageInformation& GetImageInformation() const; + + Slice* Clone() const; }; }
--- a/Framework/Toolbox/ViewportGeometry.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Toolbox/ViewportGeometry.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -121,7 +121,19 @@ } - void ViewportGeometry::SetDefaultView() + void ViewportGeometry::MapPixelCenterToScene(double& sceneX, + double& sceneY, + int x, + int y) const + { + // Take the center of the pixel + MapDisplayToScene(sceneX, sceneY, + static_cast<double>(x) + 0.5, + static_cast<double>(y) + 0.5); + } + + + void ViewportGeometry::FitContent() { if (width_ > 0 && height_ > 0 && @@ -167,4 +179,22 @@ zoom_ = zoom; ComputeTransform(); } + + + Matrix ViewportGeometry::GetMatrix() const + { + Matrix m(3, 3); + + m(0, 0) = transform_.xx; + m(0, 1) = transform_.xy; + m(0, 2) = transform_.x0; + m(1, 0) = transform_.yx; + m(1, 1) = transform_.yy; + m(1, 2) = transform_.y0; + m(2, 0) = 0; + m(2, 1) = 0; + m(2, 2) = 1; + + return m; + } }
--- a/Framework/Toolbox/ViewportGeometry.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Toolbox/ViewportGeometry.h Mon Nov 05 10:05:33 2018 +0100 @@ -22,7 +22,8 @@ #pragma once #include "../Viewport/CairoContext.h" -#include "../Toolbox/Extent2D.h" +#include "Extent2D.h" +#include "LinearAlgebra.h" namespace OrthancStone { @@ -63,6 +64,11 @@ double x, double y) const; + void MapPixelCenterToScene(double& sceneX /* out */, + double& sceneY /* out */, + int x, + int y) const; + void MapSceneToDisplay(int& displayX /* out */, int& displayY /* out */, double x, @@ -83,7 +89,7 @@ return zoom_; } - void SetDefaultView(); + void FitContent(); void ApplyTransform(CairoContext& context) const; @@ -94,5 +100,7 @@ double y); void SetZoom(double zoom); + + Matrix GetMatrix() const; }; }
--- a/Framework/Viewport/CairoContext.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Viewport/CairoContext.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -24,9 +24,12 @@ #include <Core/Logging.h> #include <Core/OrthancException.h> + namespace OrthancStone { - CairoContext::CairoContext(CairoSurface& surface) + CairoContext::CairoContext(CairoSurface& surface) : + width_(surface.GetWidth()), + height_(surface.GetHeight()) { context_ = cairo_create(surface.GetObject()); if (!context_) @@ -56,4 +59,88 @@ static_cast<float>(green) / 255.0f, static_cast<float>(blue) / 255.0f); } + + + class CairoContext::AlphaSurface : public boost::noncopyable + { + private: + cairo_surface_t *surface_; + + public: + AlphaSurface(unsigned int width, + unsigned int height) + { + surface_ = cairo_image_surface_create(CAIRO_FORMAT_A8, width, height); + + if (!surface_) + { + // Should never occur + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + if (cairo_surface_status(surface_) != CAIRO_STATUS_SUCCESS) + { + LOG(ERROR) << "Cannot create a Cairo surface"; + cairo_surface_destroy(surface_); + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + } + + ~AlphaSurface() + { + cairo_surface_destroy(surface_); + } + + void GetAccessor(Orthanc::ImageAccessor& target) + { + target.AssignWritable(Orthanc::PixelFormat_Grayscale8, + cairo_image_surface_get_width(surface_), + cairo_image_surface_get_height(surface_), + cairo_image_surface_get_stride(surface_), + cairo_image_surface_get_data(surface_)); + } + + void Blit(cairo_t* cr, + double x, + double y) + { + cairo_surface_mark_dirty(surface_); + cairo_mask_surface(cr, surface_, x, y); + cairo_fill(cr); + } + }; + + + void CairoContext::DrawText(const Orthanc::Font& font, + const std::string& text, + double x, + double y, + BitmapAnchor anchor) + { + // Render a bitmap containing the text + unsigned int width, height; + font.ComputeTextExtent(width, height, text); + + AlphaSurface surface(width, height); + + Orthanc::ImageAccessor accessor; + surface.GetAccessor(accessor); + font.Draw(accessor, text, 0, 0, 255); + + // Correct the text location given the anchor location + double deltaX, deltaY; + ComputeAnchorTranslation(deltaX, deltaY, anchor, width, height); + + // Cancel zoom/rotation before blitting the text onto the surface + double pixelX = x; + double pixelY = y; + cairo_user_to_device(context_, &pixelX, &pixelY); + + cairo_save(context_); + cairo_identity_matrix(context_); + + // Blit the text bitmap + surface.Blit(context_, pixelX + deltaX, pixelY + deltaY); + cairo_restore(context_); + } }
--- a/Framework/Viewport/CairoContext.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Viewport/CairoContext.h Mon Nov 05 10:05:33 2018 +0100 @@ -22,6 +22,9 @@ #pragma once #include "CairoSurface.h" +#include "../StoneEnumerations.h" + +#include <Core/Images/Font.h> namespace OrthancStone { @@ -29,7 +32,11 @@ class CairoContext : public boost::noncopyable { private: - cairo_t* context_; + class AlphaSurface; + + cairo_t* context_; + unsigned int width_; + unsigned int height_; public: CairoContext(CairoSurface& surface); @@ -41,6 +48,16 @@ return context_; } + unsigned int GetWidth() const + { + return width_; + } + + unsigned int GetHeight() const + { + return height_; + } + void SetSourceColor(uint8_t red, uint8_t green, uint8_t blue); @@ -49,5 +66,11 @@ { SetSourceColor(color[0], color[1], color[2]); } + + void DrawText(const Orthanc::Font& font, + const std::string& text, + double x, + double y, + BitmapAnchor anchor); }; }
--- a/Framework/Viewport/CairoFont.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Viewport/CairoFont.h Mon Nov 05 10:05:33 2018 +0100 @@ -21,6 +21,14 @@ #pragma once +#if !defined(ORTHANC_SANDBOXED) +# error The macro ORTHANC_SANDBOXED must be defined +#endif + +#if ORTHANC_SANDBOXED == 1 +# error The class CairoFont cannot be used in sandboxed environments +#endif + #include "CairoContext.h" namespace OrthancStone
--- a/Framework/Viewport/CairoSurface.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Viewport/CairoSurface.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -106,6 +106,7 @@ void CairoSurface::Copy(const CairoSurface& other) { Orthanc::ImageAccessor source, target; + other.GetReadOnlyAccessor(source); GetWriteableAccessor(target);
--- a/Framework/Viewport/IMouseTracker.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Viewport/IMouseTracker.h Mon Nov 05 10:05:33 2018 +0100 @@ -25,6 +25,9 @@ namespace OrthancStone { + // this is tracking a mouse in screen coordinates/pixels unlike + // the IWorldSceneMouseTracker that is tracking a mouse + // in scene coordinates/mm. class IMouseTracker : public boost::noncopyable { public:
--- a/Framework/Viewport/IViewport.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Viewport/IViewport.h Mon Nov 05 10:05:33 2018 +0100 @@ -40,14 +40,14 @@ { } - virtual void NotifyChange(const IViewport& scene) = 0; + virtual void OnViewportContentChanged(const IViewport& scene) = 0; }; virtual ~IViewport() { } - virtual void SetDefaultView() = 0; + virtual void FitContent() = 0; virtual void Register(IObserver& observer) = 0; @@ -78,7 +78,8 @@ int y, KeyboardModifiers modifiers) = 0; - virtual void KeyPressed(char key, + virtual void KeyPressed(KeyboardKeys key, + char keyChar, KeyboardModifiers modifiers) = 0; virtual bool HasUpdateContent() = 0; @@ -86,6 +87,6 @@ virtual void UpdateContent() = 0; // Should only be called from IWidget - virtual void NotifyChange(const IWidget& widget) = 0; + virtual void NotifyContentChanged(const IWidget& widget) = 0; }; }
--- a/Framework/Viewport/WidgetViewport.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Viewport/WidgetViewport.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -36,11 +36,11 @@ } - void WidgetViewport::SetDefaultView() + void WidgetViewport::FitContent() { if (centralWidget_.get() != NULL) { - centralWidget_->SetDefaultView(); + centralWidget_->FitContent(); } } @@ -64,7 +64,7 @@ } mouseTracker_.reset(NULL); - + centralWidget_.reset(widget); centralWidget_->SetViewport(*this); @@ -74,16 +74,16 @@ } backgroundChanged_ = true; - observers_.Apply(*this, &IObserver::NotifyChange); + observers_.Apply(*this, &IObserver::OnViewportContentChanged); return *widget; } - void WidgetViewport::NotifyChange(const IWidget& widget) + void WidgetViewport::NotifyContentChanged(const IWidget& widget) { backgroundChanged_ = true; - observers_.Apply(*this, &IObserver::NotifyChange); + observers_.Apply(*this, &IObserver::OnViewportContentChanged); } @@ -97,7 +97,7 @@ centralWidget_->SetSize(width, height); } - observers_.Apply(*this, &IObserver::NotifyChange); + observers_.Apply(*this, &IObserver::OnViewportContentChanged); } @@ -155,7 +155,7 @@ mouseTracker_.reset(NULL); } - observers_.Apply(*this, &IObserver::NotifyChange); + observers_.Apply(*this, &IObserver::OnViewportContentChanged); } @@ -165,7 +165,7 @@ { mouseTracker_->MouseUp(); mouseTracker_.reset(NULL); - observers_.Apply(*this, &IObserver::NotifyChange); + observers_.Apply(*this, &IObserver::OnViewportContentChanged); } } @@ -196,7 +196,7 @@ if (repaint) { // The scene must be repainted, notify the observers - observers_.Apply(*this, &IObserver::NotifyChange); + observers_.Apply(*this, &IObserver::OnViewportContentChanged); } } @@ -204,7 +204,7 @@ void WidgetViewport::MouseEnter() { isMouseOver_ = true; - observers_.Apply(*this, &IObserver::NotifyChange); + observers_.Apply(*this, &IObserver::OnViewportContentChanged); } @@ -218,7 +218,7 @@ mouseTracker_.reset(NULL); } - observers_.Apply(*this, &IObserver::NotifyChange); + observers_.Apply(*this, &IObserver::OnViewportContentChanged); } @@ -235,13 +235,14 @@ } - void WidgetViewport::KeyPressed(char key, + void WidgetViewport::KeyPressed(KeyboardKeys key, + char keyChar, KeyboardModifiers modifiers) { if (centralWidget_.get() != NULL && mouseTracker_.get() == NULL) { - centralWidget_->KeyPressed(key, modifiers); + centralWidget_->KeyPressed(key, keyChar, modifiers); } }
--- a/Framework/Viewport/WidgetViewport.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Viewport/WidgetViewport.h Mon Nov 05 10:05:33 2018 +0100 @@ -45,13 +45,13 @@ public: WidgetViewport(); - virtual void SetDefaultView(); + virtual void FitContent(); virtual void SetStatusBar(IStatusBar& statusBar); IWidget& SetCentralWidget(IWidget* widget); // Takes ownership - virtual void NotifyChange(const IWidget& widget); + virtual void NotifyContentChanged(const IWidget& widget); virtual void Register(IObserver& observer) { @@ -82,7 +82,8 @@ int y, KeyboardModifiers modifiers); - virtual void KeyPressed(char key, + virtual void KeyPressed(KeyboardKeys key, + char keyChar, KeyboardModifiers modifiers); virtual bool HasUpdateContent();
--- a/Framework/Volumes/ImageBuffer3D.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Volumes/ImageBuffer3D.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -91,7 +91,7 @@ for (unsigned int y = 0; y < height_; y++) { - const void* source = (reinterpret_cast<const uint8_t*>(image_.GetConstRow(y + z * height_)) + + const void* source = (reinterpret_cast<const uint8_t*>(image_.GetConstRow(y + z * height_)) + bytesPerPixel * slice); memcpy(target, source, bytesPerPixel); @@ -157,20 +157,20 @@ Vector result; switch (projection) { - case VolumeProjection_Axial: - result = voxelDimensions_; - break; + case VolumeProjection_Axial: + result = voxelDimensions_; + break; - case VolumeProjection_Coronal: - LinearAlgebra::AssignVector(result, voxelDimensions_[0], voxelDimensions_[2], voxelDimensions_[1]); - break; + case VolumeProjection_Coronal: + LinearAlgebra::AssignVector(result, voxelDimensions_[0], voxelDimensions_[2], voxelDimensions_[1]); + break; - case VolumeProjection_Sagittal: - LinearAlgebra::AssignVector(result, voxelDimensions_[1], voxelDimensions_[2], voxelDimensions_[0]); - break; + case VolumeProjection_Sagittal: + LinearAlgebra::AssignVector(result, voxelDimensions_[1], voxelDimensions_[2], voxelDimensions_[0]); + break; - default: - throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); } return result; @@ -183,23 +183,23 @@ { switch (projection) { - case VolumeProjection_Axial: - width = width_; - height = height_; - break; + case VolumeProjection_Axial: + width = width_; + height = height_; + break; - case VolumeProjection_Coronal: - width = width_; - height = depth_; - break; + case VolumeProjection_Coronal: + width = width_; + height = depth_; + break; - case VolumeProjection_Sagittal: - width = height_; - height = depth_; - break; + case VolumeProjection_Sagittal: + width = height_; + height = depth_; + break; - default: - throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); } } @@ -210,51 +210,51 @@ switch (projection) { - case VolumeProjection_Axial: - for (unsigned int z = 0; z < depth_; z++) - { - Vector origin = axialGeometry_.GetOrigin(); - origin += static_cast<double>(z) * voxelDimensions_[2] * axialGeometry_.GetNormal(); + case VolumeProjection_Axial: + for (unsigned int z = 0; z < depth_; z++) + { + Vector origin = axialGeometry_.GetOrigin(); + origin += static_cast<double>(z) * voxelDimensions_[2] * axialGeometry_.GetNormal(); - result->AddSlice(origin, - axialGeometry_.GetAxisX(), - axialGeometry_.GetAxisY()); - } - break; + result->AddSlice(origin, + axialGeometry_.GetAxisX(), + axialGeometry_.GetAxisY()); + } + break; - case VolumeProjection_Coronal: - for (unsigned int y = 0; y < height_; y++) - { - Vector origin = axialGeometry_.GetOrigin(); - origin += static_cast<double>(y) * voxelDimensions_[1] * axialGeometry_.GetAxisY(); - origin += static_cast<double>(depth_ - 1) * voxelDimensions_[2] * axialGeometry_.GetNormal(); + case VolumeProjection_Coronal: + for (unsigned int y = 0; y < height_; y++) + { + Vector origin = axialGeometry_.GetOrigin(); + origin += static_cast<double>(y) * voxelDimensions_[1] * axialGeometry_.GetAxisY(); + origin += static_cast<double>(depth_ - 1) * voxelDimensions_[2] * axialGeometry_.GetNormal(); - result->AddSlice(origin, - axialGeometry_.GetAxisX(), - -axialGeometry_.GetNormal()); - } - break; + result->AddSlice(origin, + axialGeometry_.GetAxisX(), + -axialGeometry_.GetNormal()); + } + break; - case VolumeProjection_Sagittal: - for (unsigned int x = 0; x < width_; x++) - { - Vector origin = axialGeometry_.GetOrigin(); - origin += static_cast<double>(x) * voxelDimensions_[0] * axialGeometry_.GetAxisX(); - origin += static_cast<double>(depth_ - 1) * voxelDimensions_[2] * axialGeometry_.GetNormal(); + case VolumeProjection_Sagittal: + for (unsigned int x = 0; x < width_; x++) + { + Vector origin = axialGeometry_.GetOrigin(); + origin += static_cast<double>(x) * voxelDimensions_[0] * axialGeometry_.GetAxisX(); + origin += static_cast<double>(depth_ - 1) * voxelDimensions_[2] * axialGeometry_.GetNormal(); - result->AddSlice(origin, - axialGeometry_.GetAxisY(), - -axialGeometry_.GetNormal()); - } - break; + result->AddSlice(origin, + axialGeometry_.GetAxisY(), + -axialGeometry_.GetNormal()); + } + break; - default: - throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); } return result.release(); } - + uint64_t ImageBuffer3D::GetEstimatedMemorySize() const { @@ -272,27 +272,27 @@ } float sliceMin, sliceMax; - + switch (slice.GetFormat()) { - case Orthanc::PixelFormat_Grayscale8: - case Orthanc::PixelFormat_Grayscale16: - case Orthanc::PixelFormat_Grayscale32: - case Orthanc::PixelFormat_SignedGrayscale16: - { - int64_t a, b; - Orthanc::ImageProcessing::GetMinMaxIntegerValue(a, b, slice); - sliceMin = static_cast<float>(a); - sliceMax = static_cast<float>(b); - break; - } + case Orthanc::PixelFormat_Grayscale8: + case Orthanc::PixelFormat_Grayscale16: + case Orthanc::PixelFormat_Grayscale32: + case Orthanc::PixelFormat_SignedGrayscale16: + { + int64_t a, b; + Orthanc::ImageProcessing::GetMinMaxIntegerValue(a, b, slice); + sliceMin = static_cast<float>(a); + sliceMax = static_cast<float>(b); + break; + } - case Orthanc::PixelFormat_Float32: - Orthanc::ImageProcessing::GetMinMaxFloatValue(sliceMin, sliceMax, slice); - break; + case Orthanc::PixelFormat_Float32: + Orthanc::ImageProcessing::GetMinMaxFloatValue(sliceMin, sliceMax, slice); + break; - default: - return; + default: + return; } if (hasRange_) @@ -366,8 +366,8 @@ sagittal_->GetReadOnlyAccessor(accessor_); break; - default: - throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); } } @@ -379,7 +379,7 @@ if (sagittal_.get() != NULL) { // TODO - throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); + throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); } // Update the dynamic range of the underlying image, if @@ -410,8 +410,8 @@ sagittal_->GetWriteableAccessor(accessor_); break; - default: - throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); } } @@ -467,11 +467,11 @@ const CoordinateSystem3D& axial = GetAxialGeometry(); Vector origin = (axial.MapSliceToWorldCoordinates(-0.5 * ps[0], -0.5 * ps[1]) - - 0.5 * ps[2] * axial.GetNormal()); + 0.5 * ps[2] * axial.GetNormal()); return (origin + axial.GetAxisX() * ps[0] * x * static_cast<double>(GetWidth()) + - axial.GetAxisY() * ps[1] * y * static_cast<double>(GetHeight()) + - axial.GetNormal() * ps[2] * z * static_cast<double>(GetDepth())); + axial.GetAxisY() * ps[1] * y * static_cast<double>(GetHeight()) + + axial.GetNormal() * ps[2] * z * static_cast<double>(GetDepth())); } }
--- a/Framework/Volumes/ImageBuffer3D.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Volumes/ImageBuffer3D.h Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/
--- a/Framework/Volumes/StructureSetLoader.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Volumes/StructureSetLoader.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -27,130 +27,63 @@ namespace OrthancStone { - class StructureSetLoader::Operation : public Orthanc::IDynamicObject - { - public: - enum Type - { - Type_LoadStructureSet, - Type_LookupSopInstanceUid, - Type_LoadReferencedSlice - }; - - private: - Type type_; - std::string value_; - - public: - Operation(Type type, - const std::string& value) : - type_(type), - value_(value) - { - } - - Type GetType() const - { - return type_; - } - - const std::string& GetIdentifier() const - { - return value_; - } - }; - - - void StructureSetLoader::NotifyError(const std::string& uri, - Orthanc::IDynamicObject* payload) - { - // TODO - } - - void StructureSetLoader::NotifySuccess(const std::string& uri, - const void* answer, - size_t answerSize, - Orthanc::IDynamicObject* payload) - { - std::auto_ptr<Operation> op(dynamic_cast<Operation*>(payload)); - - switch (op->GetType()) - { - case Operation::Type_LoadStructureSet: - { - OrthancPlugins::FullOrthancDataset dataset(answer, answerSize); - structureSet_.reset(new DicomStructureSet(dataset)); - - std::set<std::string> instances; - structureSet_->GetReferencedInstances(instances); - - for (std::set<std::string>::const_iterator it = instances.begin(); - it != instances.end(); ++it) - { - orthanc_.SchedulePostRequest(*this, "/tools/lookup", *it, - new Operation(Operation::Type_LookupSopInstanceUid, *it)); - } - - VolumeLoaderBase::NotifyGeometryReady(); - - break; - } - - case Operation::Type_LookupSopInstanceUid: - { - Json::Value lookup; - - if (MessagingToolbox::ParseJson(lookup, answer, answerSize)) - { - if (lookup.type() != Json::arrayValue || - lookup.size() != 1 || - !lookup[0].isMember("Type") || - !lookup[0].isMember("Path") || - lookup[0]["Type"].type() != Json::stringValue || - lookup[0]["ID"].type() != Json::stringValue || - lookup[0]["Type"].asString() != "Instance") - { - throw Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol); - } - - const std::string& instance = lookup[0]["ID"].asString(); - orthanc_.ScheduleGetRequest(*this, "/instances/" + instance + "/tags", - new Operation(Operation::Type_LoadReferencedSlice, instance)); - } - else - { - // TODO - } - - break; - } - - case Operation::Type_LoadReferencedSlice: - { - OrthancPlugins::FullOrthancDataset dataset(answer, answerSize); - - Orthanc::DicomMap slice; - MessagingToolbox::ConvertDataset(slice, dataset); - structureSet_->AddReferencedSlice(slice); - - VolumeLoaderBase::NotifyContentChange(); - - break; - } - - default: - throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); - } - } - - - StructureSetLoader::StructureSetLoader(IWebService& orthanc) : + StructureSetLoader::StructureSetLoader(MessageBroker& broker, OrthancApiClient& orthanc) : + OrthancStone::IObserver(broker), orthanc_(orthanc) { } + void StructureSetLoader::OnReferencedSliceLoaded(const OrthancApiClient::JsonResponseReadyMessage& message) + { + OrthancPlugins::FullOrthancDataset dataset(message.Response); + + Orthanc::DicomMap slice; + MessagingToolbox::ConvertDataset(slice, dataset); + structureSet_->AddReferencedSlice(slice); + + VolumeLoaderBase::NotifyContentChange(); + } + + void StructureSetLoader::OnStructureSetLoaded(const OrthancApiClient::JsonResponseReadyMessage& message) + { + OrthancPlugins::FullOrthancDataset dataset(message.Response); + structureSet_.reset(new DicomStructureSet(dataset)); + + std::set<std::string> instances; + structureSet_->GetReferencedInstances(instances); + + for (std::set<std::string>::const_iterator it = instances.begin(); + it != instances.end(); ++it) + { + orthanc_.PostBinaryAsyncExpectJson("/tools/lookup", *it, + new Callable<StructureSetLoader, OrthancApiClient::JsonResponseReadyMessage>(*this, &StructureSetLoader::OnLookupCompleted)); + } + + VolumeLoaderBase::NotifyGeometryReady(); + } + + void StructureSetLoader::OnLookupCompleted(const OrthancApiClient::JsonResponseReadyMessage& message) + { + Json::Value lookup = message.Response; + + if (lookup.type() != Json::arrayValue || + lookup.size() != 1 || + !lookup[0].isMember("Type") || + !lookup[0].isMember("Path") || + lookup[0]["Type"].type() != Json::stringValue || + lookup[0]["ID"].type() != Json::stringValue || + lookup[0]["Type"].asString() != "Instance") + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol); + } + + const std::string& instance = lookup[0]["ID"].asString(); + orthanc_.GetJsonAsync("/instances/" + instance + "/tags", + new Callable<StructureSetLoader, OrthancApiClient::JsonResponseReadyMessage>(*this, &StructureSetLoader::OnReferencedSliceLoaded)); + } + void StructureSetLoader::ScheduleLoadInstance(const std::string& instance) { if (structureSet_.get() != NULL) @@ -159,8 +92,8 @@ } else { - const std::string uri = "/instances/" + instance + "/tags?ignore-length=3006-0050"; - orthanc_.ScheduleGetRequest(*this, uri, new Operation(Operation::Type_LoadStructureSet, instance)); + orthanc_.GetJsonAsync("/instances/" + instance + "/tags?ignore-length=3006-0050", + new Callable<StructureSetLoader, OrthancApiClient::JsonResponseReadyMessage>(*this, &StructureSetLoader::OnStructureSetLoaded)); } }
--- a/Framework/Volumes/StructureSetLoader.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Volumes/StructureSetLoader.h Mon Nov 05 10:05:33 2018 +0100 @@ -22,31 +22,22 @@ #pragma once #include "../Toolbox/DicomStructureSet.h" -#include "../Toolbox/IWebService.h" +#include "../Toolbox/OrthancApiClient.h" #include "VolumeLoaderBase.h" namespace OrthancStone { class StructureSetLoader : public VolumeLoaderBase, - private IWebService::ICallback + public OrthancStone::IObserver { private: - class Operation; - - virtual void NotifyError(const std::string& uri, - Orthanc::IDynamicObject* payload); - virtual void NotifySuccess(const std::string& uri, - const void* answer, - size_t answerSize, - Orthanc::IDynamicObject* payload); - - IWebService& orthanc_; + OrthancApiClient& orthanc_; std::auto_ptr<DicomStructureSet> structureSet_; public: - StructureSetLoader(IWebService& orthanc); + StructureSetLoader(MessageBroker& broker, OrthancApiClient& orthanc); void ScheduleLoadInstance(const std::string& instance); @@ -56,5 +47,12 @@ } DicomStructureSet& GetStructureSet(); + + protected: + void OnReferencedSliceLoaded(const OrthancApiClient::JsonResponseReadyMessage& message); + + void OnStructureSetLoaded(const OrthancApiClient::JsonResponseReadyMessage& message); + + void OnLookupCompleted(const OrthancApiClient::JsonResponseReadyMessage& message); }; }
--- a/Framework/Widgets/CairoWidget.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/CairoWidget.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -32,6 +32,10 @@ return true; } + CairoWidget::CairoWidget(const std::string& name) : + WidgetBase(name) + { + } void CairoWidget::SetSize(unsigned int width, unsigned int height)
--- a/Framework/Widgets/CairoWidget.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/CairoWidget.h Mon Nov 05 10:05:33 2018 +0100 @@ -38,6 +38,8 @@ int y) = 0; public: + CairoWidget(const std::string& name); + virtual void SetSize(unsigned int width, unsigned int height);
--- a/Framework/Widgets/EmptyWidget.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/EmptyWidget.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -26,19 +26,16 @@ namespace OrthancStone { - namespace Samples + bool EmptyWidget::Render(Orthanc::ImageAccessor& surface) { - bool EmptyWidget::Render(Orthanc::ImageAccessor& surface) - { - // Note: This call is slow - Orthanc::ImageProcessing::Set(surface, red_, green_, blue_, 255); - return true; - } + // Note: This call is slow + Orthanc::ImageProcessing::Set(surface, red_, green_, blue_, 255); + return true; + } - - void EmptyWidget::UpdateContent() - { - throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); - } + + void EmptyWidget::UpdateContent() + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); } }
--- a/Framework/Widgets/EmptyWidget.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/EmptyWidget.h Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -25,93 +25,91 @@ namespace OrthancStone { - namespace Samples - { - /** + /** * This is a test widget that simply fills its surface with an * uniform color. **/ - class EmptyWidget : public IWidget - { - private: - uint8_t red_; - uint8_t green_; - uint8_t blue_; + class EmptyWidget : public IWidget + { + private: + uint8_t red_; + uint8_t green_; + uint8_t blue_; - public: - EmptyWidget(uint8_t red, - uint8_t green, - uint8_t blue) : - red_(red), - green_(green), - blue_(blue) - { - } + public: + EmptyWidget(uint8_t red, + uint8_t green, + uint8_t blue) : + red_(red), + green_(green), + blue_(blue) + { + } + + virtual void FitContent() + { + } - virtual void SetDefaultView() - { - } - - virtual void SetParent(OrthancStone::IWidget& widget) - { - } - - virtual void SetViewport(IViewport& viewport) - { - } + virtual void SetParent(IWidget& widget) + { + } + + virtual void SetViewport(IViewport& viewport) + { + } - virtual void NotifyChange() - { - } + virtual void NotifyContentChanged() + { + } - virtual void SetStatusBar(IStatusBar& statusBar) - { - } + virtual void SetStatusBar(IStatusBar& statusBar) + { + } + + virtual void SetSize(unsigned int width, + unsigned int height) + { + } - virtual void SetSize(unsigned int width, - unsigned int height) - { - } - - virtual bool Render(Orthanc::ImageAccessor& surface); + virtual bool Render(Orthanc::ImageAccessor& surface); - virtual IMouseTracker* CreateMouseTracker(MouseButton button, - int x, - int y, - KeyboardModifiers modifiers) - { - return NULL; - } + virtual IMouseTracker* CreateMouseTracker(MouseButton button, + int x, + int y, + KeyboardModifiers modifiers) + { + return NULL; + } - virtual void RenderMouseOver(Orthanc::ImageAccessor& target, - int x, - int y) - { - } + virtual void RenderMouseOver(Orthanc::ImageAccessor& target, + int x, + int y) + { + } - virtual void MouseWheel(MouseWheelDirection direction, - int x, - int y, - KeyboardModifiers modifiers) - { - } + virtual void MouseWheel(MouseWheelDirection direction, + int x, + int y, + KeyboardModifiers modifiers) + { + } - virtual void KeyPressed(char key, - KeyboardModifiers modifiers) - { - } + virtual void KeyPressed(KeyboardKeys key, + char keyChar, + KeyboardModifiers modifiers) + { + } - virtual bool HasUpdateContent() const - { - return false; - } + virtual bool HasUpdateContent() const + { + return false; + } - virtual void UpdateContent(); + virtual void UpdateContent(); - virtual bool HasRenderMouseOver() - { - return false; - } - }; - } + virtual bool HasRenderMouseOver() + { + return false; + } + }; }
--- a/Framework/Widgets/IWidget.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/IWidget.h Mon Nov 05 10:05:33 2018 +0100 @@ -35,7 +35,7 @@ { } - virtual void SetDefaultView() = 0; + virtual void FitContent() = 0; virtual void SetParent(IWidget& parent) = 0; @@ -64,7 +64,8 @@ int y, KeyboardModifiers modifiers) = 0; - virtual void KeyPressed(char key, + virtual void KeyPressed(KeyboardKeys key, + char keyChar, KeyboardModifiers modifiers) = 0; virtual bool HasUpdateContent() const = 0; @@ -73,6 +74,6 @@ // Subclasses can call this method to signal the display of the // widget must be refreshed - virtual void NotifyChange() = 0; + virtual void NotifyContentChanged() = 0; }; }
--- a/Framework/Widgets/IWorldSceneInteractor.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/IWorldSceneInteractor.h Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -29,37 +29,41 @@ namespace OrthancStone { - class WorldSceneWidget; + class WorldSceneWidget; - class IWorldSceneInteractor : public boost::noncopyable - { - public: - virtual ~IWorldSceneInteractor() + class IWorldSceneInteractor : public boost::noncopyable { - } - - virtual IWorldSceneMouseTracker* CreateMouseTracker(WorldSceneWidget& widget, - const ViewportGeometry& view, - MouseButton button, - double x, - double y, - IStatusBar* statusBar) = 0; + public: + virtual ~IWorldSceneInteractor() + { + } + + virtual IWorldSceneMouseTracker* CreateMouseTracker(WorldSceneWidget& widget, + const ViewportGeometry& view, + MouseButton button, + KeyboardModifiers modifiers, + int viewportX, + int viewportY, + double x, + double y, + IStatusBar* statusBar) = 0; - virtual void MouseOver(CairoContext& context, - WorldSceneWidget& widget, - const ViewportGeometry& view, - double x, - double y, - IStatusBar* statusBar) = 0; + virtual void MouseOver(CairoContext& context, + WorldSceneWidget& widget, + const ViewportGeometry& view, + double x, + double y, + IStatusBar* statusBar) = 0; - virtual void MouseWheel(WorldSceneWidget& widget, - MouseWheelDirection direction, - KeyboardModifiers modifiers, - IStatusBar* statusBar) = 0; + virtual void MouseWheel(WorldSceneWidget& widget, + MouseWheelDirection direction, + KeyboardModifiers modifiers, + IStatusBar* statusBar) = 0; - virtual void KeyPressed(WorldSceneWidget& widget, - char key, - KeyboardModifiers modifiers, - IStatusBar* statusBar) = 0; - }; + virtual void KeyPressed(WorldSceneWidget& widget, + KeyboardKeys key, + char keyChar, + KeyboardModifiers modifiers, + IStatusBar* statusBar) = 0; + }; }
--- a/Framework/Widgets/IWorldSceneMouseTracker.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/IWorldSceneMouseTracker.h Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -25,19 +25,27 @@ namespace OrthancStone { + + // this is tracking a mouse in scene coordinates/mm unlike + // the IMouseTracker that is tracking a mouse + // in screen coordinates/pixels. class IWorldSceneMouseTracker : public boost::noncopyable { public: virtual ~IWorldSceneMouseTracker() { } - + + virtual bool HasRender() const = 0; + virtual void Render(CairoContext& context, double zoom) = 0; - + virtual void MouseUp() = 0; - virtual void MouseMove(double x, - double y) = 0; + virtual void MouseMove(int displayX, + int displayY, + double sceneX, + double sceneY) = 0; }; }
--- a/Framework/Widgets/LayerWidget.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/LayerWidget.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -23,6 +23,7 @@ #include "../Layers/SliceOutlineRenderer.h" #include "../Toolbox/GeometryToolbox.h" +#include "Framework/Layers/FrameRenderer.h" #include <Core/Logging.h> @@ -37,7 +38,7 @@ double thickness_; size_t countMissing_; std::vector<ILayerRenderer*> renderers_; - +public: void DeleteLayer(size_t index) { if (index >= renderers_.size()) @@ -55,8 +56,7 @@ countMissing_++; } } - - public: + Scene(const CoordinateSystem3D& slice, double thickness, size_t countLayers) : @@ -184,7 +184,7 @@ #endif cairo_set_line_width(cr, 2.0 / view.GetZoom()); - cairo_set_source_rgb(cr, 1, 1, 1); + cairo_set_source_rgb(cr, 1, 1, 1); cairo_stroke_preserve(cr); cairo_set_source_rgb(cr, 1, 0, 0); cairo_fill(cr); @@ -215,7 +215,7 @@ { double z = (slice_.ProjectAlongNormal(slice.GetOrigin()) - slice_.ProjectAlongNormal(slice_.GetOrigin())); - + if (z < 0) { z = -z; @@ -249,13 +249,13 @@ return true; } } - + void LayerWidget::GetLayerExtent(Extent2D& extent, ILayerSource& source) const { extent.Reset(); - + std::vector<Vector> points; if (source.GetExtent(points, slice_)) { @@ -268,7 +268,7 @@ } } - + Extent2D LayerWidget::GetSceneExtent() { Extent2D sceneExtent; @@ -341,7 +341,7 @@ currentScene_->ContainsPlane(slice)) { currentScene_->SetLayer(index, tmp.release()); - NotifyChange(); + NotifyContentChanged(); } else if (pendingScene_.get() != NULL && pendingScene_->ContainsPlane(slice)) @@ -353,13 +353,16 @@ pendingScene_->IsComplete()) { currentScene_ = pendingScene_; - NotifyChange(); + NotifyContentChanged(); } } } - LayerWidget::LayerWidget() : + LayerWidget::LayerWidget(MessageBroker& broker, const std::string& name) : + WorldSceneWidget(name), + IObserver(broker), + IObservable(broker), started_(false) { SetBackgroundCleared(true); @@ -374,6 +377,15 @@ } } + void LayerWidget::ObserveLayer(ILayerSource& layer) + { + layer.RegisterObserverCallback(new Callable<LayerWidget, ILayerSource::GeometryReadyMessage>(*this, &LayerWidget::OnGeometryReady)); + // currently ignore errors layer->RegisterObserverCallback(new Callable<LayerWidget, ILayerSource::GeometryErrorMessage>(*this, &LayerWidget::...)); + layer.RegisterObserverCallback(new Callable<LayerWidget, ILayerSource::SliceChangedMessage>(*this, &LayerWidget::OnSliceChanged)); + layer.RegisterObserverCallback(new Callable<LayerWidget, ILayerSource::ContentChangedMessage>(*this, &LayerWidget::OnContentChanged)); + layer.RegisterObserverCallback(new Callable<LayerWidget, ILayerSource::LayerReadyMessage>(*this, &LayerWidget::OnLayerReady)); + } + size_t LayerWidget::AddLayer(ILayerSource* layer) // Takes ownership { @@ -388,14 +400,58 @@ layersIndex_[layer] = index; ResetPendingScene(); - layer->Register(*this); + + ObserveLayer(*layer); ResetChangedLayers(); return index; } - + void LayerWidget::ReplaceLayer(size_t index, ILayerSource* layer) // Takes ownership + { + if (layer == NULL) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); + } + + if (index >= layers_.size()) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + + delete layers_[index]; + layers_[index] = layer; + layersIndex_[layer] = index; + + ResetPendingScene(); + + ObserveLayer(*layer); + + InvalidateLayer(index); + } + + void LayerWidget::RemoveLayer(size_t index) + { + if (index >= layers_.size()) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + + ILayerSource* previousLayer = layers_[index]; + layersIndex_.erase(layersIndex_.find(previousLayer)); + layers_.erase(layers_.begin() + index); + changedLayers_.erase(changedLayers_.begin() + index); + styles_.erase(styles_.begin() + index); + + delete layers_[index]; + + currentScene_->DeleteLayer(index); + ResetPendingScene(); + + NotifyContentChanged(); + } + const RenderStyle& LayerWidget::GetLayerStyle(size_t layer) const { if (layer >= layers_.size()) @@ -429,7 +485,7 @@ pendingScene_->SetLayerStyle(layer, style); } - NotifyChange(); + NotifyContentChanged(); } @@ -457,26 +513,19 @@ } } - - void LayerWidget::NotifyGeometryReady(const ILayerSource& source) + void LayerWidget::OnGeometryReady(const ILayerSource::GeometryReadyMessage& message) { size_t i; - if (LookupLayer(i, source)) + if (LookupLayer(i, message.origin_)) { - LOG(INFO) << "Geometry ready for layer " << i; + LOG(INFO) << ": Geometry ready for layer " << i << " in " << GetName(); changedLayers_[i] = true; //layers_[i]->ScheduleLayerCreation(slice_); } + EmitMessage(GeometryChangedMessage(*this)); } - - void LayerWidget::NotifyGeometryError(const ILayerSource& source) - { - LOG(ERROR) << "Cannot get geometry"; - } - - void LayerWidget::InvalidateAllLayers() { for (size_t i = 0; i < layers_.size(); i++) @@ -503,39 +552,37 @@ } - void LayerWidget::NotifyContentChange(const ILayerSource& source) + void LayerWidget::OnContentChanged(const ILayerSource::ContentChangedMessage& message) { size_t index; - if (LookupLayer(index, source)) + if (LookupLayer(index, message.origin_)) { InvalidateLayer(index); } + EmitMessage(LayerWidget::ContentChangedMessage(*this)); } - void LayerWidget::NotifySliceChange(const ILayerSource& source, - const Slice& slice) + void LayerWidget::OnSliceChanged(const ILayerSource::SliceChangedMessage& message) { - if (slice.ContainsPlane(slice_)) + if (message.slice_.ContainsPlane(slice_)) { size_t index; - if (LookupLayer(index, source)) + if (LookupLayer(index, message.origin_)) { InvalidateLayer(index); } } + EmitMessage(LayerWidget::ContentChangedMessage(*this)); } - void LayerWidget::NotifyLayerReady(std::auto_ptr<ILayerRenderer>& renderer, - const ILayerSource& source, - const CoordinateSystem3D& slice, - bool isError) + void LayerWidget::OnLayerReady(const ILayerSource::LayerReadyMessage& message) { size_t index; - if (LookupLayer(index, source)) + if (LookupLayer(index, message.origin_)) { - if (isError) + if (message.isError_) { LOG(ERROR) << "Using error renderer on layer " << index; } @@ -543,17 +590,18 @@ { LOG(INFO) << "Renderer ready for layer " << index; } - - if (renderer.get() != NULL) + + if (message.renderer_.get() != NULL) { - UpdateLayer(index, renderer.release(), slice); + UpdateLayer(index, message.renderer_.release(), message.slice_); } - else if (isError) + else if (message.isError_) { // TODO //UpdateLayer(index, new SliceOutlineRenderer(slice), slice); } } + EmitMessage(LayerWidget::ContentChangedMessage(*this)); }
--- a/Framework/Widgets/LayerWidget.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/LayerWidget.h Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -24,15 +24,21 @@ #include "WorldSceneWidget.h" #include "../Layers/ILayerSource.h" #include "../Toolbox/Extent2D.h" +#include "../../Framework/Messages/IObserver.h" #include <map> namespace OrthancStone { class LayerWidget : - public WorldSceneWidget, - private ILayerSource::IObserver + public WorldSceneWidget, + public IObserver, + public IObservable { + public: + typedef OriginMessage<MessageType_Widget_GeometryChanged, LayerWidget> GeometryChangedMessage; + typedef OriginMessage<MessageType_Widget_ContentChanged, LayerWidget> ContentChangedMessage; + private: class Scene; @@ -53,25 +59,23 @@ void GetLayerExtent(Extent2D& extent, ILayerSource& source) const; - virtual void NotifyGeometryReady(const ILayerSource& source); + void OnGeometryReady(const ILayerSource::GeometryReadyMessage& message); - virtual void NotifyGeometryError(const ILayerSource& source); - - virtual void NotifyContentChange(const ILayerSource& source); + virtual void OnContentChanged(const ILayerSource::ContentChangedMessage& message); - virtual void NotifySliceChange(const ILayerSource& source, - const Slice& slice); + virtual void OnSliceChanged(const ILayerSource::SliceChangedMessage& message); - virtual void NotifyLayerReady(std::auto_ptr<ILayerRenderer>& renderer, - const ILayerSource& source, - const CoordinateSystem3D& slice, - bool isError); + virtual void OnLayerReady(const ILayerSource::LayerReadyMessage& message); + + void ObserveLayer(ILayerSource& source); void ResetChangedLayers(); public: + LayerWidget(MessageBroker& broker, const std::string& name); + virtual Extent2D GetSceneExtent(); - + protected: virtual bool RenderScene(CairoContext& context, const ViewportGeometry& view); @@ -87,12 +91,14 @@ void InvalidateLayer(size_t layer); public: - LayerWidget(); - virtual ~LayerWidget(); size_t AddLayer(ILayerSource* layer); // Takes ownership + void ReplaceLayer(size_t layerIndex, ILayerSource* layer); // Takes ownership + + void RemoveLayer(size_t layerIndex); + size_t GetLayerCount() const { return layers_.size();
--- a/Framework/Widgets/LayoutWidget.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/LayoutWidget.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -83,12 +83,10 @@ int top_; unsigned int width_; unsigned int height_; - bool hasUpdate_; public: ChildWidget(IWidget* widget) : - widget_(widget), - hasUpdate_(widget->HasUpdateContent()) + widget_(widget) { assert(widget != NULL); SetEmpty(); @@ -96,7 +94,7 @@ void UpdateContent() { - if (hasUpdate_) + if (widget_->HasUpdateContent()) { widget_->UpdateContent(); } @@ -266,11 +264,12 @@ } } - NotifyChange(*this); + NotifyContentChanged(*this); } - LayoutWidget::LayoutWidget() : + LayoutWidget::LayoutWidget(const std::string& name) : + WidgetBase(name), isHorizontal_(true), width_(0), height_(0), @@ -292,19 +291,19 @@ } - void LayoutWidget::SetDefaultView() + void LayoutWidget::FitContent() { for (size_t i = 0; i < children_.size(); i++) { - children_[i]->GetWidget().SetDefaultView(); + children_[i]->GetWidget().FitContent(); } } - void LayoutWidget::NotifyChange(const IWidget& widget) + void LayoutWidget::NotifyContentChanged(const IWidget& widget) { // One of the children has changed - WidgetBase::NotifyChange(); + WidgetBase::NotifyContentChanged(); } @@ -452,12 +451,13 @@ } - void LayoutWidget::KeyPressed(char key, + void LayoutWidget::KeyPressed(KeyboardKeys key, + char keyChar, KeyboardModifiers modifiers) { for (size_t i = 0; i < children_.size(); i++) { - children_[i]->GetWidget().KeyPressed(key, modifiers); + children_[i]->GetWidget().KeyPressed(key, keyChar, modifiers); } }
--- a/Framework/Widgets/LayoutWidget.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/LayoutWidget.h Mon Nov 05 10:05:33 2018 +0100 @@ -49,13 +49,13 @@ void ComputeChildrenExtents(); public: - LayoutWidget(); + LayoutWidget(const std::string& name); virtual ~LayoutWidget(); - virtual void SetDefaultView(); + virtual void FitContent(); - virtual void NotifyChange(const IWidget& widget); + virtual void NotifyContentChanged(const IWidget& widget); void SetHorizontal(); @@ -117,7 +117,8 @@ int y, KeyboardModifiers modifiers); - virtual void KeyPressed(char key, + virtual void KeyPressed(KeyboardKeys key, + char keyChar, KeyboardModifiers modifiers); virtual bool HasUpdateContent() const
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Widgets/PanMouseTracker.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,55 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#include "PanMouseTracker.h" + +#include <Core/Logging.h> + +namespace OrthancStone +{ + PanMouseTracker::PanMouseTracker(WorldSceneWidget& that, + int x, + int y) : + that_(that) + { + that.GetView().GetPan(originalPanX_, originalPanY_); + that.GetView().MapPixelCenterToScene(downX_, downY_, x, y); + } + + + void PanMouseTracker::Render(CairoContext& context, + double zoom) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + + void PanMouseTracker::MouseMove(int displayX, + int displayY, + double x, + double y) + { + ViewportGeometry view = that_.GetView(); + view.SetPan(originalPanX_ + (x - downX_) * view.GetZoom(), + originalPanY_ + (y - downY_) * view.GetZoom()); + that_.SetView(view); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Widgets/PanMouseTracker.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,59 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "WorldSceneWidget.h" + +namespace OrthancStone +{ + class PanMouseTracker : public IWorldSceneMouseTracker + { + private: + WorldSceneWidget& that_; + double originalPanX_; + double originalPanY_; + double downX_; + double downY_; + + public: + PanMouseTracker(WorldSceneWidget& that, + int x, + int y); + + virtual bool HasRender() const + { + return false; + } + + virtual void MouseUp() + { + } + + virtual void Render(CairoContext& context, + double zoom); + + virtual void MouseMove(int displayX, + int displayY, + double x, + double y); + }; +}
--- a/Framework/Widgets/TestCairoWidget.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/TestCairoWidget.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -36,7 +36,7 @@ value_ = 1; } - NotifyChange(); + NotifyContentChanged(); } @@ -77,7 +77,8 @@ } - TestCairoWidget::TestCairoWidget(bool animate) : + TestCairoWidget::TestCairoWidget(const std::string& name, bool animate) : + CairoWidget(name), width_(0), height_(0), value_(1), @@ -114,10 +115,11 @@ } - void TestCairoWidget::KeyPressed(char key, + void TestCairoWidget::KeyPressed(KeyboardKeys key, + char keyChar, KeyboardModifiers modifiers) { - UpdateStatusBar("Key pressed: \"" + std::string(1, key) + "\""); + UpdateStatusBar("Key pressed: \"" + std::string(1, keyChar) + "\""); } } }
--- a/Framework/Widgets/TestCairoWidget.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/TestCairoWidget.h Mon Nov 05 10:05:33 2018 +0100 @@ -43,7 +43,7 @@ int y); public: - TestCairoWidget(bool animate); + TestCairoWidget(const std::string& name, bool animate); virtual void SetSize(unsigned int width, unsigned int height); @@ -58,7 +58,8 @@ int y, KeyboardModifiers modifiers); - virtual void KeyPressed(char key, + virtual void KeyPressed(KeyboardKeys key, + char keyChar, KeyboardModifiers modifiers); virtual bool HasUpdateContent() const
--- a/Framework/Widgets/TestWorldSceneWidget.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/TestWorldSceneWidget.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -34,6 +34,9 @@ virtual IWorldSceneMouseTracker* CreateMouseTracker(WorldSceneWidget& widget, const ViewportGeometry& view, MouseButton button, + KeyboardModifiers modifiers, + int viewportX, + int viewportY, double x, double y, IStatusBar* statusBar) @@ -80,20 +83,21 @@ } virtual void KeyPressed(WorldSceneWidget& widget, - char key, + KeyboardKeys key, + char keyChar, KeyboardModifiers modifiers, IStatusBar* statusBar) { if (statusBar) { - statusBar->SetMessage("Key pressed: \"" + std::string(1, key) + "\""); + statusBar->SetMessage("Key pressed: \"" + std::string(1, keyChar) + "\""); } } }; bool TestWorldSceneWidget::RenderScene(CairoContext& context, - const ViewportGeometry& view) + const ViewportGeometry& view) { cairo_t* cr = context.GetObject(); @@ -110,7 +114,8 @@ } - TestWorldSceneWidget::TestWorldSceneWidget(bool animate) : + TestWorldSceneWidget::TestWorldSceneWidget(const std::string& name, bool animate) : + WorldSceneWidget(name), interactor_(new Interactor), animate_(animate), count_(0) @@ -130,7 +135,7 @@ if (animate_) { count_++; - NotifyChange(); + NotifyContentChanged(); } else {
--- a/Framework/Widgets/TestWorldSceneWidget.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/TestWorldSceneWidget.h Mon Nov 05 10:05:33 2018 +0100 @@ -43,7 +43,7 @@ const ViewportGeometry& view); public: - TestWorldSceneWidget(bool animate); + TestWorldSceneWidget(const std::string& name, bool animate); virtual Extent2D GetSceneExtent();
--- a/Framework/Widgets/WidgetBase.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/WidgetBase.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -27,16 +27,16 @@ namespace OrthancStone { - void WidgetBase::NotifyChange() + void WidgetBase::NotifyContentChanged() { if (parent_ != NULL) { - parent_->NotifyChange(); + parent_->NotifyContentChanged(); } if (viewport_ != NULL) { - viewport_->NotifyChange(*this); + viewport_->NotifyContentChanged(*this); } } @@ -101,12 +101,13 @@ } - WidgetBase::WidgetBase() : + WidgetBase::WidgetBase(const std::string& name) : parent_(NULL), viewport_(NULL), statusBar_(NULL), backgroundCleared_(false), - transmitMouseOver_(false) + transmitMouseOver_(false), + name_(name) { backgroundColor_[0] = 0; backgroundColor_[1] = 0;
--- a/Framework/Widgets/WidgetBase.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/WidgetBase.h Mon Nov 05 10:05:33 2018 +0100 @@ -36,6 +36,7 @@ bool backgroundCleared_; uint8_t backgroundColor_[3]; bool transmitMouseOver_; + std::string name_; protected: void ClearBackgroundOrthanc(Orthanc::ImageAccessor& target) const; @@ -52,9 +53,9 @@ } public: - WidgetBase(); + WidgetBase(const std::string& name); - virtual void SetDefaultView() + virtual void FitContent() { } @@ -104,6 +105,12 @@ return transmitMouseOver_; } - virtual void NotifyChange(); + virtual void NotifyContentChanged(); + + const std::string& GetName() const + { + return name_; + } + }; }
--- a/Framework/Widgets/WorldSceneWidget.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/WorldSceneWidget.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -21,195 +21,61 @@ #include "WorldSceneWidget.h" +#include "PanMouseTracker.h" +#include "ZoomMouseTracker.h" + +#include <Core/Logging.h> + #include <math.h> #include <memory> #include <cassert> namespace OrthancStone { - static void MapMouseToScene(double& sceneX, - double& sceneY, - const ViewportGeometry& view, - int mouseX, - int mouseY) - { - // Take the center of the pixel - double x, y; - x = static_cast<double>(mouseX) + 0.5; - y = static_cast<double>(mouseY) + 0.5; - - view.MapDisplayToScene(sceneX, sceneY, x, y); - } - - - struct WorldSceneWidget::SizeChangeFunctor - { - ViewportGeometry& view_; - - SizeChangeFunctor(ViewportGeometry& view) : - view_(view) - { - } - - void operator() (IWorldObserver& observer, - const WorldSceneWidget& source) - { - observer.NotifySizeChange(source, view_); - } - }; - - + // this is an adapter between a IWorldSceneMouseTracker + // that is tracking a mouse in scene coordinates/mm and + // an IMouseTracker that is tracking a mouse + // in screen coordinates/pixels. class WorldSceneWidget::SceneMouseTracker : public IMouseTracker { private: - ViewportGeometry view_; + ViewportGeometry view_; std::auto_ptr<IWorldSceneMouseTracker> tracker_; - + public: SceneMouseTracker(const ViewportGeometry& view, IWorldSceneMouseTracker* tracker) : view_(view), tracker_(tracker) { - assert(tracker != NULL); + if (tracker == NULL) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); + } } virtual void Render(Orthanc::ImageAccessor& target) { - CairoSurface surface(target); - CairoContext context(surface); - view_.ApplyTransform(context); - tracker_->Render(context, view_.GetZoom()); + if (tracker_->HasRender()) + { + CairoSurface surface(target); + CairoContext context(surface); + view_.ApplyTransform(context); + tracker_->Render(context, view_.GetZoom()); + } } - virtual void MouseUp() + virtual void MouseUp() { tracker_->MouseUp(); } - virtual void MouseMove(int x, + virtual void MouseMove(int x, int y) { double sceneX, sceneY; - MapMouseToScene(sceneX, sceneY, view_, x, y); - tracker_->MouseMove(sceneX, sceneY); - } - }; - - - class WorldSceneWidget::PanMouseTracker : public IMouseTracker - { - private: - WorldSceneWidget& that_; - double previousPanX_; - double previousPanY_; - double downX_; - double downY_; - - public: - PanMouseTracker(WorldSceneWidget& that, - int x, - int y) : - that_(that), - downX_(x), - downY_(y) - { - that_.view_.GetPan(previousPanX_, previousPanY_); - } - - virtual void Render(Orthanc::ImageAccessor& surface) - { - } - - virtual void MouseUp() - { - } - - virtual void MouseMove(int x, - int y) - { - that_.view_.SetPan(previousPanX_ + x - downX_, - previousPanY_ + y - downY_); - - that_.observers_.Apply(that_, &IWorldObserver::NotifyViewChange, that_.view_); - } - }; - - - class WorldSceneWidget::ZoomMouseTracker : public IMouseTracker - { - private: - WorldSceneWidget& that_; - int downX_; - int downY_; - double centerX_; - double centerY_; - double oldZoom_; - - public: - ZoomMouseTracker(WorldSceneWidget& that, - int x, - int y) : - that_(that), - downX_(x), - downY_(y) - { - oldZoom_ = that_.view_.GetZoom(); - MapMouseToScene(centerX_, centerY_, that_.view_, downX_, downY_); - } - - virtual void Render(Orthanc::ImageAccessor& surface) - { - } - - virtual void MouseUp() - { - } - - virtual void MouseMove(int x, - int y) - { - static const double MIN_ZOOM = -4; - static const double MAX_ZOOM = 4; - - if (that_.view_.GetDisplayHeight() <= 3) - { - return; // Cannot zoom on such a small image - } - - double dy = (static_cast<double>(y - downY_) / - static_cast<double>(that_.view_.GetDisplayHeight() - 1)); // In the range [-1,1] - double z; - - // Linear interpolation from [-1, 1] to [MIN_ZOOM, MAX_ZOOM] - if (dy < -1.0) - { - z = MIN_ZOOM; - } - else if (dy > 1.0) - { - z = MAX_ZOOM; - } - else - { - z = MIN_ZOOM + (MAX_ZOOM - MIN_ZOOM) * (dy + 1.0) / 2.0; - } - - z = pow(2.0, z); - - that_.view_.SetZoom(oldZoom_ * z); - - // Correct the pan so that the original click point is kept at - // the same location on the display - double panX, panY; - that_.view_.GetPan(panX, panY); - - int tx, ty; - that_.view_.MapSceneToDisplay(tx, ty, centerX_, centerY_); - that_.view_.SetPan(panX + static_cast<double>(downX_ - tx), - panY + static_cast<double>(downY_ - ty)); - - that_.observers_.Apply(that_, &IWorldObserver::NotifyViewChange, that_.view_); + view_.MapPixelCenterToScene(sceneX, sceneY, x, y); + tracker_->MouseMove(x, y, sceneX, sceneY); } }; @@ -229,8 +95,12 @@ view.ApplyTransform(context); double sceneX, sceneY; - MapMouseToScene(sceneX, sceneY, view, x, y); - RenderSceneMouseOver(context, view, sceneX, sceneY); + view.MapPixelCenterToScene(sceneX, sceneY, x, y); + + if (interactor_) + { + interactor_->MouseOver(context, *this, view, sceneX, sceneY, GetStatusBar()); + } } @@ -244,20 +114,7 @@ unsigned int height) { CairoWidget::SetSize(width, height); - view_.SetDisplaySize(width, height); - - if (observers_.IsEmpty()) - { - // Without a size observer, reset to the default view - // view_.SetDefaultView(); - } - else - { - // With a size observer, let it decide which view to use - SizeChangeFunctor functor(view_); - observers_.Notify(*this, functor); - } } @@ -267,14 +124,12 @@ } - void WorldSceneWidget::SetDefaultView() + void WorldSceneWidget::FitContent() { SetSceneExtent(view_); - view_.SetDefaultView(); + view_.FitContent(); - NotifyChange(); - - observers_.Apply(*this, &IWorldObserver::NotifyViewChange, view_); + NotifyContentChanged(); } @@ -282,15 +137,7 @@ { view_ = view; - NotifyChange(); - - observers_.Apply(*this, &IWorldObserver::NotifyViewChange, view_); - } - - - ViewportGeometry WorldSceneWidget::GetView() - { - return view_; + NotifyContentChanged(); } @@ -300,50 +147,33 @@ KeyboardModifiers modifiers) { double sceneX, sceneY; - MapMouseToScene(sceneX, sceneY, view_, x, y); + view_.MapPixelCenterToScene(sceneX, sceneY, x, y); + + // asks the Widget Interactor to provide a mouse tracker + std::auto_ptr<IWorldSceneMouseTracker> tracker; - std::auto_ptr<IWorldSceneMouseTracker> tracker - (CreateMouseSceneTracker(view_, button, sceneX, sceneY, modifiers)); - + if (interactor_) + { + tracker.reset(interactor_->CreateMouseTracker(*this, view_, button, modifiers, x, y, sceneX, sceneY, GetStatusBar())); + } + if (tracker.get() != NULL) { return new SceneMouseTracker(view_, tracker.release()); } - - switch (button) + else if (hasDefaultMouseEvents_) { - case MouseButton_Middle: - return new PanMouseTracker(*this, x, y); - - case MouseButton_Right: - return new ZoomMouseTracker(*this, x, y); - - default: - return NULL; - } - } - + switch (button) + { + case MouseButton_Middle: + return new SceneMouseTracker(view_, new PanMouseTracker(*this, x, y)); - void WorldSceneWidget::RenderSceneMouseOver(CairoContext& context, - const ViewportGeometry& view, - double x, - double y) - { - if (interactor_) - { - interactor_->MouseOver(context, *this, view, x, y, GetStatusBar()); - } - } + case MouseButton_Right: + return new SceneMouseTracker(view_, new ZoomMouseTracker(*this, x, y)); - IWorldSceneMouseTracker* WorldSceneWidget::CreateMouseSceneTracker(const ViewportGeometry& view, - MouseButton button, - double x, - double y, - KeyboardModifiers modifiers) - { - if (interactor_) - { - return interactor_->CreateMouseTracker(*this, view, button, x, y, GetStatusBar()); + default: + return NULL; + } } else { @@ -355,7 +185,7 @@ void WorldSceneWidget::MouseWheel(MouseWheelDirection direction, int x, int y, - KeyboardModifiers modifiers) + KeyboardModifiers modifiers) { if (interactor_) { @@ -364,12 +194,13 @@ } - void WorldSceneWidget::KeyPressed(char key, + void WorldSceneWidget::KeyPressed(KeyboardKeys key, + char keyChar, KeyboardModifiers modifiers) { if (interactor_) { - interactor_->KeyPressed(*this, key, modifiers, GetStatusBar()); + interactor_->KeyPressed(*this, key, keyChar, modifiers, GetStatusBar()); } } }
--- a/Framework/Widgets/WorldSceneWidget.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/Widgets/WorldSceneWidget.h Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -31,43 +31,23 @@ { class WorldSceneWidget : public CairoWidget { - public: - class IWorldObserver : public boost::noncopyable - { - public: - virtual ~IWorldObserver() - { - } - - virtual void NotifySizeChange(const WorldSceneWidget& source, - ViewportGeometry& view) = 0; // Can be tuned by the observer - - virtual void NotifyViewChange(const WorldSceneWidget& source, - const ViewportGeometry& view) = 0; - }; - private: - struct SizeChangeFunctor; - class SceneMouseTracker; - class PanMouseTracker; - class ZoomMouseTracker; - - typedef ObserversRegistry<WorldSceneWidget, IWorldObserver> Observers; ViewportGeometry view_; - Observers observers_; IWorldSceneInteractor* interactor_; + bool hasDefaultMouseEvents_; - public: + protected: virtual Extent2D GetSceneExtent() = 0; - protected: virtual bool RenderScene(CairoContext& context, const ViewportGeometry& view) = 0; + // From CairoWidget virtual bool RenderCairo(CairoContext& context); + // From CairoWidget virtual void RenderMouseOverCairo(CairoContext& context, int x, int y); @@ -75,54 +55,49 @@ void SetSceneExtent(ViewportGeometry& geometry); public: - WorldSceneWidget() : - interactor_(NULL) + WorldSceneWidget(const std::string& name) : + CairoWidget(name), + interactor_(NULL), + hasDefaultMouseEvents_(true) { } - void Register(IWorldObserver& observer) + void SetDefaultMouseEvents(bool value) { - observers_.Register(observer); + hasDefaultMouseEvents_ = value; } - void Unregister(IWorldObserver& observer) + bool HasDefaultMouseEvents() const { - observers_.Unregister(observer); + return hasDefaultMouseEvents_; + } + + void SetInteractor(IWorldSceneInteractor& interactor); + + void SetView(const ViewportGeometry& view); + + const ViewportGeometry& GetView() const + { + return view_; } virtual void SetSize(unsigned int width, unsigned int height); - void SetInteractor(IWorldSceneInteractor& interactor); - - virtual void SetDefaultView(); - - void SetView(const ViewportGeometry& view); - - ViewportGeometry GetView(); + virtual void FitContent(); virtual IMouseTracker* CreateMouseTracker(MouseButton button, int x, int y, KeyboardModifiers modifiers); - virtual void RenderSceneMouseOver(CairoContext& context, - const ViewportGeometry& view, - double x, - double y); - - virtual IWorldSceneMouseTracker* CreateMouseSceneTracker(const ViewportGeometry& view, - MouseButton button, - double x, - double y, - KeyboardModifiers modifiers); - virtual void MouseWheel(MouseWheelDirection direction, int x, int y, KeyboardModifiers modifiers); - virtual void KeyPressed(char key, + virtual void KeyPressed(KeyboardKeys key, + char keyChar, KeyboardModifiers modifiers); }; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Widgets/ZoomMouseTracker.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,107 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#include "ZoomMouseTracker.h" + +#include <Core/Logging.h> + +namespace OrthancStone +{ + ZoomMouseTracker::ZoomMouseTracker(WorldSceneWidget& that, + int x, + int y) : + that_(that), + originalZoom_(that.GetView().GetZoom()), + downX_(x), + downY_(y) + { + that.GetView().MapPixelCenterToScene(centerX_, centerY_, x, y); + + unsigned int height = that.GetView().GetDisplayHeight(); + + if (height <= 3) + { + idle_ = true; + LOG(WARNING) << "image is too small to zoom (current height = " << height << ")"; + } + else + { + idle_ = false; + normalization_ = 1.0 / static_cast<double>(height - 1); + } + } + + + void ZoomMouseTracker::Render(CairoContext& context, + double zoom) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + + void ZoomMouseTracker::MouseMove(int displayX, + int displayY, + double x, + double y) + { + static const double MIN_ZOOM = -4; + static const double MAX_ZOOM = 4; + + + if (!idle_) + { + double dy = static_cast<double>(displayY - downY_) * normalization_; // In the range [-1,1] + double z; + + // Linear interpolation from [-1, 1] to [MIN_ZOOM, MAX_ZOOM] + if (dy < -1.0) + { + z = MIN_ZOOM; + } + else if (dy > 1.0) + { + z = MAX_ZOOM; + } + else + { + z = MIN_ZOOM + (MAX_ZOOM - MIN_ZOOM) * (dy + 1.0) / 2.0; + } + + z = pow(2.0, z); + + ViewportGeometry view = that_.GetView(); + + view.SetZoom(z * originalZoom_); + + // Correct the pan so that the original click point is kept at + // the same location on the display + double panX, panY; + view.GetPan(panX, panY); + + int tx, ty; + view.MapSceneToDisplay(tx, ty, centerX_, centerY_); + view.SetPan(panX + static_cast<double>(downX_ - tx), + panY + static_cast<double>(downY_ - ty)); + + that_.SetView(view); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Widgets/ZoomMouseTracker.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,62 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "WorldSceneWidget.h" + +namespace OrthancStone +{ + class ZoomMouseTracker : public IWorldSceneMouseTracker + { + private: + WorldSceneWidget& that_; + double originalZoom_; + int downX_; + int downY_; + double centerX_; + double centerY_; + bool idle_; + double normalization_; + + public: + ZoomMouseTracker(WorldSceneWidget& that, + int x, + int y); + + virtual bool HasRender() const + { + return false; + } + + virtual void MouseUp() + { + } + + virtual void Render(CairoContext& context, + double zoom); + + virtual void MouseMove(int displayX, + int displayY, + double x, + double y); + }; +}
--- a/Framework/dev.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Framework/dev.h Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -41,10 +41,10 @@ namespace OrthancStone { // TODO: Handle errors while loading - class OrthancVolumeImage : - public SlicedVolumeBase, - private OrthancSlicesLoader::ICallback - { + class OrthancVolumeImage : + public SlicedVolumeBase, + public OrthancStone::IObserver + { private: OrthancSlicesLoader loader_; std::auto_ptr<ImageBuffer3D> image_; @@ -64,7 +64,7 @@ } - static bool IsCompatible(const Slice& a, + static bool IsCompatible(const Slice& a, const Slice& b) { if (!GeometryToolbox::IsParallel(a.GetGeometry().GetNormal(), @@ -98,15 +98,15 @@ } - static double GetDistance(const Slice& a, + static double GetDistance(const Slice& a, const Slice& b) { - return fabs(a.GetGeometry().ProjectAlongNormal(a.GetGeometry().GetOrigin()) - + return fabs(a.GetGeometry().ProjectAlongNormal(a.GetGeometry().GetOrigin()) - a.GetGeometry().ProjectAlongNormal(b.GetGeometry().GetOrigin())); } - virtual void NotifyGeometryReady(const OrthancSlicesLoader& loader) + void OnSliceGeometryReady(const OrthancSlicesLoader& loader) { if (loader.GetSliceCount() == 0) { @@ -151,15 +151,15 @@ unsigned int width = loader.GetSlice(0).GetWidth(); unsigned int height = loader.GetSlice(0).GetHeight(); Orthanc::PixelFormat format = loader.GetSlice(0).GetConverter().GetExpectedPixelFormat(); - LOG(INFO) << "Creating a volume image of size " << width << "x" << height + LOG(INFO) << "Creating a volume image of size " << width << "x" << height << "x" << loader.GetSliceCount() << " in " << Orthanc::EnumerationToString(format); image_.reset(new ImageBuffer3D(format, width, height, loader.GetSliceCount(), computeRange_)); image_->SetAxialGeometry(loader.GetSlice(0).GetGeometry()); - image_->SetVoxelDimensions(loader.GetSlice(0).GetPixelSpacingX(), + image_->SetVoxelDimensions(loader.GetSlice(0).GetPixelSpacingX(), loader.GetSlice(0).GetPixelSpacingY(), spacingZ); image_->Clear(); - + downloadStack_.reset(new DownloadStack(loader.GetSliceCount())); pendingSlices_ = loader.GetSliceCount(); @@ -173,24 +173,18 @@ SlicedVolumeBase::NotifyGeometryReady(); } - virtual void NotifyGeometryError(const OrthancSlicesLoader& loader) - { - LOG(ERROR) << "Unable to download a volume image"; - SlicedVolumeBase::NotifyGeometryError(); - } - - virtual void NotifySliceImageReady(const OrthancSlicesLoader& loader, - unsigned int sliceIndex, - const Slice& slice, - std::auto_ptr<Orthanc::ImageAccessor>& image, - SliceImageQuality quality) + virtual void OnSliceImageReady(const OrthancSlicesLoader& loader, + unsigned int sliceIndex, + const Slice& slice, + const boost::shared_ptr<Orthanc::ImageAccessor>& image, + SliceImageQuality quality) { { ImageBuffer3D::SliceWriter writer(*image_, VolumeProjection_Axial, sliceIndex); Orthanc::ImageProcessing::Copy(writer.GetAccessor(), *image); } - SlicedVolumeBase::NotifySliceChange(sliceIndex, slice); + SlicedVolumeBase::NotifySliceChange(sliceIndex, slice); if (pendingSlices_ == 1) { @@ -205,22 +199,47 @@ ScheduleSliceDownload(); } - virtual void NotifySliceImageError(const OrthancSlicesLoader& loader, - unsigned int sliceIndex, - const Slice& slice, - SliceImageQuality quality) + virtual void HandleMessage(const IObservable& from, const IMessage& message) { - LOG(ERROR) << "Cannot download slice " << sliceIndex << " in a volume image"; - ScheduleSliceDownload(); + switch (message.GetType()) + { + case MessageType_SliceLoader_GeometryReady: + OnSliceGeometryReady(dynamic_cast<const OrthancSlicesLoader&>(from)); + case MessageType_SliceLoader_GeometryError: + { + LOG(ERROR) << "Unable to download a volume image"; + SlicedVolumeBase::NotifyGeometryError(); + }; break; + case MessageType_SliceLoader_ImageReady: + { + const OrthancSlicesLoader::SliceImageReadyMessage& msg = dynamic_cast<const OrthancSlicesLoader::SliceImageReadyMessage&>(message); + OnSliceImageReady(dynamic_cast<const OrthancSlicesLoader&>(from), + msg.sliceIndex_, + msg.slice_, + msg.image_, + msg.effectiveQuality_); + }; break; + case MessageType_SliceLoader_ImageError: + { + const OrthancSlicesLoader::SliceImageErrorMessage& msg = dynamic_cast<const OrthancSlicesLoader::SliceImageErrorMessage&>(message); + LOG(ERROR) << "Cannot download slice " << msg.sliceIndex_ << " in a volume image"; + ScheduleSliceDownload(); + }; break; + default: + VLOG("unhandled message type" << message.GetType()); + } } public: - OrthancVolumeImage(IWebService& orthanc, - bool computeRange) : - loader_(*this, orthanc), + OrthancVolumeImage(MessageBroker& broker, + OrthancApiClient& orthanc, + bool computeRange) : + OrthancStone::IObserver(broker), + loader_(broker, orthanc), computeRange_(computeRange), pendingSlices_(0) { + // TODO: replace with new callables loader_.RegisterObserver(*this); } void ScheduleLoadSeries(const std::string& seriesId) @@ -352,7 +371,7 @@ axialThickness * axial.GetGeometry().GetNormal()); reference_ = CoordinateSystem3D(origin, - axial.GetGeometry().GetAxisX(), + axial.GetGeometry().GetAxisX(), -axial.GetGeometry().GetNormal()); } @@ -374,7 +393,7 @@ axialThickness * axial.GetGeometry().GetNormal()); reference_ = CoordinateSystem3D(origin, - axial.GetGeometry().GetAxisY(), + axial.GetGeometry().GetAxisY(), axial.GetGeometry().GetNormal()); } @@ -391,20 +410,20 @@ switch (projection) { - case VolumeProjection_Axial: - SetupAxial(volume); - break; + case VolumeProjection_Axial: + SetupAxial(volume); + break; - case VolumeProjection_Coronal: - SetupCoronal(volume); - break; + case VolumeProjection_Coronal: + SetupCoronal(volume); + break; - case VolumeProjection_Sagittal: - SetupSagittal(volume); - break; + case VolumeProjection_Sagittal: + SetupSagittal(volume); + break; - default: - throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); } } @@ -468,8 +487,8 @@ class VolumeImageSource : - public LayerSourceBase, - private ISlicedVolume::IObserver + public LayerSourceBase, + private ISlicedVolume::IObserver { private: OrthancVolumeImage& volume_; @@ -493,12 +512,12 @@ LayerSourceBase::NotifyGeometryReady(); } - + virtual void NotifyGeometryError(const ISlicedVolume& volume) { LayerSourceBase::NotifyGeometryError(); } - + virtual void NotifyContentChange(const ISlicedVolume& volume) { LayerSourceBase::NotifyContentChange(); @@ -527,17 +546,17 @@ switch (projection) { - case VolumeProjection_Axial: - return *axialGeometry_; + case VolumeProjection_Axial: + return *axialGeometry_; - case VolumeProjection_Sagittal: - return *sagittalGeometry_; + case VolumeProjection_Sagittal: + return *sagittalGeometry_; - case VolumeProjection_Coronal: - return *coronalGeometry_; + case VolumeProjection_Coronal: + return *coronalGeometry_; - default: - throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); } } @@ -576,7 +595,8 @@ public: - VolumeImageSource(OrthancVolumeImage& volume) : + VolumeImageSource(MessageBroker& broker, OrthancVolumeImage& volume) : + LayerSourceBase(broker), volume_(volume) { volume_.Register(*this); @@ -593,7 +613,7 @@ return false; } else - { + { // As the slices of the volumic image are arranged in a box, // we only consider one single reference slice (the one with index 0). std::auto_ptr<Slice> slice(GetProjectionGeometry(projection).GetSlice(0)); @@ -630,9 +650,9 @@ std::auto_ptr<Slice> slice(geometry.GetSlice(closest)); LayerSourceBase::NotifyLayerReady( - FrameRenderer::CreateRenderer(frame.release(), *slice, isFullQuality), - //new SliceOutlineRenderer(slice), - slice->GetGeometry(), false); + FrameRenderer::CreateRenderer(frame.release(), *slice, isFullQuality), + //new SliceOutlineRenderer(slice), + slice->GetGeometry(), false); return; } } @@ -645,8 +665,8 @@ class VolumeImageInteractor : - public IWorldSceneInteractor, - protected ISlicedVolume::IObserver + public IWorldSceneInteractor, + protected ISlicedVolume::IObserver { private: LayerWidget& widget_; @@ -664,14 +684,14 @@ slices_.reset(new VolumeImageGeometry(image, projection_)); SetSlice(slices_->GetSliceCount() / 2); - widget_.SetDefaultView(); + widget_.FitContent(); } } - + virtual void NotifyGeometryError(const ISlicedVolume& volume) { } - + virtual void NotifyContentChange(const ISlicedVolume& volume) { } @@ -711,38 +731,39 @@ IStatusBar* statusBar) { int scale = (modifiers & KeyboardModifiers_Control ? 10 : 1); - + switch (direction) { - case MouseWheelDirection_Up: - OffsetSlice(-scale); - break; + case MouseWheelDirection_Up: + OffsetSlice(-scale); + break; - case MouseWheelDirection_Down: - OffsetSlice(scale); - break; + case MouseWheelDirection_Down: + OffsetSlice(scale); + break; - default: - break; + default: + break; } } virtual void KeyPressed(WorldSceneWidget& widget, - char key, + KeyboardKeys key, + char keyChar, KeyboardModifiers modifiers, IStatusBar* statusBar) { - switch (key) + switch (keyChar) { - case 's': - widget.SetDefaultView(); - break; + case 's': + widget.FitContent(); + break; - default: - break; + default: + break; } } - + public: VolumeImageInteractor(OrthancVolumeImage& volume, LayerWidget& widget, @@ -787,13 +808,13 @@ slice = slices_->GetSliceCount() - 1; } - if (slice != static_cast<int>(slice_)) + if (slice != static_cast<int>(slice_)) { SetSlice(slice); - } + } } } - + void SetSlice(size_t slice) { if (slices_.get() != NULL) @@ -814,7 +835,8 @@ LayerWidget& otherPlane_; public: - SliceLocationSource(LayerWidget& otherPlane) : + SliceLocationSource(MessageBroker& broker, LayerWidget& otherPlane) : + LayerSourceBase(broker), otherPlane_(otherPlane) { NotifyGeometryReady(); @@ -835,7 +857,7 @@ const CoordinateSystem3D& slice = otherPlane_.GetSlice(); // Compute the line of intersection between the two slices - if (!GeometryToolbox::IntersectTwoPlanes(p, d, + if (!GeometryToolbox::IntersectTwoPlanes(p, d, slice.GetOrigin(), slice.GetNormal(), viewportSlice.GetOrigin(), viewportSlice.GetNormal())) { @@ -850,7 +872,7 @@ const Extent2D extent = otherPlane_.GetSceneExtent(); - if (GeometryToolbox::ClipLineToRectangle(x1, y1, x2, y2, + if (GeometryToolbox::ClipLineToRectangle(x1, y1, x2, y2, x1, y1, x2, y2, extent.GetX1(), extent.GetY1(), extent.GetX2(), extent.GetY2())) @@ -863,6 +885,6 @@ NotifyLayerReady(NULL, reference.GetGeometry(), false); } } - } + } }; }
--- a/Platforms/Generic/CMakeLists.txt Mon Nov 05 10:04:56 2018 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,98 +0,0 @@ -cmake_minimum_required(VERSION 2.8) -project(OrthancStone) - - -##################################################################### -## Configuration for Orthanc -##################################################################### - -include(../../Resources/CMake/Version.cmake) - -if (ORTHANC_STONE_VERSION STREQUAL "mainline") - set(ORTHANC_FRAMEWORK_VERSION "mainline") - set(ORTHANC_FRAMEWORK_DEFAULT_SOURCE "hg") -else() - set(ORTHANC_FRAMEWORK_VERSION "1.3.2") - set(ORTHANC_FRAMEWORK_DEFAULT_SOURCE "web") -endif() - -set(ORTHANC_FRAMEWORK_SOURCE "${ORTHANC_FRAMEWORK_DEFAULT_SOURCE}" CACHE STRING "Source of the Orthanc source code (can be \"hg\", \"archive\", \"web\" or \"path\")") -set(ORTHANC_FRAMEWORK_ARCHIVE "" CACHE STRING "Path to the Orthanc archive, if ORTHANC_FRAMEWORK_SOURCE is \"archive\"") -set(ORTHANC_FRAMEWORK_ROOT "" CACHE STRING "Path to the Orthanc source directory, if ORTHANC_FRAMEWORK_SOURCE is \"path\"") - - -##################################################################### -## Build a static library containing the Orthanc Stone framework -##################################################################### - -include(../../Resources/CMake/OrthancStoneParameters.cmake) - -LIST(APPEND ORTHANC_BOOST_COMPONENTS program_options) - -SET(ORTHANC_SANDBOXED OFF) -SET(ENABLE_CRYPTO_OPTIONS ON) -SET(ENABLE_GOOGLE_TEST ON) -SET(ENABLE_WEB_CLIENT ON) - -include(../../Resources/CMake/OrthancStoneConfiguration.cmake) - -add_library(OrthancStone STATIC - ${ORTHANC_STONE_SOURCES} - ) - - -##################################################################### -## Build all the sample applications -##################################################################### - -macro(BuildSample Target Sample) - add_executable(${Target} - ${ORTHANC_STONE_ROOT}/Applications/Samples/SampleMainSdl.cpp - ${APPLICATIONS_SOURCES} - ) - set_target_properties(${Target} PROPERTIES COMPILE_DEFINITIONS ORTHANC_STONE_SAMPLE=${Sample}) - target_link_libraries(${Target} OrthancStone) -endmacro() - - -# TODO - Re-enable all these samples! - -BuildSample(OrthancStoneEmpty 1) -BuildSample(OrthancStoneTestPattern 2) -BuildSample(OrthancStoneSingleFrame 3) -BuildSample(OrthancStoneSingleVolume 4) -#BuildSample(OrthancStoneBasicPetCtFusion 5) -#BuildSample(OrthancStoneSynchronizedSeries 6) -#BuildSample(OrthancStoneLayoutPetCtFusion 7) - - -##################################################################### -## Build the unit tests -##################################################################### - -add_executable(UnitTests - ${GOOGLE_TEST_SOURCES} - ${ORTHANC_STONE_ROOT}/UnitTestsSources/UnitTestsMain.cpp - ) - -target_link_libraries(UnitTests OrthancStone) - - -##################################################################### -## Generate the documentation if Doxygen is present -##################################################################### - -find_package(Doxygen) -if (DOXYGEN_FOUND) - configure_file( - ${ORTHANC_STONE_ROOT}/Resources/OrthancStone.doxygen - ${CMAKE_CURRENT_BINARY_DIR}/OrthancStone.doxygen - @ONLY) - - add_custom_target(doc - ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/OrthancStone.doxygen - COMMENT "Generating documentation with Doxygen" VERBATIM - ) -else() - message("Doxygen not found. The documentation will not be built.") -endif()
--- a/Platforms/Generic/Oracle.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Platforms/Generic/Oracle.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -27,6 +27,7 @@ #include <vector> #include <stdio.h> +#include <boost/thread/mutex.hpp> namespace OrthancStone { @@ -40,7 +41,6 @@ State_Stopped }; - boost::mutex* globalMutex_; boost::mutex oracleMutex_; State state_; std::vector<boost::thread*> threads_; @@ -66,28 +66,26 @@ if (item.get() != NULL) { IOracleCommand& command = dynamic_cast<IOracleCommand&>(*item); - command.Execute(); + try + { + command.Execute(); + } + catch (Orthanc::OrthancException& ex) + { + // this is probably a curl error that has been triggered. We may just ignore it. + // The command.success_ will stay at false and this will be handled in the command.Commit + } // Random sleeping to test //boost::this_thread::sleep(boost::posix_time::milliseconds(50 * (1 + rand() % 10))); - if (that->globalMutex_ != NULL) - { - boost::mutex::scoped_lock lock(*that->globalMutex_); - command.Commit(); - } - else - { - command.Commit(); - } + command.Commit(); } } } public: - PImpl(boost::mutex* globalMutex, - unsigned int threadCount) : - globalMutex_(globalMutex), + PImpl(unsigned int threadCount) : state_(State_Init), threads_(threadCount) { @@ -182,19 +180,11 @@ }; - Oracle::Oracle(boost::mutex& globalMutex, - unsigned int threadCount) : - pimpl_(new PImpl(&globalMutex, threadCount)) + Oracle::Oracle(unsigned int threadCount) : + pimpl_(new PImpl(threadCount)) { } - - Oracle::Oracle(unsigned int threadCount) : - pimpl_(new PImpl(NULL, threadCount)) - { - } - - void Oracle::Start() { pimpl_->Start();
--- a/Platforms/Generic/Oracle.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Platforms/Generic/Oracle.h Mon Nov 05 10:05:33 2018 +0100 @@ -24,7 +24,6 @@ #include "IOracleCommand.h" #include <boost/shared_ptr.hpp> -#include <boost/thread/mutex.hpp> namespace OrthancStone { @@ -36,9 +35,6 @@ boost::shared_ptr<PImpl> pimpl_; public: - Oracle(boost::mutex& globalMutex, - unsigned int threadCount); - Oracle(unsigned int threadCount); void Start();
--- a/Platforms/Generic/OracleWebService.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Platforms/Generic/OracleWebService.h Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -25,36 +25,73 @@ #include "Oracle.h" #include "WebServiceGetCommand.h" #include "WebServicePostCommand.h" +#include "WebServiceDeleteCommand.h" +#include "../../Applications/Generic/NativeStoneApplicationContext.h" namespace OrthancStone { + // The OracleWebService performs HTTP requests in a native environment. + // It uses a thread pool to handle multiple HTTP requests in a same time. + // It works asynchronously to mimick the behaviour of the WebService running in a WASM environment. class OracleWebService : public IWebService { private: Oracle& oracle_; + NativeStoneApplicationContext& context_; Orthanc::WebServiceParameters parameters_; public: - OracleWebService(Oracle& oracle, - const Orthanc::WebServiceParameters& parameters) : + OracleWebService(MessageBroker& broker, + Oracle& oracle, + const Orthanc::WebServiceParameters& parameters, + NativeStoneApplicationContext& context) : + IWebService(broker), oracle_(oracle), + context_(context), parameters_(parameters) { } - virtual void ScheduleGetRequest(ICallback& callback, - const std::string& uri, - Orthanc::IDynamicObject* payload) + virtual void GetAsync(const std::string& uri, + const Headers& headers, + Orthanc::IDynamicObject* payload, // takes ownership + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallback, // takes ownership + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback = NULL,// takes ownership + unsigned int timeoutInSeconds = 60) { - oracle_.Submit(new WebServiceGetCommand(callback, parameters_, uri, payload)); + oracle_.Submit(new WebServiceGetCommand(broker_, successCallback, failureCallback, parameters_, uri, headers, timeoutInSeconds, payload, context_)); } - virtual void SchedulePostRequest(ICallback& callback, - const std::string& uri, - const std::string& body, - Orthanc::IDynamicObject* payload) + virtual void PostAsync(const std::string& uri, + const Headers& headers, + const std::string& body, + Orthanc::IDynamicObject* payload, // takes ownership + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallback, // takes ownership + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback = NULL, // takes ownership + unsigned int timeoutInSeconds = 60) { - oracle_.Submit(new WebServicePostCommand(callback, parameters_, uri, body, payload)); + oracle_.Submit(new WebServicePostCommand(broker_, successCallback, failureCallback, parameters_, uri, headers, timeoutInSeconds, body, payload, context_)); + } + + virtual void DeleteAsync(const std::string& uri, + const Headers& headers, + Orthanc::IDynamicObject* payload, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallback, + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback = NULL, + unsigned int timeoutInSeconds = 60) + { + oracle_.Submit(new WebServiceDeleteCommand(broker_, successCallback, failureCallback, parameters_, uri, headers, timeoutInSeconds, payload, context_)); + } + + + void Start() + { + oracle_.Start(); + } + + void Stop() + { + oracle_.Stop(); } }; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Generic/WebServiceCommandBase.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,65 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#include "WebServiceCommandBase.h" + +#include <Core/HttpClient.h> + +namespace OrthancStone +{ + WebServiceCommandBase::WebServiceCommandBase(MessageBroker& broker, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallback, + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback, + const Orthanc::WebServiceParameters& parameters, + const std::string& uri, + const IWebService::Headers& headers, + unsigned int timeoutInSeconds, + Orthanc::IDynamicObject* payload /* takes ownership */, + NativeStoneApplicationContext& context) : + IObservable(broker), + successCallback_(successCallback), + failureCallback_(failureCallback), + parameters_(parameters), + uri_(uri), + headers_(headers), + payload_(payload), + context_(context), + timeoutInSeconds_(timeoutInSeconds) + { + } + + + void WebServiceCommandBase::Commit() + { + NativeStoneApplicationContext::GlobalMutexLocker lock(context_); // we want to make sure that, i.e, the UpdateThread is not triggered while we are updating the "model" with the result of a WebServiceCommand + + if (success_ && successCallback_.get() != NULL) + { + successCallback_->Apply(IWebService::HttpRequestSuccessMessage(uri_, answer_.c_str(), answer_.size(), payload_.release())); + } + else if (!success_ && failureCallback_.get() != NULL) + { + failureCallback_->Apply(IWebService::HttpRequestErrorMessage(uri_, payload_.release())); + } + + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Generic/WebServiceCommandBase.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,68 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "IOracleCommand.h" + +#include "../../Framework/Toolbox/IWebService.h" +#include "../../Framework/Messages/IObservable.h" +#include "../../Framework/Messages/ICallable.h" +#include "../../Applications/Generic/NativeStoneApplicationContext.h" + +#include <Core/WebServiceParameters.h> + +#include <memory> + +namespace OrthancStone +{ + class WebServiceCommandBase : public IOracleCommand, IObservable + { + protected: + std::auto_ptr<MessageHandler<IWebService::HttpRequestSuccessMessage> > successCallback_; + std::auto_ptr<MessageHandler<IWebService::HttpRequestErrorMessage> > failureCallback_; + Orthanc::WebServiceParameters parameters_; + std::string uri_; + std::map<std::string, std::string> headers_; + std::auto_ptr<Orthanc::IDynamicObject> payload_; + bool success_; + std::string answer_; + NativeStoneApplicationContext& context_; + unsigned int timeoutInSeconds_; + + public: + WebServiceCommandBase(MessageBroker& broker, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallback, // takes ownership + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback, // takes ownership + const Orthanc::WebServiceParameters& parameters, + const std::string& uri, + const std::map<std::string, std::string>& headers, + unsigned int timeoutInSeconds, + Orthanc::IDynamicObject* payload /* takes ownership */, + NativeStoneApplicationContext& context + ); + + virtual void Execute() = 0; + + virtual void Commit(); + }; + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Generic/WebServiceDeleteCommand.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,55 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#include "WebServiceDeleteCommand.h" + +#include <Core/HttpClient.h> + +namespace OrthancStone +{ + WebServiceDeleteCommand::WebServiceDeleteCommand(MessageBroker& broker, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallback, // takes ownership + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback, // takes ownership + const Orthanc::WebServiceParameters& parameters, + const std::string& uri, + const IWebService::Headers& headers, + unsigned int timeoutInSeconds, + Orthanc::IDynamicObject* payload /* takes ownership */, + NativeStoneApplicationContext& context) : + WebServiceCommandBase(broker, successCallback, failureCallback, parameters, uri, headers, timeoutInSeconds, payload, context) + { + } + + void WebServiceDeleteCommand::Execute() + { + Orthanc::HttpClient client(parameters_, uri_); + client.SetTimeout(timeoutInSeconds_); + client.SetMethod(Orthanc::HttpMethod_Delete); + + for (IWebService::Headers::const_iterator it = headers_.begin(); it != headers_.end(); it++ ) + { + client.AddHeader(it->first, it->second); + } + + success_ = client.Apply(answer_); + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Generic/WebServiceDeleteCommand.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,43 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#pragma once + +#include "WebServiceCommandBase.h" + +namespace OrthancStone +{ + class WebServiceDeleteCommand : public WebServiceCommandBase + { + public: + WebServiceDeleteCommand(MessageBroker& broker, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallback, // takes ownership + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback, // takes ownership + const Orthanc::WebServiceParameters& parameters, + const std::string& uri, + const IWebService::Headers& headers, + unsigned int timeoutInSeconds, + Orthanc::IDynamicObject* payload /* takes ownership */, + NativeStoneApplicationContext& context); + + virtual void Execute(); + }; +}
--- a/Platforms/Generic/WebServiceGetCommand.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Platforms/Generic/WebServiceGetCommand.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -25,14 +25,17 @@ namespace OrthancStone { - WebServiceGetCommand::WebServiceGetCommand(IWebService::ICallback& callback, + + WebServiceGetCommand::WebServiceGetCommand(MessageBroker& broker, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallback, // takes ownership + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback, // takes ownership const Orthanc::WebServiceParameters& parameters, const std::string& uri, - Orthanc::IDynamicObject* payload /* takes ownership */) : - callback_(callback), - parameters_(parameters), - uri_(uri), - payload_(payload) + const IWebService::Headers& headers, + unsigned int timeoutInSeconds, + Orthanc::IDynamicObject* payload /* takes ownership */, + NativeStoneApplicationContext& context) : + WebServiceCommandBase(broker, successCallback, failureCallback, parameters, uri, headers, timeoutInSeconds, payload, context) { } @@ -40,21 +43,15 @@ void WebServiceGetCommand::Execute() { Orthanc::HttpClient client(parameters_, uri_); - client.SetTimeout(60); + client.SetTimeout(timeoutInSeconds_); client.SetMethod(Orthanc::HttpMethod_Get); + + for (IWebService::Headers::const_iterator it = headers_.begin(); it != headers_.end(); it++ ) + { + client.AddHeader(it->first, it->second); + } + success_ = client.Apply(answer_); } - - void WebServiceGetCommand::Commit() - { - if (success_) - { - callback_.NotifySuccess(uri_, answer_.c_str(), answer_.size(), payload_.release()); - } - else - { - callback_.NotifyError(uri_, payload_.release()); - } - } }
--- a/Platforms/Generic/WebServiceGetCommand.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Platforms/Generic/WebServiceGetCommand.h Mon Nov 05 10:05:33 2018 +0100 @@ -13,7 +13,7 @@ * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Affero General Public License for more details. - * + * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. **/ @@ -21,34 +21,24 @@ #pragma once -#include "IOracleCommand.h" - -#include "../../Framework/Toolbox/IWebService.h" - -#include <Core/WebServiceParameters.h> - -#include <memory> +#include "WebServiceCommandBase.h" namespace OrthancStone { - class WebServiceGetCommand : public IOracleCommand + class WebServiceGetCommand : public WebServiceCommandBase { - private: - IWebService::ICallback& callback_; - Orthanc::WebServiceParameters parameters_; - std::string uri_; - std::auto_ptr<Orthanc::IDynamicObject> payload_; - bool success_; - std::string answer_; - public: - WebServiceGetCommand(IWebService::ICallback& callback, + WebServiceGetCommand(MessageBroker& broker, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallback, // takes ownership + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback, // takes ownership const Orthanc::WebServiceParameters& parameters, const std::string& uri, - Orthanc::IDynamicObject* payload /* takes ownership */); + const IWebService::Headers& headers, + unsigned int timeoutInSeconds, + Orthanc::IDynamicObject* payload /* takes ownership */, + NativeStoneApplicationContext& context); virtual void Execute(); + }; - virtual void Commit(); - }; }
--- a/Platforms/Generic/WebServicePostCommand.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/Platforms/Generic/WebServicePostCommand.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -25,37 +25,34 @@ namespace OrthancStone { - WebServicePostCommand::WebServicePostCommand(IWebService::ICallback& callback, + WebServicePostCommand::WebServicePostCommand(MessageBroker& broker, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallback, // takes ownership + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback, // takes ownership const Orthanc::WebServiceParameters& parameters, const std::string& uri, + const IWebService::Headers& headers, + unsigned int timeoutInSeconds, const std::string& body, - Orthanc::IDynamicObject* payload /* takes ownership */) : - callback_(callback), - parameters_(parameters), - uri_(uri), - body_(body), - payload_(payload) + Orthanc::IDynamicObject* payload /* takes ownership */, + NativeStoneApplicationContext& context) : + WebServiceCommandBase(broker, successCallback, failureCallback, parameters, uri, headers, timeoutInSeconds, payload, context), + body_(body) { } void WebServicePostCommand::Execute() { Orthanc::HttpClient client(parameters_, uri_); - client.SetTimeout(60); + client.SetTimeout(timeoutInSeconds_); client.SetMethod(Orthanc::HttpMethod_Post); client.GetBody().swap(body_); + + for (IWebService::Headers::const_iterator it = headers_.begin(); it != headers_.end(); it++ ) + { + client.AddHeader(it->first, it->second); + } + success_ = client.Apply(answer_); } - void WebServicePostCommand::Commit() - { - if (success_) - { - callback_.NotifySuccess(uri_, answer_.c_str(), answer_.size(), payload_.release()); - } - else - { - callback_.NotifyError(uri_, payload_.release()); - } - } }
--- a/Platforms/Generic/WebServicePostCommand.h Mon Nov 05 10:04:56 2018 +0100 +++ b/Platforms/Generic/WebServicePostCommand.h Mon Nov 05 10:05:33 2018 +0100 @@ -21,36 +21,27 @@ #pragma once -#include "IOracleCommand.h" - -#include "../../Framework/Toolbox/IWebService.h" - -#include <Core/WebServiceParameters.h> - -#include <memory> +#include "WebServiceCommandBase.h" namespace OrthancStone { - class WebServicePostCommand : public IOracleCommand + class WebServicePostCommand : public WebServiceCommandBase { - private: - IWebService::ICallback& callback_; - Orthanc::WebServiceParameters parameters_; - std::string uri_; + protected: std::string body_; - std::auto_ptr<Orthanc::IDynamicObject> payload_; - bool success_; - std::string answer_; public: - WebServicePostCommand(IWebService::ICallback& callback, + WebServicePostCommand(MessageBroker& broker, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallback, // takes ownership + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback, // takes ownership const Orthanc::WebServiceParameters& parameters, const std::string& uri, + const IWebService::Headers& headers, + unsigned int timeoutInSeconds, const std::string& body, - Orthanc::IDynamicObject* payload /* takes ownership */); + Orthanc::IDynamicObject* payload /* takes ownership */, + NativeStoneApplicationContext& context); virtual void Execute(); - - virtual void Commit(); }; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Wasm/Defaults.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,284 @@ +#include "Defaults.h" + +#include "WasmWebService.h" +#include <Framework/dev.h> +#include "Framework/Widgets/TestCairoWidget.h" +#include <Framework/Viewport/WidgetViewport.h> +#include <Framework/Widgets/LayerWidget.h> +#include <algorithm> +#include "Applications/Wasm/StartupParametersBuilder.h" +#include "Platforms/Wasm/WasmPlatformApplicationAdapter.h" + +static unsigned int width_ = 0; +static unsigned int height_ = 0; + +/**********************************/ + +static std::unique_ptr<OrthancStone::IStoneApplication> application; +static std::unique_ptr<OrthancStone::WasmPlatformApplicationAdapter> applicationWasmAdapter = NULL; +static std::unique_ptr<OrthancStone::StoneApplicationContext> context; +static OrthancStone::StartupParametersBuilder startupParametersBuilder; +static OrthancStone::MessageBroker broker; + +static OrthancStone::ViewportContentChangedObserver viewportContentChangedObserver_; +static OrthancStone::StatusBar statusBar_; + +static std::list<std::shared_ptr<OrthancStone::WidgetViewport>> viewports_; + +std::shared_ptr<OrthancStone::WidgetViewport> FindViewportSharedPtr(ViewportHandle viewport) { + for (const auto& v : viewports_) { + if (v.get() == viewport) { + return v; + } + } + assert(false); + return std::shared_ptr<OrthancStone::WidgetViewport>(); +} + +#ifdef __cplusplus +extern "C" { +#endif + + using namespace OrthancStone; + + // when WASM needs a C++ viewport + ViewportHandle EMSCRIPTEN_KEEPALIVE CreateCppViewport() { + + std::shared_ptr<OrthancStone::WidgetViewport> viewport(new OrthancStone::WidgetViewport); + printf("viewport %x\n", (int)viewport.get()); + + viewports_.push_back(viewport); + + printf("There are now %d viewports in C++\n", viewports_.size()); + + viewport->SetStatusBar(statusBar_); + viewport->Register(viewportContentChangedObserver_); + + return viewport.get(); + } + + // when WASM does not need a viewport anymore, it should release it + void EMSCRIPTEN_KEEPALIVE ReleaseCppViewport(ViewportHandle viewport) { + viewports_.remove_if([viewport](const std::shared_ptr<OrthancStone::WidgetViewport>& v) { return v.get() == viewport;}); + + printf("There are now %d viewports in C++\n", viewports_.size()); + } + + void EMSCRIPTEN_KEEPALIVE CreateWasmApplication(ViewportHandle viewport) { + + printf("CreateWasmApplication\n"); + + application.reset(CreateUserApplication(broker)); + applicationWasmAdapter.reset(CreateWasmApplicationAdapter(broker, application.get())); + WasmWebService::SetBroker(broker); + + startupParametersBuilder.Clear(); + } + + void EMSCRIPTEN_KEEPALIVE SetStartupParameter(const char* keyc, + const char* value) { + startupParametersBuilder.SetStartupParameter(keyc, value); + } + + void EMSCRIPTEN_KEEPALIVE StartWasmApplication() { + + printf("StartWasmApplication\n"); + + // recreate a command line from uri arguments and parse it + boost::program_options::variables_map parameters; + boost::program_options::options_description options; + application->DeclareStartupOptions(options); + startupParametersBuilder.GetStartupParameters(parameters, options); + + context.reset(new OrthancStone::StoneApplicationContext()); + context->SetWebService(OrthancStone::WasmWebService::GetInstance()); + application->Initialize(context.get(), statusBar_, parameters); + application->InitializeWasm(); + +// viewport->SetSize(width_, height_); + printf("StartWasmApplication - completed\n"); + } + + void EMSCRIPTEN_KEEPALIVE NotifyUpdateContent() + { + for (auto viewport : viewports_) { + // TODO Only launch the JavaScript timer if "HasUpdateContent()" + if (viewport->HasUpdateContent()) + { + viewport->UpdateContent(); + } + + } + + } + + + void EMSCRIPTEN_KEEPALIVE ViewportSetSize(ViewportHandle viewport, unsigned int width, unsigned int height) + { + width_ = width; + height_ = height; + + viewport->SetSize(width, height); + } + + int EMSCRIPTEN_KEEPALIVE ViewportRender(ViewportHandle viewport, + unsigned int width, + unsigned int height, + uint8_t* data) + { + viewportContentChangedObserver_.Reset(); + + //printf("ViewportRender called %dx%d\n", width, height); + if (width == 0 || + height == 0) + { + return 1; + } + + Orthanc::ImageAccessor surface; + surface.AssignWritable(Orthanc::PixelFormat_BGRA32, width, height, 4 * width, data); + + viewport->Render(surface); + + // Convert from BGRA32 memory layout (only color mode supported by + // Cairo, which corresponds to CAIRO_FORMAT_ARGB32) to RGBA32 (as + // expected by HTML5 canvas). This simply amounts to swapping the + // B and R channels. + uint8_t* p = data; + for (unsigned int y = 0; y < height; y++) { + for (unsigned int x = 0; x < width; x++) { + uint8_t tmp = p[0]; + p[0] = p[2]; + p[2] = tmp; + + p += 4; + } + } + + return 1; + } + + + void EMSCRIPTEN_KEEPALIVE ViewportMouseDown(ViewportHandle viewport, + unsigned int rawButton, + int x, + int y, + unsigned int rawModifiers) + { + OrthancStone::MouseButton button; + switch (rawButton) + { + case 0: + button = OrthancStone::MouseButton_Left; + break; + + case 1: + button = OrthancStone::MouseButton_Middle; + break; + + case 2: + button = OrthancStone::MouseButton_Right; + break; + + default: + return; // Unknown button + } + + viewport->MouseDown(button, x, y, OrthancStone::KeyboardModifiers_None /* TODO */); + } + + + void EMSCRIPTEN_KEEPALIVE ViewportMouseWheel(ViewportHandle viewport, + int deltaY, + int x, + int y, + int isControl) + { + if (deltaY != 0) + { + OrthancStone::MouseWheelDirection direction = (deltaY < 0 ? + OrthancStone::MouseWheelDirection_Up : + OrthancStone::MouseWheelDirection_Down); + OrthancStone::KeyboardModifiers modifiers = OrthancStone::KeyboardModifiers_None; + + if (isControl != 0) + { + modifiers = OrthancStone::KeyboardModifiers_Control; + } + + viewport->MouseWheel(direction, x, y, modifiers); + } + } + + + void EMSCRIPTEN_KEEPALIVE ViewportMouseMove(ViewportHandle viewport, + int x, + int y) + { + viewport->MouseMove(x, y); + } + + void EMSCRIPTEN_KEEPALIVE ViewportKeyPressed(ViewportHandle viewport, + int key, + const char* keyChar, + bool isShiftPressed, + bool isControlPressed, + bool isAltPressed) + + { + OrthancStone::KeyboardModifiers modifiers = OrthancStone::KeyboardModifiers_None; + if (isShiftPressed) { + modifiers = static_cast<OrthancStone::KeyboardModifiers>(modifiers + OrthancStone::KeyboardModifiers_Shift); + } + if (isControlPressed) { + modifiers = static_cast<OrthancStone::KeyboardModifiers>(modifiers + OrthancStone::KeyboardModifiers_Control); + } + if (isAltPressed) { + modifiers = static_cast<OrthancStone::KeyboardModifiers>(modifiers + OrthancStone::KeyboardModifiers_Alt); + } + + char c = 0; + if (keyChar != NULL && key == OrthancStone::KeyboardKeys_Generic) { + c = keyChar[0]; + } + viewport->KeyPressed(static_cast<OrthancStone::KeyboardKeys>(key), c, modifiers); + } + + + void EMSCRIPTEN_KEEPALIVE ViewportMouseUp(ViewportHandle viewport) + { + viewport->MouseUp(); + } + + + void EMSCRIPTEN_KEEPALIVE ViewportMouseEnter(ViewportHandle viewport) + { + viewport->MouseEnter(); + } + + + void EMSCRIPTEN_KEEPALIVE ViewportMouseLeave(ViewportHandle viewport) + { + viewport->MouseLeave(); + } + + const char* EMSCRIPTEN_KEEPALIVE SendMessageToStoneApplication(const char* message) + { + static std::string output; // we don't want the string to be deallocated when we return to JS code so we always use the same string (this is fine since JS is single-thread) + + printf("SendMessageToStoneApplication\n"); + printf("%s", message); + + if (applicationWasmAdapter.get() != NULL) { + printf("sending message to C++\n"); + applicationWasmAdapter->HandleMessageFromWeb(output, std::string(message)); + return output.c_str(); + } + printf("This stone application does not have a Web Adapter"); + return NULL; + } + + +#ifdef __cplusplus +} +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Wasm/Defaults.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,79 @@ +#pragma once + +#include <emscripten/emscripten.h> + +#include <Framework/dev.h> +#include <Framework/Viewport/WidgetViewport.h> +#include <Framework/Widgets/LayerWidget.h> +#include <Framework/Widgets/LayoutWidget.h> +#include <Applications/IStoneApplication.h> +#include <Platforms/Wasm/WasmPlatformApplicationAdapter.h> + +typedef OrthancStone::WidgetViewport* ViewportHandle; // the objects exchanged between JS and C++ + +#ifdef __cplusplus +extern "C" { +#endif + + // JS methods accessible from C++ + extern void ScheduleWebViewportRedrawFromCpp(ViewportHandle cppViewportHandle); + extern void UpdateStoneApplicationStatusFromCpp(const char* statusUpdateMessage); + + // C++ methods accessible from JS + extern void EMSCRIPTEN_KEEPALIVE CreateWasmApplication(ViewportHandle cppViewportHandle); + extern void EMSCRIPTEN_KEEPALIVE SetStartupParameter(const char* keyc, const char* value); + + +#ifdef __cplusplus +} +#endif + +// these methods must be implemented in the custom app "mainWasm.cpp" +extern OrthancStone::IStoneApplication* CreateUserApplication(OrthancStone::MessageBroker& broker); +extern OrthancStone::WasmPlatformApplicationAdapter* CreateWasmApplicationAdapter(OrthancStone::MessageBroker& broker, OrthancStone::IStoneApplication* application); + +namespace OrthancStone { + + // default Observer to trigger Viewport redraw when something changes in the Viewport + class ViewportContentChangedObserver : + public OrthancStone::IViewport::IObserver + { + private: + // Flag to avoid flooding JavaScript with redundant Redraw requests + bool isScheduled_; + + public: + ViewportContentChangedObserver() : + isScheduled_(false) + { + } + + void Reset() + { + isScheduled_ = false; + } + + virtual void OnViewportContentChanged(const OrthancStone::IViewport &viewport) + { + if (!isScheduled_) + { + ScheduleWebViewportRedrawFromCpp((ViewportHandle)&viewport); // loosing constness when transmitted to Web + isScheduled_ = true; + } + } + }; + + // default status bar to log messages on the console/stdout + class StatusBar : public OrthancStone::IStatusBar + { + public: + virtual void ClearMessage() + { + } + + virtual void SetMessage(const std::string& message) + { + printf("%s\n", message.c_str()); + } + }; +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Wasm/WasmPlatformApplicationAdapter.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,51 @@ +#include "WasmPlatformApplicationAdapter.h" + +#include "Framework/Toolbox/MessagingToolbox.h" +#include "Framework/StoneException.h" +#include <Applications/Commands/BaseCommandBuilder.h> +#include <stdio.h> +#include "Platforms/Wasm/Defaults.h" + +namespace OrthancStone +{ + WasmPlatformApplicationAdapter::WasmPlatformApplicationAdapter(MessageBroker& broker, IStoneApplication& application) + : IObserver(broker), + application_(application) + { + } + + void WasmPlatformApplicationAdapter::HandleMessageFromWeb(std::string& output, const std::string& input) + { + try + { + Json::Value inputJson; + // if the message is a command, build it and execute it + if (MessagingToolbox::ParseJson(inputJson, input.c_str(), input.size())) + { + std::unique_ptr<ICommand> command(application_.GetCommandBuilder().CreateFromJson(inputJson)); + if (command.get() == NULL) + printf("Could not parse command: '%s'\n", input.c_str()); + else + application_.ExecuteCommand(*command); + } + } + catch (StoneException& exc) + { + printf("Error while handling message from web (error code = %d):\n", exc.GetErrorCode()); + printf("While interpreting input: '%s'\n", input.c_str()); + } + } + + void WasmPlatformApplicationAdapter::NotifyStatusUpdateFromCppToWeb(const std::string& statusUpdateMessage) + { + try + { + UpdateStoneApplicationStatusFromCpp(statusUpdateMessage.c_str()); + } + catch (...) + { + printf("Error while handling message to web\n"); + } + } + +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Wasm/WasmPlatformApplicationAdapter.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,18 @@ +#pragma once + +#include <string> +#include <Framework/Messages/IObserver.h> +#include <Applications/IStoneApplication.h> + +namespace OrthancStone +{ + class WasmPlatformApplicationAdapter : public IObserver + { + IStoneApplication& application_; + public: + WasmPlatformApplicationAdapter(MessageBroker& broker, IStoneApplication& application); + + virtual void HandleMessageFromWeb(std::string& output, const std::string& input); + virtual void NotifyStatusUpdateFromCppToWeb(const std::string& statusUpdateMessage); + }; +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Wasm/WasmViewport.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,13 @@ +#include "WasmViewport.h" + +#include <vector> +#include <memory> + +std::vector<std::shared_ptr<OrthancStone::WidgetViewport>> wasmViewports; + +void AttachWidgetToWasmViewport(const char* htmlCanvasId, OrthancStone::IWidget* centralWidget) { + std::shared_ptr<OrthancStone::WidgetViewport> viewport(CreateWasmViewportFromCpp(htmlCanvasId)); + viewport->SetCentralWidget(centralWidget); + + wasmViewports.push_back(viewport); +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Wasm/WasmViewport.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,18 @@ +#pragma once + +#include <Framework/Viewport/WidgetViewport.h> + +#include <emscripten/emscripten.h> + +#ifdef __cplusplus +extern "C" { +#endif + + // JS methods accessible from C++ + extern OrthancStone::WidgetViewport* CreateWasmViewportFromCpp(const char* htmlCanvasId); + +#ifdef __cplusplus +} +#endif + +extern void AttachWidgetToWasmViewport(const char* htmlCanvasId, OrthancStone::IWidget* centralWidget);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Wasm/WasmWebService.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,152 @@ +#include "WasmWebService.h" +#include "json/value.h" +#include "json/writer.h" +#include <emscripten/emscripten.h> + +#ifdef __cplusplus +extern "C" { +#endif + + extern void WasmWebService_GetAsync(void* callableSuccess, + void* callableFailure, + const char* uri, + const char* headersInJsonString, + void* payload, + unsigned int timeoutInSeconds); + + extern void WasmWebService_PostAsync(void* callableSuccess, + void* callableFailure, + const char* uri, + const char* headersInJsonString, + const void* body, + size_t bodySize, + void* payload, + unsigned int timeoutInSeconds); + + extern void WasmWebService_DeleteAsync(void* callableSuccess, + void* callableFailure, + const char* uri, + const char* headersInJsonString, + void* payload, + unsigned int timeoutInSeconds); + + void EMSCRIPTEN_KEEPALIVE WasmWebService_NotifyError(void* failureCallable, + const char* uri, + void* payload) + { + if (failureCallable == NULL) + { + throw; + } + else + { + reinterpret_cast<OrthancStone::MessageHandler<OrthancStone::IWebService::HttpRequestErrorMessage>*>(failureCallable)-> + Apply(OrthancStone::IWebService::HttpRequestErrorMessage(uri, reinterpret_cast<Orthanc::IDynamicObject*>(payload))); + } + } + + void EMSCRIPTEN_KEEPALIVE WasmWebService_NotifySuccess(void* successCallable, + const char* uri, + const void* body, + size_t bodySize, + void* payload) + { + if (successCallable == NULL) + { + throw; + } + else + { + reinterpret_cast<OrthancStone::MessageHandler<OrthancStone::IWebService::HttpRequestSuccessMessage>*>(successCallable)-> + Apply(OrthancStone::IWebService::HttpRequestSuccessMessage(uri, body, bodySize, reinterpret_cast<Orthanc::IDynamicObject*>(payload))); + } + } + + void EMSCRIPTEN_KEEPALIVE WasmWebService_SetBaseUri(const char* baseUri) + { + OrthancStone::WasmWebService::GetInstance().SetBaseUri(baseUri); + } + +#ifdef __cplusplus +} +#endif + + + +namespace OrthancStone +{ + MessageBroker* WasmWebService::broker_ = NULL; + + void WasmWebService::SetBaseUri(const std::string baseUri) + { + // Make sure the base url ends with "/" + if (baseUri.empty() || + baseUri[baseUri.size() - 1] != '/') + { + baseUri_ = baseUri + "/"; + } + else + { + baseUri_ = baseUri; + } + } + + void ToJsonString(std::string& output, const IWebService::Headers& headers) + { + Json::Value jsonHeaders; + for (IWebService::Headers::const_iterator it = headers.begin(); it != headers.end(); it++ ) + { + jsonHeaders[it->first] = it->second; + } + + Json::StreamWriterBuilder builder; + std::unique_ptr<Json::StreamWriter> writer(builder.newStreamWriter()); + std::ostringstream outputStr; + + writer->write(jsonHeaders, &outputStr); + output = outputStr.str(); + } + + void WasmWebService::PostAsync(const std::string& relativeUri, + const Headers& headers, + const std::string& body, + Orthanc::IDynamicObject* payload, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallable, + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallable, + unsigned int timeoutInSeconds) + { + std::string uri = baseUri_ + relativeUri; + std::string headersInJsonString; + ToJsonString(headersInJsonString, headers); + WasmWebService_PostAsync(successCallable, failureCallable, uri.c_str(), headersInJsonString.c_str(), + body.c_str(), body.size(), payload, timeoutInSeconds); + } + + void WasmWebService::DeleteAsync(const std::string& relativeUri, + const Headers& headers, + Orthanc::IDynamicObject* payload, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallable, + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallable, + unsigned int timeoutInSeconds) + { + std::string uri = baseUri_ + relativeUri; + std::string headersInJsonString; + ToJsonString(headersInJsonString, headers); + WasmWebService_DeleteAsync(successCallable, failureCallable, uri.c_str(), headersInJsonString.c_str(), + payload, timeoutInSeconds); + } + + void WasmWebService::GetAsync(const std::string& relativeUri, + const Headers& headers, + Orthanc::IDynamicObject* payload, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallable, + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallable, + unsigned int timeoutInSeconds) + { + std::string uri = baseUri_ + relativeUri; + std::string headersInJsonString; + ToJsonString(headersInJsonString, headers); + WasmWebService_GetAsync(successCallable, failureCallable, uri.c_str(), headersInJsonString.c_str(), payload, timeoutInSeconds); + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Wasm/WasmWebService.h Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,70 @@ +#pragma once + +#include <Framework/Toolbox/IWebService.h> +#include <Core/OrthancException.h> + +namespace OrthancStone +{ + class WasmWebService : public IWebService + { + private: + std::string baseUri_; + static MessageBroker* broker_; + + // Private constructor => Singleton design pattern + WasmWebService(MessageBroker& broker) : + IWebService(broker), + baseUri_("../../") // note: this is configurable from the JS code by calling WasmWebService_SetBaseUri + { + } + + public: + static WasmWebService& GetInstance() + { + if (broker_ == NULL) + { + printf("WasmWebService::GetInstance(): broker not initialized\n"); + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); + } + static WasmWebService instance(*broker_); + return instance; + } + + static void SetBroker(MessageBroker& broker) + { + broker_ = &broker; + } + + void SetBaseUri(const std::string baseUri); + + virtual void GetAsync(const std::string& uri, + const Headers& headers, + Orthanc::IDynamicObject* payload, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallable, + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallable = NULL, + unsigned int timeoutInSeconds = 60); + + virtual void PostAsync(const std::string& uri, + const Headers& headers, + const std::string& body, + Orthanc::IDynamicObject* payload, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallable, + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallable = NULL, + unsigned int timeoutInSeconds = 60); + + virtual void DeleteAsync(const std::string& uri, + const Headers& headers, + Orthanc::IDynamicObject* payload, + MessageHandler<IWebService::HttpRequestSuccessMessage>* successCallable, + MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallable = NULL, + unsigned int timeoutInSeconds = 60); + + virtual void Start() + { + } + + virtual void Stop() + { + } + }; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Wasm/WasmWebService.js Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,90 @@ +mergeInto(LibraryManager.library, { + WasmWebService_GetAsync: function(callableSuccess, callableFailure, url, headersInJsonString, payload, timeoutInSeconds) { + // Directly use XMLHttpRequest (no jQuery) to retrieve the raw binary data + // http://www.henryalgus.com/reading-binary-files-using-jquery-ajax/ + var xhr = new XMLHttpRequest(); + var url_ = UTF8ToString(url); + var headersInJsonString_ = UTF8ToString(headersInJsonString); + + xhr.open('GET', url_, true); + xhr.responseType = 'arraybuffer'; + xhr.timeout = timeoutInSeconds * 1000; + var headers = JSON.parse(headersInJsonString_); + for (var key in headers) { + xhr.setRequestHeader(key, headers[key]); + } + //console.log(xhr); + xhr.onreadystatechange = function() { + if (this.readyState == XMLHttpRequest.DONE) { + if (xhr.status === 200) { + // TODO - Is "new Uint8Array()" necessary? This copies the + // answer to the WebAssembly stack, hence necessitating + // increasing the TOTAL_STACK parameter of Emscripten + WasmWebService_NotifySuccess(callableSuccess, url_, new Uint8Array(this.response), + this.response.byteLength, payload); + } else { + WasmWebService_NotifyError(callableFailure, url_, payload); + } + } + } + + xhr.send(); + }, + + WasmWebService_PostAsync: function(callableSuccess, callableFailure, url, headersInJsonString, body, bodySize, payload, timeoutInSeconds) { + var xhr = new XMLHttpRequest(); + var url_ = UTF8ToString(url); + var headersInJsonString_ = UTF8ToString(headersInJsonString); + xhr.open('POST', url_, true); + xhr.timeout = timeoutInSeconds * 1000; + xhr.responseType = 'arraybuffer'; + xhr.setRequestHeader('Content-type', 'application/octet-stream'); + + var headers = JSON.parse(headersInJsonString_); + for (var key in headers) { + xhr.setRequestHeader(key, headers[key]); + } + + xhr.onreadystatechange = function() { + if (this.readyState == XMLHttpRequest.DONE) { + if (xhr.status === 200) { + WasmWebService_NotifySuccess(callableSuccess, url_, new Uint8Array(this.response), + this.response.byteLength, payload); + } else { + WasmWebService_NotifyError(callableFailure, url_, payload); + } + } + } + + xhr.send(new Uint8ClampedArray(HEAPU8.buffer, body, bodySize)); + }, + + WasmWebService_DeleteAsync: function(callableSuccess, callableFailure, url, headersInJsonString, payload, timeoutInSeconds) { + var xhr = new XMLHttpRequest(); + var url_ = UTF8ToString(url); + var headersInJsonString_ = UTF8ToString(headersInJsonString); + xhr.open('DELETE', url_, true); + xhr.timeout = timeoutInSeconds * 1000; + xhr.responseType = 'arraybuffer'; + xhr.setRequestHeader('Content-type', 'application/octet-stream'); + + var headers = JSON.parse(headersInJsonString_); + for (var key in headers) { + xhr.setRequestHeader(key, headers[key]); + } + + xhr.onreadystatechange = function() { + if (this.readyState == XMLHttpRequest.DONE) { + if (xhr.status === 200) { + WasmWebService_NotifySuccess(callableSuccess, url_, new Uint8Array(this.response), + this.response.byteLength, payload); + } else { + WasmWebService_NotifyError(callableFailure, url_, payload); + } + } + } + + xhr.send(); + } + +});
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Wasm/default-library.js Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,16 @@ +// this file contains the JS method you want to expose to C++ code + +mergeInto(LibraryManager.library, { + ScheduleWebViewportRedrawFromCpp: function(cppViewportHandle) { + ScheduleWebViewportRedraw(cppViewportHandle); + }, + CreateWasmViewportFromCpp: function(htmlCanvasId) { + return CreateWasmViewport(htmlCanvasId); + }, + // each time the StoneApplication updates its status, it may signal it through this method. i.e, to change the status of a button in the web interface + UpdateStoneApplicationStatusFromCpp: function(statusUpdateMessage) { + var statusUpdateMessage_ = UTF8ToString(statusUpdateMessage); + UpdateWebApplication(statusUpdateMessage_); + } +}); + \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Wasm/stone-framework-loader.ts Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,96 @@ +module Stone { + /** + * This file contains primitives to interface with WebAssembly and + * with the Stone framework. + **/ + + export declare type InitializationCallback = () => void; + + export declare var StoneFrameworkModule : any; + + //const ASSETS_FOLDER : string = "assets/lib"; + //const WASM_FILENAME : string = "orthanc-framework"; + + + export class Framework + { + private static singleton_ : Framework = null; + private static wasmModuleName_ : string = null; + + public static Configure(wasmModuleName: string) { + this.wasmModuleName_ = wasmModuleName; + } + + private constructor(verbose : boolean) + { + //this.ccall('Initialize', null, [ 'number' ], [ verbose ]); + } + + + public ccall(name: string, + returnType: string, + argTypes: Array<string>, + argValues: Array<any>) : any + { + return StoneFrameworkModule.ccall(name, returnType, argTypes, argValues); + } + + + public cwrap(name: string, + returnType: string, + argTypes: Array<string>) : any + { + return StoneFrameworkModule.cwrap(name, returnType, argTypes); + } + + + public static GetInstance() : Framework + { + if (Framework.singleton_ == null) { + throw new Error('The WebAssembly module is not loaded yet'); + } else { + return Framework.singleton_; + } + } + + + public static Initialize(verbose: boolean, + callback: InitializationCallback) + { + console.log('Initializing WebAssembly Module'); + + (<any> window).StoneFrameworkModule = { + preRun: [ + function() { + console.log('Loading the Stone Framework using WebAssembly'); + } + ], + postRun: [ + function() { + // This function is called by ".js" wrapper once the ".wasm" + // WebAssembly module has been loaded and compiled by the + // browser + console.log('WebAssembly is ready'); + Framework.singleton_ = new Framework(verbose); + callback(); + } + ], + print: function(text : string) { + console.log(text); + }, + printErr: function(text : string) { + console.error(text); + }, + totalDependencies: 0 + }; + + // Dynamic loading of the JavaScript wrapper around WebAssembly + var script = document.createElement('script'); + script.type = 'application/javascript'; + //script.src = "orthanc-stone.js"; // ASSETS_FOLDER + '/' + WASM_FILENAME + '.js'; + script.src = this.wasmModuleName_ + ".js";// "OrthancStoneSimpleViewer.js"; // ASSETS_FOLDER + '/' + WASM_FILENAME + '.js'; + script.async = true; + document.head.appendChild(script); + } + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Wasm/tsconfig-stone.json Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,7 @@ +{ + "include" : [ + "stone-framework-loader.ts", + "wasm-application-runner.ts", + "wasm-viewport.ts" + ] +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Wasm/wasm-application-runner.ts Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,113 @@ +///<reference path='stone-framework-loader.ts'/> +///<reference path='wasm-viewport.ts'/> + +if (!('WebAssembly' in window)) { + alert('Sorry, your browser does not support WebAssembly :('); +} + +declare var StoneFrameworkModule : Stone.Framework; + +// global functions +var WasmWebService_NotifyError: Function = null; +var WasmWebService_NotifySuccess: Function = null; +var WasmWebService_SetBaseUri: Function = null; +var NotifyUpdateContent: Function = null; +var SetStartupParameter: Function = null; +var CreateWasmApplication: Function = null; +var CreateCppViewport: Function = null; +var ReleaseCppViewport: Function = null; +var StartWasmApplication: Function = null; +var SendMessageToStoneApplication: Function = null; + + +function UpdateContentThread() { + if (NotifyUpdateContent != null) { + NotifyUpdateContent(); + } + + setTimeout(UpdateContentThread, 100); // Update the viewport content every 100ms if need be +} + + +function GetUriParameters(): Map<string, string> { + var parameters = window.location.search.substr(1); + + if (parameters != null && + parameters != '') { + var result = new Map<string, string>(); + var tokens = parameters.split('&'); + + for (var i = 0; i < tokens.length; i++) { + var tmp = tokens[i].split('='); + if (tmp.length == 2) { + result[tmp[0]] = decodeURIComponent(tmp[1]); + } + } + + return result; + } + else { + return new Map<string, string>(); + } +} + +// function UpdateWebApplication(statusUpdateMessage: string) { +// console.log(statusUpdateMessage); +// } + +function _InitializeWasmApplication(orthancBaseUrl: string): void { + + CreateWasmApplication(); + WasmWebService_SetBaseUri(orthancBaseUrl); + + + // parse uri and transmit the parameters to the app before initializing it + let parameters = GetUriParameters(); + + for (let key in parameters) { + if (parameters.hasOwnProperty(key)) { + SetStartupParameter(key, parameters[key]); + } + } + + StartWasmApplication(); + + // trigger a first resize of the canvas that have just been initialized + Stone.WasmViewport.ResizeAll(); + + UpdateContentThread(); +} + +function InitializeWasmApplication(wasmModuleName: string, orthancBaseUrl: string) { + + Stone.Framework.Configure(wasmModuleName); + + // Wait for the Orthanc Framework to be initialized (this initializes + // the WebAssembly environment) and then, create and initialize the Wasm application + Stone.Framework.Initialize(true, function () { + + console.log("Connecting C++ methods to JS methods"); + + SetStartupParameter = StoneFrameworkModule.cwrap('SetStartupParameter', null, ['string', 'string']); + CreateWasmApplication = StoneFrameworkModule.cwrap('CreateWasmApplication', null, ['number']); + CreateCppViewport = StoneFrameworkModule.cwrap('CreateCppViewport', 'number', []); + ReleaseCppViewport = StoneFrameworkModule.cwrap('ReleaseCppViewport', null, ['number']); + StartWasmApplication = StoneFrameworkModule.cwrap('StartWasmApplication', null, ['number']); + + WasmWebService_NotifySuccess = StoneFrameworkModule.cwrap('WasmWebService_NotifySuccess', null, ['number', 'string', 'array', 'number', 'number']); + WasmWebService_NotifyError = StoneFrameworkModule.cwrap('WasmWebService_NotifyError', null, ['number', 'string', 'number']); + WasmWebService_SetBaseUri = StoneFrameworkModule.cwrap('WasmWebService_SetBaseUri', null, ['string']); + NotifyUpdateContent = StoneFrameworkModule.cwrap('NotifyUpdateContent', null, []); + + SendMessageToStoneApplication = StoneFrameworkModule.cwrap('SendMessageToStoneApplication', 'string', ['string']); + + console.log("Connecting C++ methods to JS methods - done"); + + // Prevent scrolling + document.body.addEventListener('touchmove', function (event) { + event.preventDefault(); + }, false); + + _InitializeWasmApplication(orthancBaseUrl); + }); +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Platforms/Wasm/wasm-viewport.ts Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,298 @@ +var isPendingRedraw = false; + +function ScheduleWebViewportRedraw(cppViewportHandle: any) : void +{ + if (!isPendingRedraw) { + isPendingRedraw = true; + console.log('Scheduling a refresh of the viewport, as its content changed'); + window.requestAnimationFrame(function() { + isPendingRedraw = false; + Stone.WasmViewport.GetFromCppViewport(cppViewportHandle).Redraw(); + }); + } +} + +declare function UTF8ToString(any): string; + +function CreateWasmViewport(htmlCanvasId: string) : any { + var cppViewportHandle = CreateCppViewport(); + var canvasId = UTF8ToString(htmlCanvasId); + var webViewport = new Stone.WasmViewport(StoneFrameworkModule, canvasId, cppViewportHandle); // viewports are stored in a static map in WasmViewport -> won't be deleted + webViewport.Initialize(); + + return cppViewportHandle; +} + +module Stone { + +// export declare type InitializationCallback = () => void; + +// export declare var StoneFrameworkModule : any; + + //const ASSETS_FOLDER : string = "assets/lib"; + //const WASM_FILENAME : string = "orthanc-framework"; + + export class WasmViewport { + + private static viewportsMapByCppHandle_ : Map<number, WasmViewport> = new Map<number, WasmViewport>(); // key = the C++ handle + private static viewportsMapByCanvasId_ : Map<string, WasmViewport> = new Map<string, WasmViewport>(); // key = the canvasId + + private module_ : any; + private canvasId_ : string; + private htmlCanvas_ : HTMLCanvasElement; + private context_ : CanvasRenderingContext2D; + private imageData_ : any = null; + private renderingBuffer_ : any = null; + private touchZoom_ : any = false; + private touchTranslation_ : any = false; + + private ViewportSetSize : Function; + private ViewportRender : Function; + private ViewportMouseDown : Function; + private ViewportMouseMove : Function; + private ViewportMouseUp : Function; + private ViewportMouseEnter : Function; + private ViewportMouseLeave : Function; + private ViewportMouseWheel : Function; + private ViewportKeyPressed : Function; + + private pimpl_ : any; // Private pointer to the underlying WebAssembly C++ object + + public constructor(module: any, canvasId: string, cppViewport: any) { + + this.pimpl_ = cppViewport; + WasmViewport.viewportsMapByCppHandle_[this.pimpl_] = this; + WasmViewport.viewportsMapByCanvasId_[canvasId] = this; + + this.module_ = module; + this.canvasId_ = canvasId; + this.htmlCanvas_ = document.getElementById(this.canvasId_) as HTMLCanvasElement; + if (this.htmlCanvas_ == null) { + console.log("Can not create WasmViewport, did not find the canvas whose id is '", this.canvasId_, "'"); + } + this.context_ = this.htmlCanvas_.getContext('2d'); + + this.ViewportSetSize = this.module_.cwrap('ViewportSetSize', null, [ 'number', 'number', 'number' ]); + this.ViewportRender = this.module_.cwrap('ViewportRender', null, [ 'number', 'number', 'number', 'number' ]); + this.ViewportMouseDown = this.module_.cwrap('ViewportMouseDown', null, [ 'number', 'number', 'number', 'number', 'number' ]); + this.ViewportMouseMove = this.module_.cwrap('ViewportMouseMove', null, [ 'number', 'number', 'number' ]); + this.ViewportMouseUp = this.module_.cwrap('ViewportMouseUp', null, [ 'number' ]); + this.ViewportMouseEnter = this.module_.cwrap('ViewportMouseEnter', null, [ 'number' ]); + this.ViewportMouseLeave = this.module_.cwrap('ViewportMouseLeave', null, [ 'number' ]); + this.ViewportMouseWheel = this.module_.cwrap('ViewportMouseWheel', null, [ 'number', 'number', 'number', 'number', 'number' ]); + this.ViewportKeyPressed = this.module_.cwrap('ViewportKeyPressed', null, [ 'number', 'number', 'string', 'number', 'number' ]); + } + + public GetCppViewport() : number { + return this.pimpl_; + } + + public static GetFromCppViewport(cppViewportHandle: number) : WasmViewport { + if (WasmViewport.viewportsMapByCppHandle_[cppViewportHandle] !== undefined) { + return WasmViewport.viewportsMapByCppHandle_[cppViewportHandle]; + } + console.log("WasmViewport not found !"); + return undefined; + } + + public static GetFromCanvasId(canvasId: string) : WasmViewport { + if (WasmViewport.viewportsMapByCanvasId_[canvasId] !== undefined) { + return WasmViewport.viewportsMapByCanvasId_[canvasId]; + } + console.log("WasmViewport not found !"); + return undefined; + } + + public static ResizeAll() { + for (let canvasId in WasmViewport.viewportsMapByCanvasId_) { + WasmViewport.viewportsMapByCanvasId_[canvasId].Resize(); + } + } + + public Redraw() { + if (this.imageData_ === null || + this.renderingBuffer_ === null || + this.ViewportRender(this.pimpl_, + this.imageData_.width, + this.imageData_.height, + this.renderingBuffer_) == 0) { + console.log('The rendering has failed'); + } else { + // Create an accessor to the rendering buffer (i.e. create a + // "window" above the heap of the WASM module), then copy it to + // the ImageData object + this.imageData_.data.set(new Uint8ClampedArray( + this.module_.buffer, + this.renderingBuffer_, + this.imageData_.width * this.imageData_.height * 4)); + + this.context_.putImageData(this.imageData_, 0, 0); + } + } + + public Resize() { + if (this.imageData_ != null && + (this.imageData_.width != window.innerWidth || + this.imageData_.height != window.innerHeight)) { + this.imageData_ = null; + } + + // width/height can be defined in percent of window width/height through html attributes like data-width-ratio="50" and data-height-ratio="20" + var widthRatio = Number(this.htmlCanvas_.dataset["widthRatio"]) || 100; + var heightRatio = Number(this.htmlCanvas_.dataset["heightRatio"]) || 100; + + this.htmlCanvas_.width = window.innerWidth * (widthRatio / 100); + this.htmlCanvas_.height = window.innerHeight * (heightRatio / 100); + + console.log("resizing WasmViewport: ", this.htmlCanvas_.width, "x", this.htmlCanvas_.height); + + if (this.imageData_ === null) { + this.imageData_ = this.context_.getImageData(0, 0, this.htmlCanvas_.width, this.htmlCanvas_.height); + this.ViewportSetSize(this.pimpl_, this.htmlCanvas_.width, this.htmlCanvas_.height); + + if (this.renderingBuffer_ != null) { + this.module_._free(this.renderingBuffer_); + } + + this.renderingBuffer_ = this.module_._malloc(this.imageData_.width * this.imageData_.height * 4); + } else { + this.ViewportSetSize(this.pimpl_, this.htmlCanvas_.width, this.htmlCanvas_.height); + } + + this.Redraw(); + } + + public Initialize() { + + // Force the rendering of the viewport for the first time + this.Resize(); + + var that : WasmViewport = this; + // Register an event listener to call the Resize() function + // each time the window is resized. + window.addEventListener('resize', function(event) { + that.Resize(); + }, false); + + this.htmlCanvas_.addEventListener('contextmenu', function(event) { + // Prevent right click on the canvas + event.preventDefault(); + }, false); + + this.htmlCanvas_.addEventListener('mouseleave', function(event) { + that.ViewportMouseLeave(that.pimpl_); + }); + + this.htmlCanvas_.addEventListener('mouseenter', function(event) { + that.ViewportMouseEnter(that.pimpl_); + }); + + this.htmlCanvas_.addEventListener('mousedown', function(event) { + var x = event.pageX - this.offsetLeft; + var y = event.pageY - this.offsetTop; + that.ViewportMouseDown(that.pimpl_, event.button, x, y, 0 /* TODO */); + }); + + this.htmlCanvas_.addEventListener('mousemove', function(event) { + var x = event.pageX - this.offsetLeft; + var y = event.pageY - this.offsetTop; + that.ViewportMouseMove(that.pimpl_, x, y); + }); + + this.htmlCanvas_.addEventListener('mouseup', function(event) { + that.ViewportMouseUp(that.pimpl_); + }); + + window.addEventListener('keydown', function(event) { + var keyChar = event.key; + var keyCode = event.keyCode + if (keyChar.length == 1) { + keyCode = 0; // maps to OrthancStone::KeyboardKeys_Generic + } else { + keyChar = null; + } +// console.log("key: ", keyCode, keyChar); + that.ViewportKeyPressed(that.pimpl_, keyCode, keyChar, event.shiftKey, event.ctrlKey, event.altKey); + }); + + this.htmlCanvas_.addEventListener('wheel', function(event) { + var x = event.pageX - this.offsetLeft; + var y = event.pageY - this.offsetTop; + that.ViewportMouseWheel(that.pimpl_, event.deltaY, x, y, event.ctrlKey); + event.preventDefault(); + }); + + this.htmlCanvas_.addEventListener('touchstart', function(event) { + that.ResetTouch(); + }); + + this.htmlCanvas_.addEventListener('touchend', function(event) { + that.ResetTouch(); + }); + + this.htmlCanvas_.addEventListener('touchmove', function(event) { + if (that.touchTranslation_.length == 2) { + var t = that.GetTouchTranslation(event); + that.ViewportMouseMove(that.pimpl_, t[0], t[1]); + } + else if (that.touchZoom_.length == 3) { + var z0 = that.touchZoom_; + var z1 = that.GetTouchZoom(event); + that.ViewportMouseMove(that.pimpl_, z0[0], z0[1] - z0[2] + z1[2]); + } + else { + // Realize the gesture event + if (event.targetTouches.length == 1) { + // Exactly one finger inside the canvas => Setup a translation + that.touchTranslation_ = that.GetTouchTranslation(event); + that.ViewportMouseDown(that.pimpl_, + 1 /* middle button */, + that.touchTranslation_[0], + that.touchTranslation_[1], 0); + } else if (event.targetTouches.length == 2) { + // Exactly 2 fingers inside the canvas => Setup a pinch/zoom + that.touchZoom_ = that.GetTouchZoom(event); + var z0 = that.touchZoom_; + that.ViewportMouseDown(that.pimpl_, + 2 /* right button */, + z0[0], + z0[1], 0); + } + } + }); + } + + public ResetTouch() { + if (this.touchTranslation_ || + this.touchZoom_) { + this.ViewportMouseUp(this.pimpl_); + } + + this.touchTranslation_ = false; + this.touchZoom_ = false; + } + + public GetTouchTranslation(event) { + var touch = event.targetTouches[0]; + return [ + touch.pageX, + touch.pageY + ]; + } + + public GetTouchZoom(event) { + var touch1 = event.targetTouches[0]; + var touch2 = event.targetTouches[1]; + var dx = (touch1.pageX - touch2.pageX); + var dy = (touch1.pageY - touch2.pageY); + var d = Math.sqrt(dx * dx + dy * dy); + return [ + (touch1.pageX + touch2.pageX) / 2.0, + (touch1.pageY + touch2.pageY) / 2.0, + d + ]; + } + +} +} + \ No newline at end of file
--- a/Platforms/WebAssembly/CMakeLists.txt Mon Nov 05 10:04:56 2018 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,49 +0,0 @@ -# Usage (Linux): -# source ~/Downloads/emsdk/emsdk_env.sh && cmake -DCMAKE_TOOLCHAIN_FILE=${EMSCRIPTEN}/cmake/Modules/Platform/Emscripten.cmake .. - -cmake_minimum_required(VERSION 2.8.3) - - -##################################################################### -## Configuration of the Emscripten compiler for WebAssembly target -##################################################################### - -set(WASM_FLAGS "-s WASM=1") -set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WASM_FLAGS}") -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WASM_FLAGS}") -set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --js-library ${CMAKE_SOURCE_DIR}/library.js") - -# Handling of memory -#set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s ALLOW_MEMORY_GROWTH=1") # Resize -#set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s TOTAL_MEMORY=536870912") # 512MB -set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s ALLOW_MEMORY_GROWTH=1 -s TOTAL_MEMORY=536870912") # 512MB + resize -#set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s ALLOW_MEMORY_GROWTH=1 -s TOTAL_MEMORY=1073741824") # 1GB + resize - -# To debug exceptions -#set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s DEMANGLE_SUPPORT=1 -s ASSERTIONS=2") - - -##################################################################### -## Build a static library containing the Orthanc Stone framework -##################################################################### - -include(../../Resources/CMake/OrthancStoneParameters.cmake) - -SET(ORTHANC_SANDBOXED ON) -SET(ENABLE_SDL OFF) - -include(../../Resources/CMake/OrthancStoneConfiguration.cmake) - -add_library(OrthancStone STATIC ${ORTHANC_STONE_SOURCES}) - - - - - - -# Regenerate a dummy "library.c" file each time the "library.js" file -# is modified, so as to force a new execution of the linking -add_custom_command( - OUTPUT "${AUTOGENERATED_DIR}/library.c" - COMMAND ${CMAKE_COMMAND} -E touch "${AUTOGENERATED_DIR}/library.c" "" - DEPENDS "${CMAKE_SOURCE_DIR}/library.js")
--- a/Platforms/WebAssembly/library.js Mon Nov 05 10:04:56 2018 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,2 +0,0 @@ -mergeInto(LibraryManager.library, { -});
--- a/README Mon Nov 05 10:04:56 2018 +0100 +++ b/README Mon Nov 05 10:05:33 2018 +0100 @@ -72,6 +72,10 @@ * Optionally, SDL, a cross-platform multimedia library: https://www.libsdl.org/ +Prerequisites to compile on Ubuntu: +``` +sudo apt-get install -y libcairo-dev libpixman-1-dev libsdl2-dev +``` Installation and usage ---------------------- @@ -83,7 +87,43 @@ http://book.orthanc-server.com/developers/stone.html Stone of Orthanc comes with several sample applications in the -"Samples" folder. These samples use SDL. +"Samples" folder. These samples can be compiled into Web Assembly +or into native SDL applications. + +to build the WASM samples: +------------------------- +``` +cd ~/orthanc-stone/Applications/Samples +./build-wasm.sh +``` + +to serve the WASM samples: +``` +# launch an Orthanc listening on 8042 port: +Orthanc + +# launch an nginx that will serve the WASM static files and reverse proxy Orthanc +sudo nginx -p $(pwd) -c nginx.local.conf +``` +Now, you can open the samples in http://localhost:9977 + +to build the SDL native samples (SimpleViewer only): +------------------------------- +``` +mkdir -p ~/builds/orthanc-stone-build +cd ~/builds/orthanc-stone-build +cmake -DALLOW_DOWNLOADS=ON -DENABLE_SDL=ON ~/orthanc-stone/Applications/Samples/ +cmake --build . --target OrthancStoneSimpleViewer -- -j 5 +``` + +to execute the native samples: +``` +# launch an Orthanc listening on 8042 port: +Orthanc + +# launch the sample +./OrthancStoneSimpleViewer --studyId=XX +``` Licensing
--- a/Resources/CMake/OrthancStoneConfiguration.cmake Mon Nov 05 10:04:56 2018 +0100 +++ b/Resources/CMake/OrthancStoneConfiguration.cmake Mon Nov 05 10:05:33 2018 +0100 @@ -22,6 +22,12 @@ ## Configure the Orthanc Framework ##################################################################### +if (ENABLE_DCMTK) + set(ENABLE_LOCALE ON) +else() + set(ENABLE_LOCALE OFF) # Disable support for locales (notably in Boost) +endif() + include(${ORTHANC_ROOT}/Resources/CMake/OrthancFrameworkConfiguration.cmake) include_directories(${ORTHANC_ROOT}) @@ -39,6 +45,10 @@ message(FATAL_ERROR "Cannot enable SDL in sandboxed environments") endif() + if (ENABLE_QT) + message(FATAL_ERROR "Cannot enable QT in sandboxed environments") + endif() + if (ENABLE_SSL) message(FATAL_ERROR "Cannot enable SSL in sandboxed environments") endif() @@ -69,12 +79,26 @@ endif() -if (ENABLE_SDL) - include(${CMAKE_CURRENT_LIST_DIR}/SdlConfiguration.cmake) +if (ENABLE_SDL AND ENABLE_QT) + message("SDL and QT may not be defined together") +elseif(ENABLE_SDL) + message("SDL is enabled") + include(${CMAKE_CURRENT_LIST_DIR}/SdlConfiguration.cmake) + add_definitions(-DORTHANC_ENABLE_NATIVE=1) + add_definitions(-DORTHANC_ENABLE_QT=0) add_definitions(-DORTHANC_ENABLE_SDL=1) +elseif(ENABLE_QT) + message("QT is enabled") + include(${CMAKE_CURRENT_LIST_DIR}/QtConfiguration.cmake) + add_definitions(-DORTHANC_ENABLE_NATIVE=1) + add_definitions(-DORTHANC_ENABLE_QT=1) + add_definitions(-DORTHANC_ENABLE_SDL=0) else() + message("SDL and QT are both disabled") unset(USE_SYSTEM_SDL CACHE) add_definitions(-DORTHANC_ENABLE_SDL=0) + add_definitions(-DORTHANC_ENABLE_QT=0) + add_definitions(-DORTHANC_ENABLE_NATIVE=0) endif() @@ -93,7 +117,9 @@ -DORTHANC_ENABLE_LOGGING_PLUGIN=0 ) - +if (CMAKE_BUILD_TYPE STREQUAL "Debug") + add_definitions(-DCHECK_OBSERVERS_MESSAGES) +endif() ##################################################################### ## Embed the colormaps into the binaries @@ -105,6 +131,9 @@ # "OrthancStoneParameters.cmake" ${DCMTK_DICTIONARIES} + FONT_UBUNTU_MONO_BOLD_16 ${ORTHANC_ROOT}/Resources/Fonts/UbuntuMonoBold-16.json + #FONT_UBUNTU_MONO_BOLD_64 ${ORTHANC_ROOT}/Resources/Fonts/UbuntuMonoBold-64.json + # Resources specific to the Stone of Orthanc COLORMAP_HOT ${ORTHANC_STONE_ROOT}/Resources/Colormaps/hot.lut COLORMAP_JET ${ORTHANC_STONE_ROOT}/Resources/Colormaps/jet.lut @@ -141,39 +170,87 @@ ## All the source files required to build Stone of Orthanc ##################################################################### +set(APPLICATIONS_SOURCES + ${ORTHANC_STONE_ROOT}/Applications/IStoneApplication.h + ${ORTHANC_STONE_ROOT}/Applications/StoneApplicationContext.cpp + ${ORTHANC_STONE_ROOT}/Applications/Commands/BaseCommandBuilder.cpp + ${ORTHANC_STONE_ROOT}/Applications/Commands/ICommand.h + ${ORTHANC_STONE_ROOT}/Applications/Commands/ICommandExecutor.h + ${ORTHANC_STONE_ROOT}/Applications/Commands/ICommandBuilder.h + ) + if (NOT ORTHANC_SANDBOXED) set(PLATFORM_SOURCES + ${ORTHANC_STONE_ROOT}/Framework/Viewport/CairoFont.cpp + ${ORTHANC_STONE_ROOT}/Platforms/Generic/WebServiceCommandBase.cpp ${ORTHANC_STONE_ROOT}/Platforms/Generic/WebServiceGetCommand.cpp ${ORTHANC_STONE_ROOT}/Platforms/Generic/WebServicePostCommand.cpp + ${ORTHANC_STONE_ROOT}/Platforms/Generic/WebServiceDeleteCommand.cpp ${ORTHANC_STONE_ROOT}/Platforms/Generic/Oracle.cpp + ${ORTHANC_STONE_ROOT}/Platforms/Generic/OracleWebService.h ) - set(APPLICATIONS_SOURCES - ${ORTHANC_STONE_ROOT}/Applications/BasicApplicationContext.cpp - ${ORTHANC_STONE_ROOT}/Applications/IBasicApplication.cpp - ${ORTHANC_STONE_ROOT}/Applications/Sdl/SdlEngine.cpp - ${ORTHANC_STONE_ROOT}/Applications/Sdl/SdlCairoSurface.cpp - ${ORTHANC_STONE_ROOT}/Applications/Sdl/SdlOrthancSurface.cpp - ${ORTHANC_STONE_ROOT}/Applications/Sdl/SdlWindow.cpp + if (ENABLE_SDL OR ENABLE_QT) + list(APPEND APPLICATIONS_SOURCES + ${ORTHANC_STONE_ROOT}/Applications/Generic/NativeStoneApplicationRunner.cpp + ${ORTHANC_STONE_ROOT}/Applications/Generic/NativeStoneApplicationContext.cpp + ) + if (ENABLE_SDL) + list(APPEND APPLICATIONS_SOURCES + ${ORTHANC_STONE_ROOT}/Applications/Sdl/SdlStoneApplicationRunner.cpp + ${ORTHANC_STONE_ROOT}/Applications/Sdl/SdlEngine.cpp + ${ORTHANC_STONE_ROOT}/Applications/Sdl/SdlCairoSurface.cpp + ${ORTHANC_STONE_ROOT}/Applications/Sdl/SdlOrthancSurface.cpp + ${ORTHANC_STONE_ROOT}/Applications/Sdl/SdlWindow.cpp + ) + endif() + endif() +elseif (ENABLE_WASM) + list(APPEND APPLICATIONS_SOURCES + ${ORTHANC_STONE_ROOT}/Applications/Wasm/StartupParametersBuilder.cpp ) + + set(STONE_WASM_SOURCES + ${ORTHANC_STONE_ROOT}/Platforms/Wasm/Defaults.cpp + ${ORTHANC_STONE_ROOT}/Platforms/Wasm/WasmWebService.cpp + ${ORTHANC_STONE_ROOT}/Platforms/Wasm/WasmViewport.cpp + ${ORTHANC_STONE_ROOT}/Platforms/Wasm/WasmPlatformApplicationAdapter.cpp + ${AUTOGENERATED_DIR}/WasmWebService.c + ${AUTOGENERATED_DIR}/default-library.c + ) + + # Regenerate a dummy "WasmWebService.c" file each time the "WasmWebService.js" file + # is modified, so as to force a new execution of the linking + add_custom_command( + OUTPUT "${AUTOGENERATED_DIR}/WasmWebService.c" + COMMAND ${CMAKE_COMMAND} -E touch "${AUTOGENERATED_DIR}/WasmWebService.c" "" + DEPENDS "${ORTHANC_STONE_ROOT}/Platforms/Wasm/WasmWebService.js") + add_custom_command( + OUTPUT "${AUTOGENERATED_DIR}/default-library.c" + COMMAND ${CMAKE_COMMAND} -E touch "${AUTOGENERATED_DIR}/default-library.c" "" + DEPENDS "${ORTHANC_STONE_ROOT}/Platforms/Wasm/default-library.js") endif() list(APPEND ORTHANC_STONE_SOURCES #${ORTHANC_STONE_ROOT}/Framework/Layers/SeriesFrameRendererFactory.cpp #${ORTHANC_STONE_ROOT}/Framework/Layers/SiblingSliceLocationFactory.cpp #${ORTHANC_STONE_ROOT}/Framework/Layers/SingleFrameRendererFactory.cpp - ${ORTHANC_STONE_ROOT}/Framework/StoneEnumerations.cpp + ${ORTHANC_STONE_ROOT}/Framework/Layers/CircleMeasureTracker.cpp ${ORTHANC_STONE_ROOT}/Framework/Layers/ColorFrameRenderer.cpp ${ORTHANC_STONE_ROOT}/Framework/Layers/DicomStructureSetRendererFactory.cpp ${ORTHANC_STONE_ROOT}/Framework/Layers/FrameRenderer.cpp ${ORTHANC_STONE_ROOT}/Framework/Layers/GrayscaleFrameRenderer.cpp + ${ORTHANC_STONE_ROOT}/Framework/Layers/ILayerSource.h ${ORTHANC_STONE_ROOT}/Framework/Layers/LayerSourceBase.cpp ${ORTHANC_STONE_ROOT}/Framework/Layers/LineLayerRenderer.cpp ${ORTHANC_STONE_ROOT}/Framework/Layers/LineMeasureTracker.cpp ${ORTHANC_STONE_ROOT}/Framework/Layers/OrthancFrameLayerSource.cpp ${ORTHANC_STONE_ROOT}/Framework/Layers/RenderStyle.cpp ${ORTHANC_STONE_ROOT}/Framework/Layers/SliceOutlineRenderer.cpp + ${ORTHANC_STONE_ROOT}/Framework/SmartLoader.cpp + ${ORTHANC_STONE_ROOT}/Framework/StoneEnumerations.cpp + ${ORTHANC_STONE_ROOT}/Framework/StoneException.h ${ORTHANC_STONE_ROOT}/Framework/Toolbox/CoordinateSystem3D.cpp ${ORTHANC_STONE_ROOT}/Framework/Toolbox/DicomFrameConverter.cpp ${ORTHANC_STONE_ROOT}/Framework/Toolbox/DicomStructureSet.cpp @@ -181,10 +258,12 @@ ${ORTHANC_STONE_ROOT}/Framework/Toolbox/Extent2D.cpp ${ORTHANC_STONE_ROOT}/Framework/Toolbox/FiniteProjectiveCamera.cpp ${ORTHANC_STONE_ROOT}/Framework/Toolbox/GeometryToolbox.cpp + ${ORTHANC_STONE_ROOT}/Framework/Toolbox/IWebService.h ${ORTHANC_STONE_ROOT}/Framework/Toolbox/ImageGeometry.cpp ${ORTHANC_STONE_ROOT}/Framework/Toolbox/LinearAlgebra.cpp ${ORTHANC_STONE_ROOT}/Framework/Toolbox/MessagingToolbox.cpp ${ORTHANC_STONE_ROOT}/Framework/Toolbox/OrientedBoundingBox.cpp + ${ORTHANC_STONE_ROOT}/Framework/Toolbox/OrthancApiClient.cpp ${ORTHANC_STONE_ROOT}/Framework/Toolbox/OrthancSlicesLoader.cpp ${ORTHANC_STONE_ROOT}/Framework/Toolbox/ParallelSlices.cpp ${ORTHANC_STONE_ROOT}/Framework/Toolbox/ParallelSlicesCursor.cpp @@ -193,8 +272,9 @@ ${ORTHANC_STONE_ROOT}/Framework/Toolbox/SlicesSorter.cpp ${ORTHANC_STONE_ROOT}/Framework/Toolbox/ViewportGeometry.cpp ${ORTHANC_STONE_ROOT}/Framework/Viewport/CairoContext.cpp - ${ORTHANC_STONE_ROOT}/Framework/Viewport/CairoFont.cpp ${ORTHANC_STONE_ROOT}/Framework/Viewport/CairoSurface.cpp + ${ORTHANC_STONE_ROOT}/Framework/Viewport/IStatusBar.h + ${ORTHANC_STONE_ROOT}/Framework/Viewport/IViewport.h ${ORTHANC_STONE_ROOT}/Framework/Viewport/WidgetViewport.cpp ${ORTHANC_STONE_ROOT}/Framework/Volumes/ImageBuffer3D.cpp ${ORTHANC_STONE_ROOT}/Framework/Volumes/SlicedVolumeBase.cpp @@ -203,17 +283,32 @@ ${ORTHANC_STONE_ROOT}/Framework/Volumes/VolumeReslicer.cpp ${ORTHANC_STONE_ROOT}/Framework/Widgets/CairoWidget.cpp ${ORTHANC_STONE_ROOT}/Framework/Widgets/EmptyWidget.cpp + ${ORTHANC_STONE_ROOT}/Framework/Widgets/IWidget.h + ${ORTHANC_STONE_ROOT}/Framework/Widgets/IWorldSceneInteractor.h + ${ORTHANC_STONE_ROOT}/Framework/Widgets/IWorldSceneMouseTracker.h ${ORTHANC_STONE_ROOT}/Framework/Widgets/LayerWidget.cpp ${ORTHANC_STONE_ROOT}/Framework/Widgets/LayoutWidget.cpp + ${ORTHANC_STONE_ROOT}/Framework/Widgets/PanMouseTracker.cpp ${ORTHANC_STONE_ROOT}/Framework/Widgets/TestCairoWidget.cpp ${ORTHANC_STONE_ROOT}/Framework/Widgets/TestWorldSceneWidget.cpp ${ORTHANC_STONE_ROOT}/Framework/Widgets/WidgetBase.cpp ${ORTHANC_STONE_ROOT}/Framework/Widgets/WorldSceneWidget.cpp + ${ORTHANC_STONE_ROOT}/Framework/Widgets/ZoomMouseTracker.cpp + ${ORTHANC_STONE_ROOT}/Framework/dev.h + ${ORTHANC_STONE_ROOT}/Framework/Messages/ICallable.h + ${ORTHANC_STONE_ROOT}/Framework/Messages/IMessage.h + ${ORTHANC_STONE_ROOT}/Framework/Messages/IObservable.h + ${ORTHANC_STONE_ROOT}/Framework/Messages/IObserver.h + ${ORTHANC_STONE_ROOT}/Framework/Messages/MessageBroker.h + ${ORTHANC_STONE_ROOT}/Framework/Messages/MessageForwarder.cpp + ${ORTHANC_STONE_ROOT}/Framework/Messages/MessageType.h + ${ORTHANC_STONE_ROOT}/Framework/Messages/Promise.h + + ${ORTHANC_ROOT}/Plugins/Samples/Common/DicomDatasetReader.cpp ${ORTHANC_ROOT}/Plugins/Samples/Common/DicomPath.cpp + ${ORTHANC_ROOT}/Plugins/Samples/Common/FullOrthancDataset.cpp ${ORTHANC_ROOT}/Plugins/Samples/Common/IOrthancConnection.cpp - ${ORTHANC_ROOT}/Plugins/Samples/Common/DicomDatasetReader.cpp - ${ORTHANC_ROOT}/Plugins/Samples/Common/FullOrthancDataset.cpp ${PLATFORM_SOURCES} ${APPLICATIONS_SOURCES} @@ -227,5 +322,7 @@ # Optional components ${SDL_SOURCES} + ${QT_SOURCES} ${BOOST_EXTENDED_SOURCES} ) +
--- a/Resources/CMake/OrthancStoneParameters.cmake Mon Nov 05 10:04:56 2018 +0100 +++ b/Resources/CMake/OrthancStoneParameters.cmake Mon Nov 05 10:05:33 2018 +0100 @@ -25,7 +25,7 @@ include(${CMAKE_CURRENT_LIST_DIR}/../../Resources/Orthanc/DownloadOrthancFramework.cmake) include(${ORTHANC_ROOT}/Resources/CMake/OrthancFrameworkParameters.cmake) -set(ENABLE_LOCALE OFF) # Disable support for locales (notably in Boost) +set(ENABLE_DCMTK OFF) set(ENABLE_GOOGLE_TEST ON) set(ENABLE_SQLITE OFF) set(ENABLE_JPEG ON) @@ -49,4 +49,3 @@ ## the Stone of Orthanc ##################################################################### -set(ENABLE_SDL ON CACHE INTERNAL "Include support for SDL")
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Resources/CMake/QtConfiguration.cmake Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,77 @@ +# Stone of Orthanc +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2018 Osimis S.A., Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU Affero General Public License +# as published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + + +set(CMAKE_AUTOMOC OFF) +set(CMAKE_AUTOUIC OFF) + +# Find the QtWidgets library +find_package(Qt5Widgets QUIET) + +if (Qt5Widgets_FOUND) + message("Qt5 has been detected") + find_package(Qt5Core REQUIRED) + link_libraries( + Qt5::Widgets + Qt5::Core + ) + + # Create aliases for the CMake commands + macro(ORTHANC_QT_WRAP_UI) + QT5_WRAP_UI(${ARGN}) + endmacro() + + macro(ORTHANC_QT_WRAP_CPP) + QT5_WRAP_CPP(${ARGN}) + endmacro() + +else() + message("Qt5 has not been found, trying with Qt4") + find_package(Qt4 REQUIRED QtGui) + link_libraries( + Qt4::QtGui + ) + + # Create aliases for the CMake commands + macro(ORTHANC_QT_WRAP_UI) + QT4_WRAP_UI(${ARGN}) + endmacro() + + macro(ORTHANC_QT_WRAP_CPP) + QT4_WRAP_CPP(${ARGN}) + endmacro() + +endif() + +list(APPEND QT_SOURCES + ${ORTHANC_STONE_ROOT}/Applications/Qt/QCairoWidget.cpp + ${ORTHANC_STONE_ROOT}/Applications/Qt/QtStoneApplicationRunner.cpp + ${ORTHANC_STONE_ROOT}/Applications/Qt/QStoneMainWindow.cpp + ) + + +# NB: Including CMAKE_CURRENT_BINARY_DIR is mandatory, as the CMake +# macros for Qt will put their result in that directory, which cannot +# be changed. +# https://stackoverflow.com/a/4016784/881731 + +include_directories( + ${ORTHANC_STONE_ROOT}/Applications/Qt/ + ${CMAKE_CURRENT_BINARY_DIR} + ) +
--- a/Resources/Orthanc/DownloadOrthancFramework.cmake Mon Nov 05 10:04:56 2018 +0100 +++ b/Resources/Orthanc/DownloadOrthancFramework.cmake Mon Nov 05 10:05:33 2018 +0100 @@ -87,6 +87,8 @@ set(ORTHANC_FRAMEWORK_MD5 "d0ccdf68e855d8224331f13774992750") elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.4.0") set(ORTHANC_FRAMEWORK_MD5 "81e15f34d97ac32bbd7d26e85698835a") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.4.1") + set(ORTHANC_FRAMEWORK_MD5 "9b6f6114264b17ed421b574cd6476127") elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.4.2") set(ORTHANC_FRAMEWORK_MD5 "d1ee84927dcf668e60eb5868d24b9394") endif()
--- a/TODO Mon Nov 05 10:04:56 2018 +0100 +++ b/TODO Mon Nov 05 10:05:33 2018 +0100 @@ -26,7 +26,6 @@ ------------- * Tune number of loading threads in LayeredSceneWidget -* Add cache over IOrthancServices (for SDL/Qt/...) * LayoutWidget: Do not update full background if only 1 widget has changed * LayoutWidget: Threads to refresh each child * Implement binary search to speed up search for closest slice @@ -38,7 +37,6 @@ Platform-specific ----------------- -* Qt widget example * Add precompiled headers for Microsoft Visual Studio * Investigate crash in CurlOrthancConnection if using MinGW32 in Release mode
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/UnitTestsSources/TestCommands.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,108 @@ +///** +// * Stone of Orthanc +// * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +// * Department, University Hospital of Liege, Belgium +// * Copyright (C) 2017-2018 Osimis S.A., Belgium +// * +// * This program is free software: you can redistribute it and/or +// * modify it under the terms of the GNU Affero General Public License +// * as published by the Free Software Foundation, either version 3 of +// * the License, or (at your option) any later version. +// * +// * This program is distributed in the hope that it will be useful, but +// * WITHOUT ANY WARRANTY; without even the implied warranty of +// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// * Affero General Public License for more details. +// * +// * You should have received a copy of the GNU Affero General Public License +// * along with this program. If not, see <http://www.gnu.org/licenses/>. +// **/ + + +//#include "gtest/gtest.h" + +//#include "../Applications/Commands/BaseCommandFactory.h" +//#include "Core/OrthancException.h" + +//class CommandIncrement: public OrthancStone::BaseCommand<CommandIncrement> +//{ +//public: +// static int counter; +// int increment_; +//public: +// CommandIncrement() +// : OrthancStone::BaseCommand<CommandIncrement>("increment"), +// increment_(0) +// {} + +// virtual void Execute() +// { +// counter += increment_; +// } +// virtual void Configure(const Json::Value& arguments) +// { +// increment_ = arguments["increment"].asInt(); +// } +//}; + +//// COMMAND("name", "arg1", "int", "arg2", "string") +//// COMMAND(name, arg1, arg2) + + +//int CommandIncrement::counter = 0; + +//TEST(Commands, CreateNoop) +//{ +// OrthancStone::BaseCommandFactory factory; + +// factory.RegisterCommandClass<OrthancStone::NoopCommand>(); + +// Json::Value cmdJson; +// cmdJson["command"] = "noop"; + +// std::auto_ptr<OrthancStone::ICommand> command(factory.CreateFromJson(cmdJson)); + +// ASSERT_TRUE(command.get() != NULL); +// ASSERT_EQ("noop", command->GetName()); +//} + +//TEST(Commands, Execute) +//{ +// OrthancStone::BaseCommandFactory factory; + +// factory.RegisterCommandClass<OrthancStone::NoopCommand>(); +// factory.RegisterCommandClass<CommandIncrement>(); + +// Json::Value cmdJson; +// cmdJson["command"] = "increment"; +// cmdJson["args"]["increment"] = 2; + +// std::auto_ptr<OrthancStone::ICommand> command(factory.CreateFromJson(cmdJson)); + +// ASSERT_TRUE(command.get() != NULL); +// CommandIncrement::counter = 0; +// command->Execute(); +// ASSERT_EQ(2, CommandIncrement::counter); +//} + +//TEST(Commands, TryCreateUnknowCommand) +//{ +// OrthancStone::BaseCommandFactory factory; +// factory.RegisterCommandClass<OrthancStone::NoopCommand>(); + +// Json::Value cmdJson; +// cmdJson["command"] = "unknown"; + +// ASSERT_THROW(std::auto_ptr<OrthancStone::ICommand> command(factory.CreateFromJson(cmdJson)), Orthanc::OrthancException); +//} + +//TEST(Commands, TryCreateCommandFromInvalidJson) +//{ +// OrthancStone::BaseCommandFactory factory; +// factory.RegisterCommandClass<OrthancStone::NoopCommand>(); + +// Json::Value cmdJson; +// cmdJson["command-name"] = "noop"; + +// ASSERT_THROW(std::auto_ptr<OrthancStone::ICommand> command(factory.CreateFromJson(cmdJson)), Orthanc::OrthancException); +//}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/UnitTestsSources/TestExceptions.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,43 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#include "gtest/gtest.h" + +#include "../Framework/StoneException.h" + + + +TEST(StoneExceptions, OrthancToStoneConversion) +{ + bool hasBeenCatched = false; + try { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + catch (Orthanc::OrthancException& orthancException) + { + hasBeenCatched = true; + OrthancStone::StoneOrthancException stoneException(orthancException); + ASSERT_EQ(OrthancStone::ErrorCode_OrthancError, stoneException.GetErrorCode()); + ASSERT_EQ(Orthanc::ErrorCode_InternalError, stoneException.GetOrthancErrorCode()); + } + + ASSERT_TRUE(hasBeenCatched); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/UnitTestsSources/TestMessageBroker.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,158 @@ +///** +// * Stone of Orthanc +// * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +// * Department, University Hospital of Liege, Belgium +// * Copyright (C) 2017-2018 Osimis S.A., Belgium +// * +// * This program is free software: you can redistribute it and/or +// * modify it under the terms of the GNU Affero General Public License +// * as published by the Free Software Foundation, either version 3 of +// * the License, or (at your option) any later version. +// * +// * This program is distributed in the hope that it will be useful, but +// * WITHOUT ANY WARRANTY; without even the implied warranty of +// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// * Affero General Public License for more details. +// * +// * You should have received a copy of the GNU Affero General Public License +// * along with this program. If not, see <http://www.gnu.org/licenses/>. +// **/ + + +//#include "gtest/gtest.h" + +//#include "../Framework/Messages/MessageBroker.h" +//#include "../Framework/Messages/IMessage.h" +//#include "../Framework/Messages/IObservable.h" +//#include "../Framework/Messages/IObserver.h" +//#include "../Framework/StoneEnumerations.h" + + +//static int test1Counter = 0; +//static int test2Counter = 0; +//class MyFullObserver : public OrthancStone::IObserver +//{ + +//public: +// MyFullObserver(OrthancStone::MessageBroker& broker) +// : OrthancStone::IObserver(broker) +// { +//// DeclareHandledMessage(OrthancStone::MessageType_Test1); +//// DeclareIgnoredMessage(OrthancStone::MessageType_Test2); +// } + + +// void HandleMessage(OrthancStone::IObservable& from, const OrthancStone::IMessage& message) { +// switch (message.GetType()) +// { +// case OrthancStone::MessageType_Test1: +// test1Counter++; +// break; +// case OrthancStone::MessageType_Test2: +// test2Counter++; +// break; +// default: +// throw OrthancStone::MessageNotDeclaredException(message.GetType()); +// } +// } + +//}; + +//class MyPartialObserver : public OrthancStone::IObserver +//{ + +//public: +// MyPartialObserver(OrthancStone::MessageBroker& broker) +// : OrthancStone::IObserver(broker) +// { +//// DeclareHandledMessage(OrthancStone::MessageType_Test1); +// // don't declare Test2 on purpose +// } + + +// void HandleMessage(OrthancStone::IObservable& from, const OrthancStone::IMessage& message) { +// switch (message.GetType()) +// { +// case OrthancStone::MessageType_Test1: +// test1Counter++; +// break; +// case OrthancStone::MessageType_Test2: +// test2Counter++; +// break; +// default: +// throw OrthancStone::MessageNotDeclaredException(message.GetType()); +// } +// } + +//}; + + +//class MyObservable : public OrthancStone::IObservable +//{ + +//public: +// MyObservable(OrthancStone::MessageBroker& broker) +// : OrthancStone::IObservable(broker) +// { +// DeclareEmittableMessage(OrthancStone::MessageType_Test1); +// DeclareEmittableMessage(OrthancStone::MessageType_Test2); +// } + +//}; + + +//TEST(MessageBroker, NormalUsage) +//{ +// OrthancStone::MessageBroker broker; +// MyObservable observable(broker); + +// test1Counter = 0; + +// // no observers have been registered -> nothing shall happen +// observable.EmitMessage(OrthancStone::IMessage(OrthancStone::MessageType_Test1)); + +// ASSERT_EQ(0, test1Counter); + +// // register an observer, check it is called +// MyFullObserver fullObserver(broker); +// ASSERT_NO_THROW(observable.RegisterObserver(fullObserver)); + +// observable.EmitMessage(OrthancStone::IMessage(OrthancStone::MessageType_Test1)); + +// ASSERT_EQ(1, test1Counter); + +// // register an invalid observer, check it raises an exception +// MyPartialObserver partialObserver(broker); +// ASSERT_THROW(observable.RegisterObserver(partialObserver), OrthancStone::MessageNotDeclaredException); + +// // check an exception is thrown when the observable emits an undeclared message +// ASSERT_THROW(observable.EmitMessage(OrthancStone::IMessage(OrthancStone::MessageType_LayerSource_GeometryReady)), OrthancStone::MessageNotDeclaredException); + +// // unregister the observer, make sure nothing happens afterwards +// observable.UnregisterObserver(fullObserver); +// observable.EmitMessage(OrthancStone::IMessage(OrthancStone::MessageType_Test1)); +// ASSERT_EQ(1, test1Counter); +//} + +//TEST(MessageBroker, DeleteObserverWhileRegistered) +//{ +// OrthancStone::MessageBroker broker; +// MyObservable observable(broker); + +// test1Counter = 0; + +// { +// // register an observer, check it is called +// MyFullObserver observer(broker); +// observable.RegisterObserver(observer); + +// observable.EmitMessage(OrthancStone::IMessage(OrthancStone::MessageType_Test1)); + +// ASSERT_EQ(1, test1Counter); +// } + +// // at this point, the observer has been deleted, the handle shall not be called again (and it shall not crash !) +// observable.EmitMessage(OrthancStone::IMessage(OrthancStone::MessageType_Test1)); + +// ASSERT_EQ(1, test1Counter); +//}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/UnitTestsSources/TestMessageBroker2.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,410 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#include "gtest/gtest.h" + +#include "Framework/Messages/MessageBroker.h" +#include "Framework/Messages/Promise.h" +#include "Framework/Messages/IObservable.h" +#include "Framework/Messages/IObserver.h" +#include "Framework/Messages/MessageForwarder.h" + + +int testCounter = 0; +namespace { + + using namespace OrthancStone; + + + enum CustomMessageType + { + CustomMessageType_First = MessageType_CustomMessage + 1, + + CustomMessageType_Completed, + CustomMessageType_Increment + }; + + + class MyObservable : public IObservable + { + public: + struct MyCustomMessage: public BaseMessage<CustomMessageType_Completed> + { + int payload_; + + MyCustomMessage(int payload) + : BaseMessage(), + payload_(payload) + {} + }; + + MyObservable(MessageBroker& broker) + : IObservable(broker) + {} + + }; + + class MyObserver : public IObserver + { + public: + MyObserver(MessageBroker& broker) + : IObserver(broker) + {} + + void HandleCompletedMessage(const MyObservable::MyCustomMessage& message) + { + testCounter += message.payload_; + } + + }; + + + class MyIntermediate : public IObserver, public IObservable + { + IObservable& observedObject_; + public: + MyIntermediate(MessageBroker& broker, IObservable& observedObject) + : IObserver(broker), + IObservable(broker), + observedObject_(observedObject) + { + observedObject_.RegisterObserverCallback(new MessageForwarder<MyObservable::MyCustomMessage>(broker, *this)); + } + }; + + + class MyPromiseSource : public IObservable + { + Promise* currentPromise_; + public: + struct MyPromiseMessage: public BaseMessage<MessageType_Test1> + { + int increment; + + MyPromiseMessage(int increment) + : BaseMessage(), + increment(increment) + {} + }; + + MyPromiseSource(MessageBroker& broker) + : IObservable(broker), + currentPromise_(NULL) + {} + + Promise& StartSomethingAsync() + { + currentPromise_ = new Promise(broker_); + return *currentPromise_; + } + + void CompleteSomethingAsyncWithSuccess(int payload) + { + currentPromise_->Success(MyPromiseMessage(payload)); + delete currentPromise_; + } + + void CompleteSomethingAsyncWithFailure(int payload) + { + currentPromise_->Failure(MyPromiseMessage(payload)); + delete currentPromise_; + } + }; + + + class MyPromiseTarget : public IObserver + { + public: + MyPromiseTarget(MessageBroker& broker) + : IObserver(broker) + {} + + void IncrementCounter(const MyPromiseSource::MyPromiseMessage& args) + { + testCounter += args.increment; + } + + void DecrementCounter(const MyPromiseSource::MyPromiseMessage& args) + { + testCounter -= args.increment; + } + }; +} + + +TEST(MessageBroker2, TestPermanentConnectionSimpleUseCase) +{ + MessageBroker broker; + MyObservable observable(broker); + MyObserver observer(broker); + + // create a permanent connection between an observable and an observer + observable.RegisterObserverCallback(new Callable<MyObserver, MyObservable::MyCustomMessage>(observer, &MyObserver::HandleCompletedMessage)); + + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(12)); + ASSERT_EQ(12, testCounter); + + // the connection is permanent; if we emit the same message again, the observer will be notified again + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(20)); + ASSERT_EQ(20, testCounter); +} + +TEST(MessageBroker2, TestMessageForwarderSimpleUseCase) +{ + MessageBroker broker; + MyObservable observable(broker); + MyIntermediate intermediate(broker, observable); + MyObserver observer(broker); + + // let the observer observers the intermediate that is actually forwarding the messages from the observable + intermediate.RegisterObserverCallback(new Callable<MyObserver, MyObservable::MyCustomMessage>(observer, &MyObserver::HandleCompletedMessage)); + + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(12)); + ASSERT_EQ(12, testCounter); + + // the connection is permanent; if we emit the same message again, the observer will be notified again + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(20)); + ASSERT_EQ(20, testCounter); +} + +TEST(MessageBroker2, TestPermanentConnectionDeleteObserver) +{ + MessageBroker broker; + MyObservable observable(broker); + MyObserver* observer = new MyObserver(broker); + + // create a permanent connection between an observable and an observer + observable.RegisterObserverCallback(new Callable<MyObserver, MyObservable::MyCustomMessage>(*observer, &MyObserver::HandleCompletedMessage)); + + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(12)); + ASSERT_EQ(12, testCounter); + + // delete the observer and check that the callback is not called anymore + delete observer; + + // the connection is permanent; if we emit the same message again, the observer will be notified again + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(20)); + ASSERT_EQ(0, testCounter); +} + +TEST(MessageBroker2, TestMessageForwarderDeleteIntermediate) +{ + MessageBroker broker; + MyObservable observable(broker); + MyIntermediate* intermediate = new MyIntermediate(broker, observable); + MyObserver observer(broker); + + // let the observer observers the intermediate that is actually forwarding the messages from the observable + intermediate->RegisterObserverCallback(new Callable<MyObserver, MyObservable::MyCustomMessage>(observer, &MyObserver::HandleCompletedMessage)); + + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(12)); + ASSERT_EQ(12, testCounter); + + delete intermediate; + + observable.EmitMessage(MyObservable::MyCustomMessage(20)); + ASSERT_EQ(12, testCounter); +} + +TEST(MessageBroker2, TestCustomMessage) +{ + MessageBroker broker; + MyObservable observable(broker); + MyIntermediate intermediate(broker, observable); + MyObserver observer(broker); + + // let the observer observers the intermediate that is actually forwarding the messages from the observable + intermediate.RegisterObserverCallback(new Callable<MyObserver, MyObservable::MyCustomMessage>(observer, &MyObserver::HandleCompletedMessage)); + + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(12)); + ASSERT_EQ(12, testCounter); + + // the connection is permanent; if we emit the same message again, the observer will be notified again + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(20)); + ASSERT_EQ(20, testCounter); +} + + +TEST(MessageBroker2, TestPromiseSuccessFailure) +{ + MessageBroker broker; + MyPromiseSource source(broker); + MyPromiseTarget target(broker); + + // test a successful promise + source.StartSomethingAsync() + .Then(new Callable<MyPromiseTarget, MyPromiseSource::MyPromiseMessage>(target, &MyPromiseTarget::IncrementCounter)) + .Else(new Callable<MyPromiseTarget, MyPromiseSource::MyPromiseMessage>(target, &MyPromiseTarget::DecrementCounter)); + + testCounter = 0; + source.CompleteSomethingAsyncWithSuccess(10); + ASSERT_EQ(10, testCounter); + + // test a failing promise + source.StartSomethingAsync() + .Then(new Callable<MyPromiseTarget, MyPromiseSource::MyPromiseMessage>(target, &MyPromiseTarget::IncrementCounter)) + .Else(new Callable<MyPromiseTarget, MyPromiseSource::MyPromiseMessage>(target, &MyPromiseTarget::DecrementCounter)); + + testCounter = 0; + source.CompleteSomethingAsyncWithFailure(15); + ASSERT_EQ(-15, testCounter); +} + +TEST(MessageBroker2, TestPromiseDeleteTarget) +{ + MessageBroker broker; + MyPromiseSource source(broker); + MyPromiseTarget* target = new MyPromiseTarget(broker); + + // create the promise + source.StartSomethingAsync() + .Then(new Callable<MyPromiseTarget, MyPromiseSource::MyPromiseMessage>(*target, &MyPromiseTarget::IncrementCounter)) + .Else(new Callable<MyPromiseTarget, MyPromiseSource::MyPromiseMessage>(*target, &MyPromiseTarget::DecrementCounter)); + + // delete the promise target + delete target; + + // trigger the promise, make sure it does not throw and does not call the callback + testCounter = 0; + source.CompleteSomethingAsyncWithSuccess(10); + ASSERT_EQ(0, testCounter); + + // test a failing promise + source.StartSomethingAsync() + .Then(new Callable<MyPromiseTarget, MyPromiseSource::MyPromiseMessage>(*target, &MyPromiseTarget::IncrementCounter)) + .Else(new Callable<MyPromiseTarget, MyPromiseSource::MyPromiseMessage>(*target, &MyPromiseTarget::DecrementCounter)); + + testCounter = 0; + source.CompleteSomethingAsyncWithFailure(15); + ASSERT_EQ(0, testCounter); +} + +#if __cplusplus >= 201103L + +#include <functional> + +namespace OrthancStone { + + template <typename TMessage> + class LambdaCallable : public MessageHandler<TMessage> + { + private: + + IObserver& observer_; + std::function<void (const TMessage&)> lambda_; + + public: + LambdaCallable(IObserver& observer, + std::function<void (const TMessage&)> lambdaFunction) : + observer_(observer), + lambda_(lambdaFunction) + { + } + + virtual void Apply(const IMessage& message) + { + lambda_(dynamic_cast<const TMessage&>(message)); + } + + virtual MessageType GetMessageType() const + { + return static_cast<MessageType>(TMessage::Type); + } + + virtual IObserver* GetObserver() const + { + return &observer_; + } + }; + + +} + +TEST(MessageBroker2, TestLambdaSimpleUseCase) +{ + MessageBroker broker; + MyObservable observable(broker); + MyObserver* observer = new MyObserver(broker); + + // create a permanent connection between an observable and an observer + observable.RegisterObserverCallback(new LambdaCallable<MyObservable::MyCustomMessage>(*observer, [&](const MyObservable::MyCustomMessage& message) {testCounter += 2 * message.payload_;})); + + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(12)); + ASSERT_EQ(24, testCounter); + + // delete the observer and check that the callback is not called anymore + delete observer; + + // the connection is permanent; if we emit the same message again, the observer will be notified again + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(20)); + ASSERT_EQ(0, testCounter); +} + +namespace { + class MyObserverWithLambda : public IObserver { + private: + int multiplier_; // this is a private variable we want to access in a lambda + + public: + MyObserverWithLambda(MessageBroker& broker, int multiplier, MyObservable& observable) + : IObserver(broker), + multiplier_(multiplier) + { + // register a callable to a lambda that access private members + observable.RegisterObserverCallback(new LambdaCallable<MyObservable::MyCustomMessage>(*this, [this](const MyObservable::MyCustomMessage& message) { + testCounter += multiplier_ * message.payload_; + })); + + } + }; +} + +TEST(MessageBroker2, TestLambdaCaptureThisAndAccessPrivateMembers) +{ + MessageBroker broker; + MyObservable observable(broker); + MyObserverWithLambda* observer = new MyObserverWithLambda(broker, 3, observable); + + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(12)); + ASSERT_EQ(36, testCounter); + + // delete the observer and check that the callback is not called anymore + delete observer; + + // the connection is permanent; if we emit the same message again, the observer will be notified again + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(20)); + ASSERT_EQ(0, testCounter); +} + +#endif // C++ 11
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/UnitTestsSources/TestMessageBroker2_connect_ok.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,226 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#include "gtest/gtest.h" + +#include <boost/noncopyable.hpp> +#include <boost/function.hpp> +#include <boost/bind.hpp> + +#include <string> +#include <map> +#include <set> + +int testCounter = 0; +namespace { + + enum MessageType + { + // used in unit tests only + MessageType_Test1, + MessageType_Test2, + + MessageType_LastGenericStoneMessage + }; + + struct IMessage : public boost::noncopyable + { + MessageType messageType_; + public: + IMessage(const MessageType& messageType) + : messageType_(messageType) + {} + virtual ~IMessage() {} + + MessageType GetType() const {return messageType_;} + }; + + + class IObserver; + class IObservable; + + /* + * This is a central message broker. It keeps track of all observers and knows + * when an observer is deleted. + * This way, it can prevent an observable to send a message to a dead observer. + */ + class MessageBroker : public boost::noncopyable + { + + std::set<IObserver*> activeObservers_; // the list of observers that are currently alive (that have not been deleted) + + public: + + void Register(IObserver& observer) + { + activeObservers_.insert(&observer); + } + + void Unregister(IObserver& observer) + { + activeObservers_.erase(&observer); + } + + void EmitMessage(IObservable& from, std::set<IObserver*> observers, const IMessage& message); + }; + + + class IObserver : public boost::noncopyable + { + protected: + MessageBroker& broker_; + + public: + IObserver(MessageBroker& broker) + : broker_(broker) + { + broker_.Register(*this); + } + + virtual ~IObserver() + { + broker_.Unregister(*this); + } + + void HandleMessage_(IObservable &from, const IMessage &message) + { + + HandleMessage(from, message); + } + + virtual void HandleMessage(IObservable& from, const IMessage& message) = 0; + + + protected: + + + }; + +// struct ICallableObserver +// { +// IObserver* observer; +// }; + +// typedef void (IObserver::*ObserverSingleMesssageHandler)(IObservable& from, const IMessage& message); + +// template <typename TObserver> +// struct CallableObserver : public ICallableObserver +// { +// void (TObserver::*ptrToMemberHandler)(IObservable& from, const IMessage& message); +// }; + + struct CallableObserver + { + IObserver* observer; + boost::function<void (IObservable& from, const IMessage& message)> f; + }; + + class IObservable : public boost::noncopyable + { + protected: + MessageBroker& broker_; + + std::set<IObserver*> observers_; + + std::map<MessageType, std::set<CallableObserver*> > callables_; + public: + + IObservable(MessageBroker& broker) + : broker_(broker) + { + } + virtual ~IObservable() + { + } + + void EmitMessage(const IMessage& message) + { + //broker_.EmitMessage(*this, observers_, message); + + // TODO check if observer is still alive and call ! + CallableObserver* callable = *(callables_[message.GetType()].begin()); + callable->f(*this, message); + } + + void RegisterObserver(IObserver& observer) + { + observers_.insert(&observer); + } + + void UnregisterObserver(IObserver& observer) + { + observers_.erase(&observer); + } + + + //template<typename TObserver> void Connect(MessageType messageType, IObserver& observer, void (TObserver::*ptrToMemberHandler)(IObservable& from, const IMessage& message)) + void Connect(MessageType messageType, IObserver& observer, boost::function<void (IObservable& from, const IMessage& message)> f) + { + callables_[messageType] = std::set<CallableObserver*>(); + CallableObserver* callable = new CallableObserver(); + callable->observer = &observer; + callable->f = f; + callables_[messageType].insert(callable); + } + }; + + + class MyObservable : public IObservable + { + public: + MyObservable(MessageBroker& broker) + : IObservable(broker) + {} + }; + + class MyObserver : public IObserver + { + public: + MyObserver(MessageBroker& broker) + : IObserver(broker) + {} + virtual void HandleMessage(IObservable& from, const IMessage& message) {} + void HandleSpecificMessage(IObservable& from, const IMessage& message) + { + testCounter++; + } + + }; + +} + +//#define STONE_CONNECT(observabe, messageType, observerPtr, observerMemberFnPtr) + +TEST(MessageBroker2, Test1) +{ + MessageBroker broker; + MyObservable observable(broker); + MyObserver observer(broker); + + + observable.Connect(MessageType_Test1, observer, boost::bind(&MyObserver::HandleSpecificMessage, &observer, _1, _2)); + //STONE_CONNECT(observable, MessageType_Test1, observer, &MyObserver::HandleSpecificMessage) + observable.EmitMessage(IMessage(MessageType_Test1)); + + ASSERT_EQ(1, testCounter); +} + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/UnitTestsSources/TestMessageBroker2_promise_and_connect_ok.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -0,0 +1,520 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#include "gtest/gtest.h" + +#include <boost/noncopyable.hpp> +#include <boost/function.hpp> +#include <boost/bind.hpp> + +#include <string> +#include <map> +#include <set> + +int testCounter = 0; +namespace { + + enum MessageType + { + MessageType_Test1, + MessageType_Test2, + + MessageType_CustomMessage, + MessageType_LastGenericStoneMessage + }; + + struct IMessage : public boost::noncopyable + { + MessageType messageType_; + public: + IMessage(const MessageType& messageType) + : messageType_(messageType) + {} + virtual ~IMessage() {} + + virtual int GetType() const {return messageType_;} + }; + + + struct ICustomMessage : public IMessage + { + int customMessageType_; + public: + ICustomMessage(int customMessageType) + : IMessage(MessageType_CustomMessage), + customMessageType_(customMessageType) + {} + virtual ~ICustomMessage() {} + + virtual int GetType() const {return customMessageType_;} + }; + + + class IObserver; + class IObservable; + class IPromiseTarget; + class IPromiseSource; + class Promise; + + /* + * This is a central message broker. It keeps track of all observers and knows + * when an observer is deleted. + * This way, it can prevent an observable to send a message to a delete observer. + * It does the same book-keeping for the IPromiseTarget and IPromiseSource + */ + class MessageBroker : public boost::noncopyable + { + + std::set<IObserver*> activeObservers_; // the list of observers that are currently alive (that have not been deleted) + std::set<IPromiseTarget*> activePromiseTargets_; + std::set<IPromiseSource*> activePromiseSources_; + + public: + + void Register(IObserver& observer) + { + activeObservers_.insert(&observer); + } + + void Unregister(IObserver& observer) + { + activeObservers_.erase(&observer); + } + + void Register(IPromiseTarget& target) + { + activePromiseTargets_.insert(&target); + } + + void Unregister(IPromiseTarget& target) + { + activePromiseTargets_.erase(&target); + } + + void Register(IPromiseSource& source) + { + activePromiseSources_.insert(&source); + } + + void Unregister(IPromiseSource& source) + { + activePromiseSources_.erase(&source); + } + + void EmitMessage(IObservable& from, std::set<IObserver*> observers, const IMessage& message); + + bool IsActive(IPromiseTarget* target) + { + return activePromiseTargets_.find(target) != activePromiseTargets_.end(); + } + + bool IsActive(IPromiseSource* source) + { + return activePromiseSources_.find(source) != activePromiseSources_.end(); + } + + bool IsActive(IObserver* observer) + { + return activeObservers_.find(observer) != activeObservers_.end(); + } + }; + + struct IPromiseArgs + { +public: + virtual ~IPromiseArgs() {} + }; + + class EmptyPromiseArguments : public IPromiseArgs + { + + }; + + class Promise : public boost::noncopyable + { + protected: + MessageBroker& broker_; + + IPromiseTarget* successTarget_; + boost::function<void (const IPromiseArgs& message)> successCallable_; + + IPromiseTarget* failureTarget_; + boost::function<void (const IPromiseArgs& message)> failureCallable_; + + public: + Promise(MessageBroker& broker) + : broker_(broker), + successTarget_(NULL), + failureTarget_(NULL) + { + } + + void Success(const IPromiseArgs& message) + { + // check the target is still alive in the broker + if (broker_.IsActive(successTarget_)) + { + successCallable_(message); + } + } + + void Failure(const IPromiseArgs& message) + { + // check the target is still alive in the broker + if (broker_.IsActive(failureTarget_)) + { + failureCallable_(message); + } + } + + Promise& Then(IPromiseTarget* target, boost::function<void (const IPromiseArgs& message)> f) + { + if (successTarget_ != NULL) + { + // TODO: throw throw new "Promise may only have a single success target" + } + successTarget_ = target; + successCallable_ = f; + return *this; + } + + Promise& Else(IPromiseTarget* target, boost::function<void (const IPromiseArgs& message)> f) + { + if (failureTarget_ != NULL) + { + // TODO: throw throw new "Promise may only have a single failure target" + } + failureTarget_ = target; + failureCallable_ = f; + return *this; + } + + }; + + class IObserver : public boost::noncopyable + { + protected: + MessageBroker& broker_; + + public: + IObserver(MessageBroker& broker) + : broker_(broker) + { + broker_.Register(*this); + } + + virtual ~IObserver() + { + broker_.Unregister(*this); + } + + }; + + class IPromiseTarget : public boost::noncopyable + { + protected: + MessageBroker& broker_; + + public: + IPromiseTarget(MessageBroker& broker) + : broker_(broker) + { + broker_.Register(*this); + } + + virtual ~IPromiseTarget() + { + broker_.Unregister(*this); + } + }; + + class IPromiseSource : public boost::noncopyable + { + protected: + MessageBroker& broker_; + + public: + IPromiseSource(MessageBroker& broker) + : broker_(broker) + { + broker_.Register(*this); + } + + virtual ~IPromiseSource() + { + broker_.Unregister(*this); + } + }; + + + struct CallableObserver + { + IObserver* observer; + boost::function<void (IObservable& from, const IMessage& message)> f; + }; + + class IObservable : public boost::noncopyable + { + protected: + MessageBroker& broker_; + + std::set<IObserver*> observers_; + + std::map<int, std::set<CallableObserver*> > callables_; + public: + + IObservable(MessageBroker& broker) + : broker_(broker) + { + } + virtual ~IObservable() + { + } + + void EmitMessage(const IMessage& message) + { + //broker_.EmitMessage(*this, observers_, message); + int messageType = message.GetType(); + if (callables_.find(messageType) != callables_.end()) + { + for (std::set<CallableObserver*>::iterator observer = callables_[messageType].begin(); observer != callables_[messageType].end(); observer++) + { + CallableObserver* callable = *observer; + if (broker_.IsActive(callable->observer)) + { + callable->f(*this, message); + } + } + } + + } + + void RegisterObserver(IObserver& observer) + { + observers_.insert(&observer); + } + + void UnregisterObserver(IObserver& observer) + { + observers_.erase(&observer); + } + + //template<typename TObserver> void Connect(MessageType messageType, IObserver& observer, void (TObserver::*ptrToMemberHandler)(IObservable& from, const IMessage& message)) + void Connect(int messageType, IObserver& observer, boost::function<void (IObservable& from, const IMessage& message)> f) + { + callables_[messageType] = std::set<CallableObserver*>(); + CallableObserver* callable = new CallableObserver(); + callable->observer = &observer; + callable->f = f; + callables_[messageType].insert(callable); + } + }; + + + enum CustomMessageType + { + CustomMessageType_First = MessageType_LastGenericStoneMessage + 1, + + CustomMessageType_Completed + }; + + class MyObservable : public IObservable + { + public: + struct MyCustomMessage: public ICustomMessage + { + int payload_; + MyCustomMessage(int payload) + : ICustomMessage(CustomMessageType_Completed), + payload_(payload) + {} + }; + + MyObservable(MessageBroker& broker) + : IObservable(broker) + {} + + }; + + class MyObserver : public IObserver + { + public: + MyObserver(MessageBroker& broker) + : IObserver(broker) + {} + void HandleCompletedMessage(IObservable& from, const IMessage& message) + { + const MyObservable::MyCustomMessage& msg = dynamic_cast<const MyObservable::MyCustomMessage&>(message); + testCounter += msg.payload_; + } + + }; + + + class MyPromiseSource : public IPromiseSource + { + Promise* currentPromise_; + public: + struct MyPromiseArgs : public IPromiseArgs + { + int increment; + }; + + MyPromiseSource(MessageBroker& broker) + : IPromiseSource(broker), + currentPromise_(NULL) + {} + + Promise& StartSomethingAsync() + { + currentPromise_ = new Promise(broker_); + return *currentPromise_; + } + + void CompleteSomethingAsyncWithSuccess() + { + currentPromise_->Success(EmptyPromiseArguments()); + delete currentPromise_; + } + + void CompleteSomethingAsyncWithFailure() + { + currentPromise_->Failure(EmptyPromiseArguments()); + delete currentPromise_; + } + }; + + + class MyPromiseTarget : public IPromiseTarget + { + public: + MyPromiseTarget(MessageBroker& broker) + : IPromiseTarget(broker) + {} + + void IncrementCounter(const IPromiseArgs& args) + { + testCounter++; + } + + void DecrementCounter(const IPromiseArgs& args) + { + testCounter--; + } + }; +} + +#define CONNECT_MESSAGES(observablePtr, messageType, observerPtr, observerFnPtr) (observablePtr)->Connect(messageType, *(observerPtr), boost::bind(observerFnPtr, observerPtr, _1, _2)) +#define PTHEN(targetPtr, targetFnPtr) Then(targetPtr, boost::bind(targetFnPtr, targetPtr, _1)) +#define PELSE(targetPtr, targetFnPtr) Else(targetPtr, boost::bind(targetFnPtr, targetPtr, _1)) + + +TEST(MessageBroker2, TestPermanentConnectionSimpleUseCase) +{ + MessageBroker broker; + MyObservable observable(broker); + MyObserver observer(broker); + + // create a permanent connection between an observable and an observer + CONNECT_MESSAGES(&observable, CustomMessageType_Completed, &observer, &MyObserver::HandleCompletedMessage); + + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(12)); + ASSERT_EQ(12, testCounter); + + // the connection is permanent; if we emit the same message again, the observer will be notified again + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(20)); + ASSERT_EQ(20, testCounter); +} + +TEST(MessageBroker2, TestPermanentConnectionDeleteObserver) +{ + MessageBroker broker; + MyObservable observable(broker); + MyObserver* observer = new MyObserver(broker); + + // create a permanent connection between an observable and an observer + CONNECT_MESSAGES(&observable, CustomMessageType_Completed, observer, &MyObserver::HandleCompletedMessage); + + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(12)); + ASSERT_EQ(12, testCounter); + + // delete the observer and check that the callback is not called anymore + delete observer; + + // the connection is permanent; if we emit the same message again, the observer will be notified again + testCounter = 0; + observable.EmitMessage(MyObservable::MyCustomMessage(20)); + ASSERT_EQ(0, testCounter); +} + + +TEST(MessageBroker2, TestPromiseSuccessFailure) +{ + MessageBroker broker; + MyPromiseSource source(broker); + MyPromiseTarget target(broker); + + // test a successful promise + source.StartSomethingAsync() + .PTHEN(&target, &MyPromiseTarget::IncrementCounter) + .PELSE(&target, &MyPromiseTarget::DecrementCounter); + + testCounter = 0; + source.CompleteSomethingAsyncWithSuccess(); + ASSERT_EQ(1, testCounter); + + // test a failing promise + source.StartSomethingAsync() + .PTHEN(&target, &MyPromiseTarget::IncrementCounter) + .PELSE(&target, &MyPromiseTarget::DecrementCounter); + + testCounter = 0; + source.CompleteSomethingAsyncWithFailure(); + ASSERT_EQ(-1, testCounter); +} + +//TEST(MessageBroker2, TestPromiseDeleteTarget) +//{ +// MessageBroker broker; +// MyPromiseSource source(broker); +// MyPromiseTarget target(broker); + +// // test a successful promise +// source.StartSomethingAsync() +// .PTHEN(&target, &MyPromiseTarget::IncrementCounter) +// .PELSE(&target, &MyPromiseTarget::DecrementCounter); + +// testCounter = 0; +// source.CompleteSomethingAsyncWithSuccess(); +// ASSERT_EQ(1, testCounter); + +// // test a failing promise +// source.StartSomethingAsync() +// .PTHEN(&target, &MyPromiseTarget::IncrementCounter) +// .PELSE(&target, &MyPromiseTarget::DecrementCounter); + +// testCounter = 0; +// source.CompleteSomethingAsyncWithFailure(); +// ASSERT_EQ(-1, testCounter); +//}
--- a/UnitTestsSources/UnitTestsMain.cpp Mon Nov 05 10:04:56 2018 +0100 +++ b/UnitTestsSources/UnitTestsMain.cpp Mon Nov 05 10:05:33 2018 +0100 @@ -26,6 +26,7 @@ #include "../Framework/Layers/LayerSourceBase.h" #include "../Framework/Toolbox/DownloadStack.h" #include "../Framework/Toolbox/FiniteProjectiveCamera.h" +#include "../Framework/Toolbox/MessagingToolbox.h" #include "../Framework/Toolbox/OrthancSlicesLoader.h" #include "../Framework/Volumes/ImageBuffer3D.h" #include "../Framework/Volumes/SlicedVolumeBase.h" @@ -55,7 +56,7 @@ for (size_t i = 0; i < loader.GetSliceCount(); i++) { - const_cast<OrthancSlicesLoader&>(loader).ScheduleLoadSliceImage(i, SliceImageQuality_Full); + const_cast<OrthancSlicesLoader&>(loader).ScheduleLoadSliceImage(i, SliceImageQuality_FullPng); } } @@ -724,6 +725,12 @@ */ } +TEST(MessagingToolbox, ParseJson) +{ + Json::Value response; + std::string source = "{\"command\":\"panel:takeDarkImage\",\"commandType\":\"simple\",\"args\":{}}"; + ASSERT_TRUE(OrthancStone::MessagingToolbox::ParseJson(response, source.c_str(), source.size())); +} int main(int argc, char **argv) {