Mercurial > hg > orthanc-webviewer
annotate Plugin/Plugin.cpp @ 74:ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Fri, 18 Sep 2015 17:52:52 +0200 |
parents | b3259b9c6dfb |
children | e15a59a4b4d4 |
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 | 26 #include "../Orthanc/Core/OrthancException.h" |
0 | 27 #include "ViewerToolbox.h" |
28 #include "ViewerPrefetchPolicy.h" | |
29 #include "DecodedImageAdapter.h" | |
30 #include "InstanceInformationAdapter.h" | |
31 #include "SeriesInformationAdapter.h" | |
32 | |
33 | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
34 #if (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER >= 9 && ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= 5) |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
35 # define RETURN_TYPE OrthancPluginErrorCode |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
36 # define RETURN_SUCCESS OrthancPluginErrorCode_Success |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
37 # define RETURN_FAILURE OrthancPluginErrorCode_Plugin |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
38 #else |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
39 # define RETURN_TYPE int32_t |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
40 # define RETURN_SUCCESS 0 |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
41 # define RETURN_FAILURE -1 |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
42 #endif |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
43 |
0 | 44 |
45 class CacheContext | |
46 { | |
47 private: | |
58 | 48 Orthanc::FilesystemStorage storage_; |
49 Orthanc::SQLite::Connection db_; | |
50 | |
0 | 51 std::auto_ptr<OrthancPlugins::CacheManager> cache_; |
52 std::auto_ptr<OrthancPlugins::CacheScheduler> scheduler_; | |
53 | |
54 public: | |
58 | 55 CacheContext(const std::string& path) : storage_(path) |
0 | 56 { |
57 boost::filesystem::path p(path); | |
58 | 58 db_.Open((p / "cache.db").string()); |
0 | 59 |
58 | 60 cache_.reset(new OrthancPlugins::CacheManager(db_, storage_)); |
0 | 61 //cache_->SetSanityCheckEnabled(true); // For debug |
62 | |
63 scheduler_.reset(new OrthancPlugins::CacheScheduler(*cache_, 100)); | |
64 } | |
65 | |
58 | 66 ~CacheContext() |
67 { | |
68 scheduler_.reset(NULL); | |
69 cache_.reset(NULL); | |
70 } | |
71 | |
0 | 72 OrthancPlugins::CacheScheduler& GetScheduler() |
73 { | |
74 return *scheduler_; | |
75 } | |
76 }; | |
77 | |
78 | |
79 static OrthancPluginContext* context_ = NULL; | |
80 static CacheContext* cache_ = NULL; | |
81 | |
82 | |
83 | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
84 static RETURN_TYPE OnChangeCallback(OrthancPluginChangeType changeType, |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
85 OrthancPluginResourceType resourceType, |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
86 const char* resourceId) |
0 | 87 { |
88 try | |
89 { | |
90 if (changeType == OrthancPluginChangeType_NewInstance && | |
91 resourceType == OrthancPluginResourceType_Instance) | |
92 { | |
93 // On the reception of a new instance, precompute its spatial position | |
94 cache_->GetScheduler().Prefetch(OrthancPlugins::CacheBundle_InstanceInformation, resourceId); | |
95 | |
96 // Indalidate the parent series of the instance | |
97 std::string uri = "/instances/" + std::string(resourceId); | |
98 Json::Value instance; | |
99 if (OrthancPlugins::GetJsonFromOrthanc(instance, context_, uri)) | |
100 { | |
101 std::string seriesId = instance["ParentSeries"].asString(); | |
102 cache_->GetScheduler().Invalidate(OrthancPlugins::CacheBundle_SeriesInformation, seriesId); | |
103 } | |
104 } | |
105 | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
106 return RETURN_SUCCESS; |
0 | 107 } |
108 catch (std::runtime_error& e) | |
109 { | |
110 OrthancPluginLogError(context_, e.what()); | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
111 return RETURN_SUCCESS; // Ignore error |
0 | 112 } |
113 } | |
114 | |
115 | |
116 | |
117 template <enum OrthancPlugins::CacheBundle bundle> | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
118 static RETURN_TYPE ServeCache(OrthancPluginRestOutput* output, |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
119 const char* url, |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
120 const OrthancPluginHttpRequest* request) |
0 | 121 { |
122 try | |
123 { | |
124 if (request->method != OrthancPluginHttpMethod_Get) | |
125 { | |
126 OrthancPluginSendMethodNotAllowed(context_, output, "GET"); | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
127 return RETURN_SUCCESS; |
0 | 128 } |
129 | |
130 const std::string id = request->groups[0]; | |
131 std::string content; | |
132 | |
133 if (cache_->GetScheduler().Access(content, bundle, id)) | |
134 { | |
135 OrthancPluginAnswerBuffer(context_, output, content.c_str(), content.size(), "application/json"); | |
136 } | |
137 else | |
138 { | |
139 OrthancPluginSendHttpStatusCode(context_, output, 404); | |
140 } | |
141 | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
142 return RETURN_SUCCESS; |
0 | 143 } |
144 catch (Orthanc::OrthancException& e) | |
145 { | |
146 OrthancPluginLogError(context_, e.What()); | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
147 return RETURN_FAILURE; |
0 | 148 } |
149 catch (std::runtime_error& e) | |
150 { | |
151 OrthancPluginLogError(context_, e.what()); | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
152 return RETURN_FAILURE; |
0 | 153 } |
154 catch (boost::bad_lexical_cast&) | |
155 { | |
156 OrthancPluginLogError(context_, "Bad lexical cast"); | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
157 return RETURN_FAILURE; |
0 | 158 } |
159 } | |
160 | |
161 | |
162 | |
163 | |
164 #if ORTHANC_STANDALONE == 0 | |
165 static int32_t ServeWebViewer(OrthancPluginRestOutput* output, | |
166 const char* url, | |
167 const OrthancPluginHttpRequest* request) | |
168 { | |
169 if (request->method != OrthancPluginHttpMethod_Get) | |
170 { | |
171 OrthancPluginSendMethodNotAllowed(context_, output, "GET"); | |
172 return 0; | |
173 } | |
174 | |
175 const std::string path = std::string(WEB_VIEWER_PATH) + std::string(request->groups[0]); | |
176 const char* mime = OrthancPlugins::GetMimeType(path); | |
177 | |
178 std::string s; | |
179 if (OrthancPlugins::ReadFile(s, path)) | |
180 { | |
181 const char* resource = s.size() ? s.c_str() : NULL; | |
182 OrthancPluginAnswerBuffer(context_, output, resource, s.size(), mime); | |
183 } | |
184 else | |
185 { | |
186 std::string s = "Inexistent file in served folder: " + path; | |
187 OrthancPluginLogError(context_, s.c_str()); | |
188 OrthancPluginSendHttpStatusCode(context_, output, 404); | |
189 } | |
190 | |
191 return 0; | |
192 } | |
193 #endif | |
194 | |
195 | |
196 | |
31 | 197 template <enum Orthanc::EmbeddedResources::DirectoryResourceId folder> |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
198 static RETURN_TYPE ServeEmbeddedFolder(OrthancPluginRestOutput* output, |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
199 const char* url, |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
200 const OrthancPluginHttpRequest* request) |
0 | 201 { |
202 if (request->method != OrthancPluginHttpMethod_Get) | |
203 { | |
204 OrthancPluginSendMethodNotAllowed(context_, output, "GET"); | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
205 return RETURN_SUCCESS; |
0 | 206 } |
207 | |
208 std::string path = "/" + std::string(request->groups[0]); | |
209 const char* mime = OrthancPlugins::GetMimeType(path); | |
210 | |
211 try | |
212 { | |
213 std::string s; | |
31 | 214 Orthanc::EmbeddedResources::GetDirectoryResource(s, folder, path.c_str()); |
0 | 215 |
216 const char* resource = s.size() ? s.c_str() : NULL; | |
217 OrthancPluginAnswerBuffer(context_, output, resource, s.size(), mime); | |
218 | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
219 return RETURN_SUCCESS; |
0 | 220 } |
221 catch (std::runtime_error&) | |
222 { | |
223 std::string s = "Unknown static resource in plugin: " + std::string(request->groups[0]); | |
224 OrthancPluginLogError(context_, s.c_str()); | |
225 OrthancPluginSendHttpStatusCode(context_, output, 404); | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
226 return RETURN_SUCCESS; |
0 | 227 } |
228 } | |
229 | |
230 | |
231 | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
232 static RETURN_TYPE IsStableSeries(OrthancPluginRestOutput* output, |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
233 const char* url, |
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
234 const OrthancPluginHttpRequest* request) |
19 | 235 { |
236 try | |
237 { | |
238 if (request->method != OrthancPluginHttpMethod_Get) | |
239 { | |
240 OrthancPluginSendMethodNotAllowed(context_, output, "GET"); | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
241 return RETURN_SUCCESS; |
19 | 242 } |
243 | |
244 const std::string id = request->groups[0]; | |
245 Json::Value series; | |
246 | |
247 if (OrthancPlugins::GetJsonFromOrthanc(series, context_, "/series/" + id) && | |
248 series.type() == Json::objectValue) | |
249 { | |
250 bool value = (series["IsStable"].asBool() || | |
251 series["Status"].asString() == "Complete"); | |
252 std::string answer = value ? "true" : "false"; | |
253 OrthancPluginAnswerBuffer(context_, output, answer.c_str(), answer.size(), "application/json"); | |
254 } | |
255 else | |
256 { | |
257 OrthancPluginSendHttpStatusCode(context_, output, 404); | |
258 } | |
259 | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
260 return RETURN_SUCCESS; |
19 | 261 } |
262 catch (Orthanc::OrthancException& e) | |
263 { | |
264 OrthancPluginLogError(context_, e.What()); | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
265 return RETURN_FAILURE; |
19 | 266 } |
267 catch (std::runtime_error& e) | |
268 { | |
269 OrthancPluginLogError(context_, e.what()); | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
270 return RETURN_FAILURE; |
19 | 271 } |
272 catch (boost::bad_lexical_cast&) | |
273 { | |
274 OrthancPluginLogError(context_, "Bad lexical cast"); | |
74
ab5218c18b7a
compatibility with forthcoming sdk 0.9.5
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
58
diff
changeset
|
275 return RETURN_FAILURE; |
19 | 276 } |
277 } | |
278 | |
0 | 279 |
280 extern "C" | |
281 { | |
282 ORTHANC_PLUGINS_API int32_t OrthancPluginInitialize(OrthancPluginContext* context) | |
283 { | |
284 using namespace OrthancPlugins; | |
285 | |
286 context_ = context; | |
287 OrthancPluginLogWarning(context_, "Initializing the Web viewer"); | |
288 | |
289 | |
290 /* Check the version of the Orthanc core */ | |
291 if (OrthancPluginCheckVersion(context_) == 0) | |
292 { | |
293 char info[1024]; | |
294 sprintf(info, "Your version of Orthanc (%s) must be above %d.%d.%d to run this plugin", | |
295 context_->orthancVersion, | |
296 ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER, | |
297 ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER, | |
298 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER); | |
299 OrthancPluginLogError(context_, info); | |
300 return -1; | |
301 } | |
302 | |
303 OrthancPluginSetDescription(context_, "Provides a Web viewer of DICOM series within Orthanc."); | |
304 | |
305 | |
306 /* By default, use half of the available processing cores for the decoding of DICOM images */ | |
307 int decodingThreads = boost::thread::hardware_concurrency() / 2; | |
308 if (decodingThreads == 0) | |
309 { | |
310 decodingThreads = 1; | |
311 } | |
312 | |
313 | |
314 try | |
315 { | |
316 /* Read the configuration of the Web viewer */ | |
317 Json::Value configuration; | |
318 if (!ReadConfiguration(configuration, context)) | |
319 { | |
320 OrthancPluginLogError(context_, "Unable to read the configuration file of Orthanc"); | |
321 return -1; | |
322 } | |
323 | |
4
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
324 // 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
|
325 // "StorageDirectory" of Orthanc |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
326 boost::filesystem::path cachePath = GetStringValue(configuration, "StorageDirectory", "."); |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
327 cachePath /= "WebViewerCache"; |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
328 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
|
329 |
0 | 330 if (configuration.isMember("WebViewer")) |
331 { | |
4
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
332 std::string key = "CachePath"; |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
333 if (!configuration["WebViewer"].isMember(key)) |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
334 { |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
335 // 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
|
336 key = "Cache"; |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
337 } |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
338 |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
339 cachePath = GetStringValue(configuration["WebViewer"], key, cachePath.string()); |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
340 cacheSize = GetIntegerValue(configuration["WebViewer"], "CacheSize", cacheSize); |
0 | 341 decodingThreads = GetIntegerValue(configuration["WebViewer"], "Threads", decodingThreads); |
342 } | |
343 | |
344 std::string message = ("Web viewer using " + boost::lexical_cast<std::string>(decodingThreads) + | |
345 " threads for the decoding of the DICOM images"); | |
346 OrthancPluginLogWarning(context_, message.c_str()); | |
347 | |
4
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
348 if (decodingThreads <= 0 || |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
349 cacheSize <= 0) |
0 | 350 { |
351 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
352 } | |
353 | |
4
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
354 message = "Storing the cache of the Web viewer in folder: " + cachePath.string(); |
0 | 355 OrthancPluginLogWarning(context_, message.c_str()); |
356 | |
357 | |
358 /* Create the cache */ | |
4
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
359 cache_ = new CacheContext(cachePath.string()); |
0 | 360 cache_->GetScheduler().RegisterPolicy(new ViewerPrefetchPolicy(context_)); |
361 cache_->GetScheduler().Register(CacheBundle_SeriesInformation, | |
362 new SeriesInformationAdapter(context_, cache_->GetScheduler()), 1); | |
363 cache_->GetScheduler().Register(CacheBundle_InstanceInformation, | |
364 new InstanceInformationAdapter(context_), 1); | |
365 cache_->GetScheduler().Register(CacheBundle_DecodedImage, | |
366 new DecodedImageAdapter(context_), decodingThreads); | |
4
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
367 |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
368 |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
369 /* Set the quotas */ |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
370 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
|
371 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
|
372 |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
373 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
|
374 OrthancPluginLogWarning(context_, message.c_str()); |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
375 |
ecefd45026bf
configuration of the cache
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
376 cache_->GetScheduler().SetQuota(CacheBundle_DecodedImage, 0, static_cast<uint64_t>(cacheSize) * 1024 * 1024); |
0 | 377 } |
378 catch (std::runtime_error& e) | |
379 { | |
380 OrthancPluginLogError(context_, e.what()); | |
381 return -1; | |
382 } | |
383 catch (Orthanc::OrthancException& e) | |
384 { | |
385 OrthancPluginLogError(context_, e.What()); | |
386 return -1; | |
387 } | |
388 | |
389 | |
390 /* Install the callbacks */ | |
391 OrthancPluginRegisterRestCallback(context_, "/web-viewer/series/(.*)", ServeCache<CacheBundle_SeriesInformation>); | |
19 | 392 OrthancPluginRegisterRestCallback(context_, "/web-viewer/is-stable-series/(.*)", IsStableSeries); |
0 | 393 OrthancPluginRegisterRestCallback(context_, "/web-viewer/instances/(.*)", ServeCache<CacheBundle_DecodedImage>); |
31 | 394 OrthancPluginRegisterRestCallback(context, "/web-viewer/libs/(.*)", ServeEmbeddedFolder<Orthanc::EmbeddedResources::JAVASCRIPT_LIBS>); |
0 | 395 |
396 #if ORTHANC_STANDALONE == 1 | |
31 | 397 OrthancPluginRegisterRestCallback(context, "/web-viewer/app/(.*)", ServeEmbeddedFolder<Orthanc::EmbeddedResources::WEB_VIEWER>); |
0 | 398 #else |
399 OrthancPluginRegisterRestCallback(context, "/web-viewer/app/(.*)", ServeWebViewer); | |
400 #endif | |
401 | |
402 OrthancPluginRegisterOnChangeCallback(context, OnChangeCallback); | |
403 | |
404 | |
405 /* Extend the default Orthanc Explorer with custom JavaScript */ | |
406 std::string explorer; | |
31 | 407 Orthanc::EmbeddedResources::GetFileResource(explorer, Orthanc::EmbeddedResources::ORTHANC_EXPLORER); |
0 | 408 OrthancPluginExtendOrthancExplorer(context_, explorer.c_str()); |
409 | |
410 return 0; | |
411 } | |
412 | |
413 | |
414 ORTHANC_PLUGINS_API void OrthancPluginFinalize() | |
415 { | |
416 OrthancPluginLogWarning(context_, "Finalizing the Web viewer"); | |
417 | |
418 if (cache_ != NULL) | |
419 { | |
420 delete cache_; | |
421 cache_ = NULL; | |
422 } | |
423 } | |
424 | |
425 | |
426 ORTHANC_PLUGINS_API const char* OrthancPluginGetName() | |
427 { | |
428 return "web-viewer"; | |
429 } | |
430 | |
431 | |
432 ORTHANC_PLUGINS_API const char* OrthancPluginGetVersion() | |
433 { | |
12 | 434 return ORTHANC_WEBVIEWER_VERSION; |
0 | 435 } |
436 } |