Mercurial > hg > orthanc-stone
annotate UnitTestsSources/UnitTestsMain.cpp @ 70:f73aed014bde wasm
OrthancAsynchronousWebService
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Mon, 22 May 2017 21:43:49 +0200 |
parents | 1553b67b24e5 |
children | 30c768873d47 |
rev | line source |
---|---|
20
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1 /** |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2 * Stone of Orthanc |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
4 * Department, University Hospital of Liege, Belgium |
40
7207a407bcd8
shared copyright with osimis
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
20
diff
changeset
|
5 * Copyright (C) 2017 Osimis, Belgium |
20
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
6 * |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
7 * This program is free software: you can redistribute it and/or |
47 | 8 * modify it under the terms of the GNU Affero General Public License |
9 * as published by the Free Software Foundation, either version 3 of | |
10 * the License, or (at your option) any later version. | |
20
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
11 * |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
12 * This program is distributed in the hope that it will be useful, but |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
13 * WITHOUT ANY WARRANTY; without even the implied warranty of |
47 | 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 * Affero General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Affero General Public License | |
20
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
18 * along with this program. If not, see <http://www.gnu.org/licenses/>. |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
19 **/ |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
20 |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
21 |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
22 #include "gtest/gtest.h" |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
23 |
70
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
24 #include "../Framework/Toolbox/OrthancAsynchronousWebService.h" |
20
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
25 #include "../Resources/Orthanc/Core/Logging.h" |
69
1553b67b24e5
OrthancSynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
68
diff
changeset
|
26 #include "../Framework/Toolbox/OrthancSynchronousWebService.h" |
65
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
27 #include "../Framework/Layers/OrthancFrameLayerSource.h" |
66 | 28 #include "../Framework/Widgets/LayerWidget.h" |
65
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
29 |
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
30 |
68 | 31 #include "../Resources/Orthanc/Core/Images/PngReader.h" |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
32 #include "../Framework/Toolbox/MessagingToolbox.h" |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
33 #include "../Framework/Toolbox/DicomFrameConverter.h" |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
34 |
68 | 35 #include <boost/lexical_cast.hpp> |
70
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
36 #include <boost/date_time/posix_time/posix_time.hpp> |
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
37 #include <boost/thread/thread.hpp> |
68 | 38 |
65
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
39 namespace OrthancStone |
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
40 { |
68 | 41 class Slice |
42 { | |
43 private: | |
44 enum Type | |
45 { | |
46 Type_Invalid, | |
47 Type_OrthancInstance | |
48 // TODO A slice could come from some DICOM file (URL) | |
49 }; | |
50 | |
51 Type type_; | |
52 std::string orthancInstanceId_; | |
53 unsigned int frame_; | |
54 SliceGeometry geometry_; | |
55 double pixelSpacingX_; | |
56 double pixelSpacingY_; | |
57 double thickness_; | |
58 unsigned int width_; | |
59 unsigned int height_; | |
60 DicomFrameConverter converter_; | |
61 | |
62 public: | |
63 Slice() : type_(Type_Invalid) | |
64 { | |
65 } | |
66 | |
67 bool ParseOrthancFrame(const OrthancPlugins::IDicomDataset& dataset, | |
68 const std::string& instanceId, | |
69 unsigned int frame) | |
70 { | |
71 OrthancPlugins::DicomDatasetReader reader(dataset); | |
72 | |
73 unsigned int frameCount; | |
74 if (!reader.GetUnsignedIntegerValue(frameCount, OrthancPlugins::DICOM_TAG_NUMBER_OF_FRAMES)) | |
75 { | |
76 frameCount = 1; // Assume instance with one frame | |
77 } | |
78 | |
79 if (frame >= frameCount) | |
80 { | |
81 return false; | |
82 } | |
83 | |
84 if (!reader.GetDoubleValue(thickness_, OrthancPlugins::DICOM_TAG_SLICE_THICKNESS)) | |
85 { | |
86 thickness_ = 100.0 * std::numeric_limits<double>::epsilon(); | |
87 } | |
88 | |
89 GeometryToolbox::GetPixelSpacing(pixelSpacingX_, pixelSpacingY_, dataset); | |
90 | |
91 std::string position, orientation; | |
92 if (dataset.GetStringValue(position, OrthancPlugins::DICOM_TAG_IMAGE_POSITION_PATIENT) && | |
93 dataset.GetStringValue(orientation, OrthancPlugins::DICOM_TAG_IMAGE_ORIENTATION_PATIENT) && | |
94 reader.GetUnsignedIntegerValue(width_, OrthancPlugins::DICOM_TAG_COLUMNS) && | |
95 reader.GetUnsignedIntegerValue(height_, OrthancPlugins::DICOM_TAG_ROWS)) | |
96 { | |
97 orthancInstanceId_ = instanceId; | |
98 frame_ = frame; | |
99 geometry_ = SliceGeometry(position, orientation); | |
100 converter_.ReadParameters(dataset); | |
101 | |
102 type_ = Type_OrthancInstance; | |
103 return true; | |
104 } | |
105 else | |
106 { | |
107 return false; | |
108 } | |
109 } | |
110 | |
111 bool IsOrthancInstance() const | |
112 { | |
113 return type_ == Type_OrthancInstance; | |
114 } | |
115 | |
116 const std::string GetOrthancInstanceId() const | |
117 { | |
118 if (type_ != Type_OrthancInstance) | |
119 { | |
120 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
121 } | |
122 | |
123 return orthancInstanceId_; | |
124 } | |
125 | |
126 unsigned int GetFrame() const | |
127 { | |
128 if (type_ == Type_Invalid) | |
129 { | |
130 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
131 } | |
132 | |
133 return frame_; | |
134 } | |
135 | |
136 const SliceGeometry& GetGeometry() const | |
137 { | |
138 if (type_ == Type_Invalid) | |
139 { | |
140 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
141 } | |
142 | |
143 return geometry_; | |
144 } | |
145 | |
146 double GetThickness() const | |
147 { | |
148 if (type_ == Type_Invalid) | |
149 { | |
150 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
151 } | |
152 | |
153 return thickness_; | |
154 } | |
155 | |
156 double GetPixelSpacingX() const | |
157 { | |
158 if (type_ == Type_Invalid) | |
159 { | |
160 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
161 } | |
162 | |
163 return pixelSpacingX_; | |
164 } | |
165 | |
166 double GetPixelSpacingY() const | |
167 { | |
168 if (type_ == Type_Invalid) | |
169 { | |
170 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
171 } | |
172 | |
173 return pixelSpacingY_; | |
174 } | |
175 | |
176 unsigned int GetWidth() const | |
177 { | |
178 if (type_ == Type_Invalid) | |
179 { | |
180 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
181 } | |
182 | |
183 return width_; | |
184 } | |
185 | |
186 unsigned int GetHeight() const | |
187 { | |
188 if (type_ == Type_Invalid) | |
189 { | |
190 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
191 } | |
192 | |
193 return height_; | |
194 } | |
195 | |
196 const DicomFrameConverter& GetConverter() const | |
197 { | |
198 if (type_ == Type_Invalid) | |
199 { | |
200 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
201 } | |
202 | |
203 return converter_; | |
204 } | |
205 }; | |
206 | |
207 | |
208 class SliceSorter : public boost::noncopyable | |
209 { | |
210 private: | |
211 class SliceWithDepth : public boost::noncopyable | |
212 { | |
213 private: | |
214 Slice slice_; | |
215 double depth_; | |
216 | |
217 public: | |
218 SliceWithDepth(const Slice& slice) : | |
219 slice_(slice), | |
220 depth_(0) | |
221 { | |
222 } | |
223 | |
224 void SetNormal(const Vector& normal) | |
225 { | |
226 depth_ = boost::numeric::ublas::inner_prod | |
227 (slice_.GetGeometry().GetOrigin(), normal); | |
228 } | |
229 | |
230 double GetDepth() const | |
231 { | |
232 return depth_; | |
233 } | |
234 | |
235 const Slice& GetSlice() const | |
236 { | |
237 return slice_; | |
238 } | |
239 }; | |
240 | |
241 struct Comparator | |
242 { | |
243 bool operator() (const SliceWithDepth* const& a, | |
244 const SliceWithDepth* const& b) const | |
245 { | |
246 return a->GetDepth() < b->GetDepth(); | |
247 } | |
248 }; | |
249 | |
250 typedef std::vector<SliceWithDepth*> Slices; | |
251 | |
252 Slices slices_; | |
253 bool hasNormal_; | |
254 | |
255 public: | |
256 SliceSorter() : hasNormal_(false) | |
257 { | |
258 } | |
259 | |
260 ~SliceSorter() | |
261 { | |
262 for (size_t i = 0; i < slices_.size(); i++) | |
263 { | |
264 assert(slices_[i] != NULL); | |
265 delete slices_[i]; | |
266 } | |
267 } | |
268 | |
269 void Reserve(size_t count) | |
270 { | |
271 slices_.reserve(count); | |
272 } | |
273 | |
274 void AddSlice(const Slice& slice) | |
275 { | |
276 slices_.push_back(new SliceWithDepth(slice)); | |
277 } | |
278 | |
279 size_t GetSliceCount() const | |
280 { | |
281 return slices_.size(); | |
282 } | |
283 | |
284 const Slice& GetSlice(size_t i) const | |
285 { | |
286 if (i >= slices_.size()) | |
287 { | |
288 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
289 } | |
290 | |
291 assert(slices_[i] != NULL); | |
292 return slices_[i]->GetSlice(); | |
293 } | |
294 | |
295 void SetNormal(const Vector& normal) | |
296 { | |
297 for (size_t i = 0; i < slices_.size(); i++) | |
298 { | |
299 slices_[i]->SetNormal(normal); | |
300 } | |
301 | |
302 hasNormal_ = true; | |
303 } | |
304 | |
305 void Sort() | |
306 { | |
307 if (!hasNormal_) | |
308 { | |
309 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
310 } | |
311 | |
312 Comparator comparator; | |
313 std::sort(slices_.begin(), slices_.end(), comparator); | |
314 } | |
315 | |
316 void FilterNormal(const Vector& normal) | |
317 { | |
318 size_t pos = 0; | |
319 | |
320 for (size_t i = 0; i < slices_.size(); i++) | |
321 { | |
322 if (GeometryToolbox::IsParallel(normal, slices_[i]->GetSlice().GetGeometry().GetNormal())) | |
323 { | |
324 // This slice is compatible with the selected normal | |
325 slices_[pos] = slices_[i]; | |
326 pos += 1; | |
327 } | |
328 else | |
329 { | |
330 delete slices_[i]; | |
331 slices_[i] = NULL; | |
332 } | |
333 } | |
334 | |
335 slices_.resize(pos); | |
336 } | |
337 | |
338 bool SelectNormal(Vector& normal) const | |
339 { | |
340 std::vector<Vector> normalCandidates; | |
341 std::vector<unsigned int> normalCount; | |
342 | |
343 bool found = false; | |
344 | |
345 for (size_t i = 0; !found && i < GetSliceCount(); i++) | |
346 { | |
347 const Vector& normal = GetSlice(i).GetGeometry().GetNormal(); | |
348 | |
349 bool add = true; | |
350 for (size_t j = 0; add && j < normalCandidates.size(); j++) // (*) | |
351 { | |
352 if (GeometryToolbox::IsParallel(normal, normalCandidates[j])) | |
353 { | |
354 normalCount[j] += 1; | |
355 add = false; | |
356 } | |
357 } | |
358 | |
359 if (add) | |
360 { | |
361 if (normalCount.size() > 2) | |
362 { | |
363 // To get linear-time complexity in (*). This heuristics | |
364 // allows the series to have one single frame that is | |
365 // not parallel to the others (such a frame could be a | |
366 // generated preview) | |
367 found = false; | |
368 } | |
369 else | |
370 { | |
371 normalCandidates.push_back(normal); | |
372 normalCount.push_back(1); | |
373 } | |
374 } | |
375 } | |
376 | |
377 for (size_t i = 0; !found && i < normalCandidates.size(); i++) | |
378 { | |
379 unsigned int count = normalCount[i]; | |
380 if (count == GetSliceCount() || | |
381 count + 1 == GetSliceCount()) | |
382 { | |
383 normal = normalCandidates[i]; | |
384 found = true; | |
385 } | |
386 } | |
387 | |
388 return found; | |
389 } | |
390 }; | |
391 | |
392 | |
393 | |
394 class OrthancSliceLoader : | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
395 public IWebService::ICallback // TODO move to PImpl |
66 | 396 { |
397 public: | |
398 class ICallback : public boost::noncopyable | |
399 { | |
400 public: | |
401 virtual ~ICallback() | |
402 { | |
403 } | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
404 |
70
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
405 virtual void NotifyGeometryReady(OrthancSliceLoader& loader) = 0; |
68 | 406 |
70
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
407 virtual void NotifyGeometryError(OrthancSliceLoader& loader) = 0; |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
408 |
70
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
409 virtual void NotifySliceImageReady(OrthancSliceLoader& loader, |
68 | 410 unsigned int sliceIndex, |
411 const Slice& slice, | |
412 Orthanc::ImageAccessor* image) = 0; | |
413 | |
70
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
414 virtual void NotifySliceImageError(OrthancSliceLoader& loader, |
68 | 415 unsigned int sliceIndex, |
416 const Slice& slice) = 0; | |
66 | 417 }; |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
418 |
66 | 419 private: |
68 | 420 enum State |
66 | 421 { |
68 | 422 State_Error, |
423 State_Initialization, | |
424 State_LoadingGeometry, | |
425 State_GeometryReady | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
426 }; |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
427 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
428 enum Mode |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
429 { |
68 | 430 Mode_SeriesGeometry, |
431 Mode_LoadImage | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
432 }; |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
433 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
434 class Operation : public Orthanc::IDynamicObject |
66 | 435 { |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
436 private: |
68 | 437 Mode mode_; |
438 unsigned int sliceIndex_; | |
439 const Slice* slice_; | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
440 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
441 Operation(Mode mode) : |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
442 mode_(mode) |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
443 { |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
444 } |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
445 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
446 public: |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
447 Mode GetMode() const |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
448 { |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
449 return mode_; |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
450 } |
68 | 451 |
452 unsigned int GetSliceIndex() const | |
453 { | |
454 assert(mode_ == Mode_LoadImage); | |
455 return sliceIndex_; | |
456 } | |
457 | |
458 const Slice& GetSlice() const | |
459 { | |
460 assert(mode_ == Mode_LoadImage && slice_ != NULL); | |
461 return *slice_; | |
462 } | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
463 |
68 | 464 static Operation* DownloadSeriesGeometry() |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
465 { |
68 | 466 return new Operation(Mode_SeriesGeometry); |
467 } | |
468 | |
469 static Operation* DownloadSliceImage(unsigned int sliceIndex, | |
470 const Slice& slice) | |
471 { | |
472 std::auto_ptr<Operation> tmp(new Operation(Mode_LoadImage)); | |
473 tmp->sliceIndex_ = sliceIndex; | |
474 tmp->slice_ = &slice; | |
475 return tmp.release(); | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
476 } |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
477 }; |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
478 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
479 ICallback& callback_; |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
480 IWebService& orthanc_; |
68 | 481 State state_; |
482 SliceSorter slices_; | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
483 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
484 |
68 | 485 void ParseSeriesGeometry(const void* answer, |
486 size_t size) | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
487 { |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
488 Json::Value series; |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
489 if (!MessagingToolbox::ParseJson(series, answer, size) || |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
490 series.type() != Json::objectValue) |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
491 { |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
492 callback_.NotifyGeometryError(*this); |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
493 return; |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
494 } |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
495 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
496 Json::Value::Members instances = series.getMemberNames(); |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
497 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
498 slices_.Reserve(instances.size()); |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
499 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
500 for (size_t i = 0; i < instances.size(); i++) |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
501 { |
68 | 502 OrthancPlugins::FullOrthancDataset dataset(series[instances[i]]); |
503 | |
504 Slice slice; | |
505 if (slice.ParseOrthancFrame(dataset, instances[i], 0 /* todo */)) | |
506 { | |
507 slices_.AddSlice(slice); | |
508 } | |
509 else | |
510 { | |
511 LOG(WARNING) << "Skipping invalid instance " << instances[i]; | |
512 } | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
513 } |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
514 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
515 bool ok = false; |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
516 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
517 if (slices_.GetSliceCount() > 0) |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
518 { |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
519 Vector normal; |
68 | 520 if (slices_.SelectNormal(normal)) |
521 { | |
522 slices_.FilterNormal(normal); | |
523 slices_.SetNormal(normal); | |
524 slices_.Sort(); | |
525 ok = true; | |
526 } | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
527 } |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
528 |
70
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
529 state_ = State_GeometryReady; |
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
530 |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
531 if (ok) |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
532 { |
68 | 533 LOG(INFO) << "Loaded a series with " << slices_.GetSliceCount() << " slice(s)"; |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
534 callback_.NotifyGeometryReady(*this); |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
535 } |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
536 else |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
537 { |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
538 LOG(ERROR) << "This series is empty"; |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
539 callback_.NotifyGeometryError(*this); |
68 | 540 } |
541 } | |
542 | |
543 | |
544 void ParseSliceImage(const Operation& operation, | |
545 const void* answer, | |
546 size_t size) | |
547 { | |
548 std::auto_ptr<Orthanc::PngReader> image(new Orthanc::PngReader); | |
549 image->ReadFromMemory(answer, size); | |
550 | |
551 bool ok = (image->GetWidth() == operation.GetSlice().GetWidth() || | |
552 image->GetHeight() == operation.GetSlice().GetHeight()); | |
553 | |
554 if (ok && | |
555 operation.GetSlice().GetConverter().GetExpectedPixelFormat() == | |
556 Orthanc::PixelFormat_SignedGrayscale16) | |
557 { | |
558 if (image->GetFormat() == Orthanc::PixelFormat_Grayscale16) | |
559 { | |
560 image->SetFormat(Orthanc::PixelFormat_SignedGrayscale16); | |
561 } | |
562 else | |
563 { | |
564 ok = false; | |
565 } | |
566 } | |
567 | |
568 if (ok) | |
569 { | |
570 callback_.NotifySliceImageReady(*this, operation.GetSliceIndex(), | |
571 operation.GetSlice(), image.release()); | |
572 } | |
573 else | |
574 { | |
575 callback_.NotifySliceImageError(*this, operation.GetSliceIndex(), | |
576 operation.GetSlice()); | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
577 } |
66 | 578 } |
579 | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
580 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
581 public: |
68 | 582 OrthancSliceLoader(ICallback& callback, |
583 IWebService& orthanc) : | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
584 callback_(callback), |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
585 orthanc_(orthanc), |
68 | 586 state_(State_Initialization) |
587 { | |
588 } | |
589 | |
590 void ScheduleLoadSeries(const std::string& seriesId) | |
66 | 591 { |
68 | 592 if (state_ != State_Initialization) |
593 { | |
594 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
595 } | |
596 else | |
597 { | |
598 state_ = State_LoadingGeometry; | |
599 std::string uri = "/series/" + seriesId + "/instances-tags"; | |
600 orthanc_.ScheduleGetRequest(*this, uri, Operation::DownloadSeriesGeometry()); | |
601 } | |
602 } | |
603 | |
604 size_t GetSliceCount() const | |
605 { | |
606 if (state_ != State_GeometryReady) | |
607 { | |
608 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
609 } | |
610 | |
611 return slices_.GetSliceCount(); | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
612 } |
66 | 613 |
68 | 614 const Slice& GetSlice(size_t index) const |
615 { | |
616 if (state_ != State_GeometryReady) | |
617 { | |
618 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
619 } | |
620 | |
621 return slices_.GetSlice(index); | |
622 } | |
623 | |
624 void ScheduleLoadSliceImage(size_t index) | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
625 { |
68 | 626 if (state_ != State_GeometryReady) |
627 { | |
628 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
629 } | |
630 else | |
631 { | |
632 const Slice& slice = GetSlice(index); | |
633 | |
634 std::string uri = ("/instances/" + slice.GetOrthancInstanceId() + "/frames/" + | |
635 boost::lexical_cast<std::string>(slice.GetFrame())); | |
636 | |
637 switch (slice.GetConverter().GetExpectedPixelFormat()) | |
638 { | |
639 case Orthanc::PixelFormat_RGB24: | |
640 uri += "/preview"; | |
641 break; | |
642 | |
643 case Orthanc::PixelFormat_Grayscale16: | |
644 uri += "/image-uint16"; | |
645 break; | |
646 | |
647 case Orthanc::PixelFormat_SignedGrayscale16: | |
648 uri += "/image-int16"; | |
649 break; | |
650 | |
651 default: | |
652 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
653 } | |
654 | |
655 orthanc_.ScheduleGetRequest(*this, uri, Operation::DownloadSliceImage(index, slice)); | |
656 } | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
657 } |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
658 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
659 virtual void NotifySuccess(const std::string& uri, |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
660 const void* answer, |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
661 size_t answerSize, |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
662 Orthanc::IDynamicObject* payload) |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
663 { |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
664 std::auto_ptr<Operation> operation(dynamic_cast<Operation*>(payload)); |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
665 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
666 switch (operation->GetMode()) |
66 | 667 { |
68 | 668 case Mode_SeriesGeometry: |
669 ParseSeriesGeometry(answer, answerSize); | |
670 break; | |
671 | |
672 case Mode_LoadImage: | |
673 ParseSliceImage(*operation, answer, answerSize); | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
674 break; |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
675 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
676 default: |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
677 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); |
66 | 678 } |
679 } | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
680 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
681 virtual void NotifyError(const std::string& uri, |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
682 Orthanc::IDynamicObject* payload) |
66 | 683 { |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
684 std::auto_ptr<Operation> operation(dynamic_cast<Operation*>(payload)); |
66 | 685 LOG(ERROR) << "Cannot download " << uri; |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
686 |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
687 switch (operation->GetMode()) |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
688 { |
68 | 689 case Mode_SeriesGeometry: |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
690 callback_.NotifyGeometryError(*this); |
68 | 691 state_ = State_Error; |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
692 break; |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
693 |
68 | 694 case Mode_LoadImage: |
695 callback_.NotifySliceImageError(*this, operation->GetSliceIndex(), operation->GetSlice()); | |
696 break; | |
697 | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
698 default: |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
699 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
700 } |
66 | 701 } |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
702 }; |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
703 |
66 | 704 |
68 | 705 class Tata : public OrthancSliceLoader::ICallback |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
706 { |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
707 public: |
70
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
708 virtual void NotifyGeometryReady(OrthancSliceLoader& loader) |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
709 { |
70
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
710 printf(">> %d\n", loader.GetSliceCount()); |
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
711 |
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
712 for (size_t i = 0; i < loader.GetSliceCount(); i++) |
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
713 { |
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
714 loader.ScheduleLoadSliceImage(i); |
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
715 } |
68 | 716 } |
717 | |
70
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
718 virtual void NotifyGeometryError(OrthancSliceLoader& loader) |
68 | 719 { |
720 printf("Error\n"); | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
721 } |
66 | 722 |
70
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
723 virtual void NotifySliceImageReady(OrthancSliceLoader& loader, |
68 | 724 unsigned int sliceIndex, |
725 const Slice& slice, | |
726 Orthanc::ImageAccessor* image) | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
727 { |
68 | 728 std::auto_ptr<Orthanc::ImageAccessor> tmp(image); |
70
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
729 printf("Slice OK %dx%d\n", tmp->GetWidth(), tmp->GetHeight()); |
68 | 730 } |
731 | |
70
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
732 virtual void NotifySliceImageError(OrthancSliceLoader& loader, |
68 | 733 unsigned int sliceIndex, |
734 const Slice& slice) | |
735 { | |
736 printf("ERROR 2\n"); | |
67
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
737 } |
acb60cbb8301
refactoring SeriesLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
738 }; |
65
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
739 } |
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
740 |
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
741 |
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
742 TEST(Toto, Tutu) |
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
743 { |
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
744 Orthanc::WebServiceParameters web; |
70
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
745 OrthancStone::OrthancAsynchronousWebService orthanc(web, 4); |
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
746 orthanc.Start(); |
65
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
747 |
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
748 OrthancStone::Tata tata; |
68 | 749 OrthancStone::OrthancSliceLoader loader(tata, orthanc); |
750 //loader.ScheduleLoadSeries("c1c4cb95-05e3bd11-8da9f5bb-87278f71-0b2b43f5"); | |
751 loader.ScheduleLoadSeries("67f1b334-02c16752-45026e40-a5b60b6b-030ecab5"); | |
752 | |
70
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
753 /*printf(">> %d\n", loader.GetSliceCount()); |
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
754 loader.ScheduleLoadSliceImage(31);*/ |
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
755 |
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
756 boost::this_thread::sleep(boost::posix_time::milliseconds(1000)); |
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
757 |
f73aed014bde
OrthancAsynchronousWebService
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
69
diff
changeset
|
758 orthanc.Stop(); |
65
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
759 } |
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
760 |
885932a893de
OrthancFrameLayerSource
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
761 |
20
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
762 |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
763 int main(int argc, char **argv) |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
764 { |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
765 Orthanc::Logging::Initialize(); |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
766 Orthanc::Logging::EnableInfoLevel(true); |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
767 |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
768 ::testing::InitGoogleTest(&argc, argv); |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
769 int result = RUN_ALL_TESTS(); |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
770 |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
771 Orthanc::Logging::Finalize(); |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
772 |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
773 return result; |
946377d1c992
skeleton for unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
774 } |