Mercurial > hg > orthanc-webviewer
annotate Plugin/Plugin.cpp @ 12:379131283479
version
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Wed, 11 Mar 2015 14:23:24 +0100 |
| parents | ecefd45026bf |
| children | 20af33af313a |
| rev | line source |
|---|---|
| 0 | 1 /** |
| 2 * Orthanc - A Lightweight, RESTful DICOM Store | |
| 3 * Copyright (C) 2012-2015 Sebastien Jodogne, Medical Physics | |
| 4 * Department, University Hospital of Liege, Belgium | |
| 5 * | |
| 6 * This program is free software: you can redistribute it and/or | |
| 7 * modify it under the terms of the GNU Affero General Public License | |
| 8 * as published by the Free Software Foundation, either version 3 of | |
| 9 * the License, or (at your option) any later version. | |
| 10 * | |
| 11 * This program is distributed in the hope that it will be useful, but | |
| 12 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 14 * Affero General Public License for more details. | |
| 15 * | |
| 16 * You should have received a copy of the GNU Affero General Public License | |
| 17 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| 18 **/ | |
| 19 | |
| 20 | |
| 21 #include <boost/thread.hpp> | |
| 22 #include <boost/lexical_cast.hpp> | |
| 23 #include <EmbeddedResources.h> | |
|
4
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
24 #include <boost/filesystem.hpp> |
| 0 | 25 |
| 26 #include "../Orthanc/OrthancException.h" | |
| 27 #include "ViewerToolbox.h" | |
| 28 #include "ViewerPrefetchPolicy.h" | |
| 29 #include "DecodedImageAdapter.h" | |
| 30 #include "InstanceInformationAdapter.h" | |
| 31 #include "SeriesInformationAdapter.h" | |
| 32 | |
| 33 | |
| 34 | |
| 35 class CacheContext | |
| 36 { | |
| 37 private: | |
| 38 std::auto_ptr<Orthanc::FilesystemStorage> storage_; | |
| 39 std::auto_ptr<Orthanc::SQLite::Connection> db_; | |
| 40 std::auto_ptr<OrthancPlugins::CacheManager> cache_; | |
| 41 std::auto_ptr<OrthancPlugins::CacheScheduler> scheduler_; | |
| 42 | |
| 43 public: | |
| 44 CacheContext(const std::string& path) | |
| 45 { | |
| 46 boost::filesystem::path p(path); | |
| 47 | |
| 48 storage_.reset(new Orthanc::FilesystemStorage(path)); | |
| 49 db_.reset(new Orthanc::SQLite::Connection()); | |
| 50 db_->Open((p / "cache.db").string()); | |
| 51 | |
| 52 cache_.reset(new OrthancPlugins::CacheManager(*db_, *storage_)); | |
| 53 //cache_->SetSanityCheckEnabled(true); // For debug | |
| 54 | |
| 55 scheduler_.reset(new OrthancPlugins::CacheScheduler(*cache_, 100)); | |
| 56 } | |
| 57 | |
| 58 OrthancPlugins::CacheScheduler& GetScheduler() | |
| 59 { | |
| 60 return *scheduler_; | |
| 61 } | |
| 62 }; | |
| 63 | |
| 64 | |
| 65 static OrthancPluginContext* context_ = NULL; | |
| 66 static CacheContext* cache_ = NULL; | |
| 67 | |
| 68 | |
| 69 | |
| 70 static int32_t OnChangeCallback(OrthancPluginChangeType changeType, | |
| 71 OrthancPluginResourceType resourceType, | |
| 72 const char* resourceId) | |
| 73 { | |
| 74 try | |
| 75 { | |
| 76 if (changeType == OrthancPluginChangeType_NewInstance && | |
| 77 resourceType == OrthancPluginResourceType_Instance) | |
| 78 { | |
| 79 // On the reception of a new instance, precompute its spatial position | |
| 80 cache_->GetScheduler().Prefetch(OrthancPlugins::CacheBundle_InstanceInformation, resourceId); | |
| 81 | |
| 82 // Indalidate the parent series of the instance | |
| 83 std::string uri = "/instances/" + std::string(resourceId); | |
| 84 Json::Value instance; | |
| 85 if (OrthancPlugins::GetJsonFromOrthanc(instance, context_, uri)) | |
| 86 { | |
| 87 std::string seriesId = instance["ParentSeries"].asString(); | |
| 88 cache_->GetScheduler().Invalidate(OrthancPlugins::CacheBundle_SeriesInformation, seriesId); | |
| 89 } | |
| 90 } | |
| 91 | |
| 92 return 0; | |
| 93 } | |
| 94 catch (std::runtime_error& e) | |
| 95 { | |
| 96 OrthancPluginLogError(context_, e.what()); | |
| 97 return 0; // Ignore error | |
| 98 } | |
| 99 } | |
| 100 | |
| 101 | |
| 102 | |
| 103 template <enum OrthancPlugins::CacheBundle bundle> | |
| 104 int32_t ServeCache(OrthancPluginRestOutput* output, | |
| 105 const char* url, | |
| 106 const OrthancPluginHttpRequest* request) | |
| 107 { | |
| 108 try | |
| 109 { | |
| 110 if (request->method != OrthancPluginHttpMethod_Get) | |
| 111 { | |
| 112 OrthancPluginSendMethodNotAllowed(context_, output, "GET"); | |
| 113 return 0; | |
| 114 } | |
| 115 | |
| 116 const std::string id = request->groups[0]; | |
| 117 std::string content; | |
| 118 | |
| 119 if (cache_->GetScheduler().Access(content, bundle, id)) | |
| 120 { | |
| 121 OrthancPluginAnswerBuffer(context_, output, content.c_str(), content.size(), "application/json"); | |
| 122 } | |
| 123 else | |
| 124 { | |
| 125 OrthancPluginSendHttpStatusCode(context_, output, 404); | |
| 126 } | |
| 127 | |
| 128 return 0; | |
| 129 } | |
| 130 catch (Orthanc::OrthancException& e) | |
| 131 { | |
| 132 OrthancPluginLogError(context_, e.What()); | |
| 133 return -1; | |
| 134 } | |
| 135 catch (std::runtime_error& e) | |
| 136 { | |
| 137 OrthancPluginLogError(context_, e.what()); | |
| 138 return -1; | |
| 139 } | |
| 140 catch (boost::bad_lexical_cast&) | |
| 141 { | |
| 142 OrthancPluginLogError(context_, "Bad lexical cast"); | |
| 143 return -1; | |
| 144 } | |
| 145 } | |
| 146 | |
| 147 | |
| 148 | |
| 149 | |
| 150 #if ORTHANC_STANDALONE == 0 | |
| 151 static int32_t ServeWebViewer(OrthancPluginRestOutput* output, | |
| 152 const char* url, | |
| 153 const OrthancPluginHttpRequest* request) | |
| 154 { | |
| 155 if (request->method != OrthancPluginHttpMethod_Get) | |
| 156 { | |
| 157 OrthancPluginSendMethodNotAllowed(context_, output, "GET"); | |
| 158 return 0; | |
| 159 } | |
| 160 | |
| 161 const std::string path = std::string(WEB_VIEWER_PATH) + std::string(request->groups[0]); | |
| 162 const char* mime = OrthancPlugins::GetMimeType(path); | |
| 163 | |
| 164 std::string s; | |
| 165 if (OrthancPlugins::ReadFile(s, path)) | |
| 166 { | |
| 167 const char* resource = s.size() ? s.c_str() : NULL; | |
| 168 OrthancPluginAnswerBuffer(context_, output, resource, s.size(), mime); | |
| 169 } | |
| 170 else | |
| 171 { | |
| 172 std::string s = "Inexistent file in served folder: " + path; | |
| 173 OrthancPluginLogError(context_, s.c_str()); | |
| 174 OrthancPluginSendHttpStatusCode(context_, output, 404); | |
| 175 } | |
| 176 | |
| 177 return 0; | |
| 178 } | |
| 179 #endif | |
| 180 | |
| 181 | |
| 182 | |
| 183 template <enum OrthancPlugins::EmbeddedResources::DirectoryResourceId folder> | |
| 184 static int32_t ServeEmbeddedFolder(OrthancPluginRestOutput* output, | |
| 185 const char* url, | |
| 186 const OrthancPluginHttpRequest* request) | |
| 187 { | |
| 188 if (request->method != OrthancPluginHttpMethod_Get) | |
| 189 { | |
| 190 OrthancPluginSendMethodNotAllowed(context_, output, "GET"); | |
| 191 return 0; | |
| 192 } | |
| 193 | |
| 194 std::string path = "/" + std::string(request->groups[0]); | |
| 195 const char* mime = OrthancPlugins::GetMimeType(path); | |
| 196 | |
| 197 try | |
| 198 { | |
| 199 std::string s; | |
| 200 OrthancPlugins::EmbeddedResources::GetDirectoryResource(s, folder, path.c_str()); | |
| 201 | |
| 202 const char* resource = s.size() ? s.c_str() : NULL; | |
| 203 OrthancPluginAnswerBuffer(context_, output, resource, s.size(), mime); | |
| 204 | |
| 205 return 0; | |
| 206 } | |
| 207 catch (std::runtime_error&) | |
| 208 { | |
| 209 std::string s = "Unknown static resource in plugin: " + std::string(request->groups[0]); | |
| 210 OrthancPluginLogError(context_, s.c_str()); | |
| 211 OrthancPluginSendHttpStatusCode(context_, output, 404); | |
| 212 return 0; | |
| 213 } | |
| 214 } | |
| 215 | |
| 216 | |
| 217 | |
| 218 | |
| 219 extern "C" | |
| 220 { | |
| 221 ORTHANC_PLUGINS_API int32_t OrthancPluginInitialize(OrthancPluginContext* context) | |
| 222 { | |
| 223 using namespace OrthancPlugins; | |
| 224 | |
| 225 context_ = context; | |
| 226 OrthancPluginLogWarning(context_, "Initializing the Web viewer"); | |
| 227 | |
| 228 | |
| 229 /* Check the version of the Orthanc core */ | |
| 230 if (OrthancPluginCheckVersion(context_) == 0) | |
| 231 { | |
| 232 char info[1024]; | |
| 233 sprintf(info, "Your version of Orthanc (%s) must be above %d.%d.%d to run this plugin", | |
| 234 context_->orthancVersion, | |
| 235 ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER, | |
| 236 ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER, | |
| 237 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER); | |
| 238 OrthancPluginLogError(context_, info); | |
| 239 return -1; | |
| 240 } | |
| 241 | |
| 242 OrthancPluginSetDescription(context_, "Provides a Web viewer of DICOM series within Orthanc."); | |
| 243 | |
| 244 | |
| 245 /* By default, use half of the available processing cores for the decoding of DICOM images */ | |
| 246 int decodingThreads = boost::thread::hardware_concurrency() / 2; | |
| 247 if (decodingThreads == 0) | |
| 248 { | |
| 249 decodingThreads = 1; | |
| 250 } | |
| 251 | |
| 252 | |
| 253 try | |
| 254 { | |
| 255 /* Read the configuration of the Web viewer */ | |
| 256 Json::Value configuration; | |
| 257 if (!ReadConfiguration(configuration, context)) | |
| 258 { | |
| 259 OrthancPluginLogError(context_, "Unable to read the configuration file of Orthanc"); | |
| 260 return -1; | |
| 261 } | |
| 262 | |
|
4
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
263 // By default, the cache of the Web viewer is located inside the |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
264 // "StorageDirectory" of Orthanc |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
265 boost::filesystem::path cachePath = GetStringValue(configuration, "StorageDirectory", "."); |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
266 cachePath /= "WebViewerCache"; |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
267 int cacheSize = 100; // By default, a cache of 100 MB is used |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
268 |
| 0 | 269 if (configuration.isMember("WebViewer")) |
| 270 { | |
|
4
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
271 std::string key = "CachePath"; |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
272 if (!configuration["WebViewer"].isMember(key)) |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
273 { |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
274 // For backward compatibility with the initial release of the Web viewer |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
275 key = "Cache"; |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
276 } |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
277 |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
278 cachePath = GetStringValue(configuration["WebViewer"], key, cachePath.string()); |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
279 cacheSize = GetIntegerValue(configuration["WebViewer"], "CacheSize", cacheSize); |
| 0 | 280 decodingThreads = GetIntegerValue(configuration["WebViewer"], "Threads", decodingThreads); |
| 281 } | |
| 282 | |
| 283 std::string message = ("Web viewer using " + boost::lexical_cast<std::string>(decodingThreads) + | |
| 284 " threads for the decoding of the DICOM images"); | |
| 285 OrthancPluginLogWarning(context_, message.c_str()); | |
| 286 | |
|
4
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
287 if (decodingThreads <= 0 || |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
288 cacheSize <= 0) |
| 0 | 289 { |
| 290 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
| 291 } | |
| 292 | |
|
4
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
293 message = "Storing the cache of the Web viewer in folder: " + cachePath.string(); |
| 0 | 294 OrthancPluginLogWarning(context_, message.c_str()); |
| 295 | |
| 296 | |
| 297 /* Create the cache */ | |
|
4
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
298 cache_ = new CacheContext(cachePath.string()); |
| 0 | 299 cache_->GetScheduler().RegisterPolicy(new ViewerPrefetchPolicy(context_)); |
| 300 cache_->GetScheduler().Register(CacheBundle_SeriesInformation, | |
| 301 new SeriesInformationAdapter(context_, cache_->GetScheduler()), 1); | |
| 302 cache_->GetScheduler().Register(CacheBundle_InstanceInformation, | |
| 303 new InstanceInformationAdapter(context_), 1); | |
| 304 cache_->GetScheduler().Register(CacheBundle_DecodedImage, | |
| 305 new DecodedImageAdapter(context_), decodingThreads); | |
|
4
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
306 |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
307 |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
308 /* Set the quotas */ |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
309 cache_->GetScheduler().SetQuota(CacheBundle_SeriesInformation, 1000, 0); // Keep info about 1000 series |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
310 cache_->GetScheduler().SetQuota(CacheBundle_InstanceInformation, 10000, 0); // Keep info about 10,000 instances |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
311 |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
312 message = "Web viewer using a cache of " + boost::lexical_cast<std::string>(cacheSize) + " MB"; |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
313 OrthancPluginLogWarning(context_, message.c_str()); |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
314 |
|
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
315 cache_->GetScheduler().SetQuota(CacheBundle_DecodedImage, 0, static_cast<uint64_t>(cacheSize) * 1024 * 1024); |
| 0 | 316 } |
| 317 catch (std::runtime_error& e) | |
| 318 { | |
| 319 OrthancPluginLogError(context_, e.what()); | |
| 320 return -1; | |
| 321 } | |
| 322 catch (Orthanc::OrthancException& e) | |
| 323 { | |
| 324 OrthancPluginLogError(context_, e.What()); | |
| 325 return -1; | |
| 326 } | |
| 327 | |
| 328 | |
| 329 /* Install the callbacks */ | |
| 330 OrthancPluginRegisterRestCallback(context_, "/web-viewer/series/(.*)", ServeCache<CacheBundle_SeriesInformation>); | |
| 331 OrthancPluginRegisterRestCallback(context_, "/web-viewer/instances/(.*)", ServeCache<CacheBundle_DecodedImage>); | |
| 332 OrthancPluginRegisterRestCallback(context, "/web-viewer/libs/(.*)", ServeEmbeddedFolder<EmbeddedResources::JAVASCRIPT_LIBS>); | |
| 333 | |
| 334 #if ORTHANC_STANDALONE == 1 | |
| 335 OrthancPluginRegisterRestCallback(context, "/web-viewer/app/(.*)", ServeEmbeddedFolder<EmbeddedResources::WEB_VIEWER>); | |
| 336 #else | |
| 337 OrthancPluginRegisterRestCallback(context, "/web-viewer/app/(.*)", ServeWebViewer); | |
| 338 #endif | |
| 339 | |
| 340 OrthancPluginRegisterOnChangeCallback(context, OnChangeCallback); | |
| 341 | |
| 342 | |
| 343 /* Extend the default Orthanc Explorer with custom JavaScript */ | |
| 344 std::string explorer; | |
| 345 EmbeddedResources::GetFileResource(explorer, EmbeddedResources::ORTHANC_EXPLORER); | |
| 346 OrthancPluginExtendOrthancExplorer(context_, explorer.c_str()); | |
| 347 | |
| 348 return 0; | |
| 349 } | |
| 350 | |
| 351 | |
| 352 ORTHANC_PLUGINS_API void OrthancPluginFinalize() | |
| 353 { | |
| 354 OrthancPluginLogWarning(context_, "Finalizing the Web viewer"); | |
| 355 | |
| 356 if (cache_ != NULL) | |
| 357 { | |
| 358 delete cache_; | |
| 359 cache_ = NULL; | |
| 360 } | |
| 361 } | |
| 362 | |
| 363 | |
| 364 ORTHANC_PLUGINS_API const char* OrthancPluginGetName() | |
| 365 { | |
| 366 return "web-viewer"; | |
| 367 } | |
| 368 | |
| 369 | |
| 370 ORTHANC_PLUGINS_API const char* OrthancPluginGetVersion() | |
| 371 { | |
| 12 | 372 return ORTHANC_WEBVIEWER_VERSION; |
| 0 | 373 } |
| 374 } |