Mercurial > hg > orthanc-stone

comparison UnitTestsSources/SortedFramesTests.cpp @ 1478:fab6c6e795a3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Framework/Toolbox/SortedFrames.cpp
author Sebastien Jodogne <s.jodogne@gmail.com>
date Thu, 18 Jun 2020 16:01:00 +0200
parents 5732edec7cbd
children
comparison
equal deleted inserted replaced
1477:5732edec7cbd 1478:fab6c6e795a3
19 **/ 19 **/
20 20
21 21
22 #include <gtest/gtest.h> 22 #include <gtest/gtest.h>
23 23
24 #include "../Framework/Toolbox/SortedFrames.h"
25
24 #include <OrthancException.h> 26 #include <OrthancException.h>
25 #include <DicomFormat/DicomMap.h>
26
27 #include "../Framework/Toolbox/GeometryToolbox.h"
28
29 namespace OrthancStone
30 {
31 class SortedFrames : public boost::noncopyable
32 {
33 private:
34 class Instance : public boost::noncopyable
35 {
36 private:
37 bool hasPosition_;
38 Orthanc::DicomMap tags_;
39 std::string sopInstanceUid_;
40 unsigned int numberOfFrames_;
41 Vector normal_;
42 Vector position_;
43
44 public:
45 Instance(const Orthanc::DicomMap& tags)
46 {
47 tags_.Assign(tags);
48
49 if (!tags.LookupStringValue(sopInstanceUid_, Orthanc::DICOM_TAG_SOP_INSTANCE_UID, false))
50 {
51 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat);
52 }
53
54 uint32_t tmp;
55 if (tags.ParseUnsignedInteger32(tmp, Orthanc::DICOM_TAG_NUMBER_OF_FRAMES))
56 {
57 numberOfFrames_ = tmp;
58 }
59 else
60 {
61 numberOfFrames_ = 1;
62 }
63
64 hasPosition_ = (
65 LinearAlgebra::ParseVector(position_, tags, Orthanc::DICOM_TAG_IMAGE_POSITION_PATIENT) &&
66 position_.size() == 3 &&
67 GeometryToolbox::ComputeNormal(normal_, tags));
68 }
69
70 const Orthanc::DicomMap& GetTags() const
71 {
72 return tags_;
73 }
74
75 const std::string& GetSopInstanceUid() const
76 {
77 return sopInstanceUid_;
78 }
79
80 unsigned int GetNumberOfFrames() const
81 {
82 return numberOfFrames_;
83 }
84
85 bool HasPosition() const
86 {
87 return hasPosition_;
88 }
89
90 const Vector& GetNormal() const
91 {
92 if (hasPosition_)
93 {
94 return normal_;
95 }
96 else
97 {
98 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
99 }
100 }
101
102 const Vector& GetPosition() const
103 {
104 if (hasPosition_)
105 {
106 return position_;
107 }
108 else
109 {
110 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
111 }
112 }
113 };
114
115 struct Frame
116 {
117 private:
118 const Instance& instance_;
119 unsigned int frameIndex_;
120
121 public:
122 Frame(const Instance& instance,
123 unsigned int frameIndex) :
124 instance_(instance),
125 frameIndex_(frameIndex)
126 {
127 if (frameIndex >= instance.GetNumberOfFrames())
128 {
129 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
130 }
131 }
132
133 const Instance& GetInstance() const
134 {
135 return instance_;
136 }
137
138 unsigned int GetFrameIndex() const
139 {
140 return frameIndex_;
141 }
142 };
143
144 std::string studyInstanceUid_;
145 std::string seriesInstanceUid_;
146 std::vector<Instance*> instances_;
147 std::vector<Frame> frames_;
148 bool sorted_;
149
150 const Instance& GetInstance(size_t index) const
151 {
152 if (index >= instances_.size())
153 {
154 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
155 }
156 else
157 {
158 assert(instances_[index] != NULL);
159 return *instances_[index];
160 }
161 }
162
163 const Frame& GetFrame(size_t index) const
164 {
165 if (!sorted_)
166 {
167 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls,
168 "Sort() has not been called");
169 }
170 if (index >= frames_.size())
171 {
172 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
173 }
174 else
175 {
176 return frames_[index];
177 }
178 }
179
180 public:
181 SortedFrames() :
182 sorted_(true)
183 {
184 }
185
186 ~SortedFrames()
187 {
188 for (size_t i = 0; i < instances_.size(); i++)
189 {
190 assert(instances_[i] != NULL);
191 delete instances_[i];
192 }
193 }
194
195 const std::string& GetStudyInstanceUid() const
196 {
197 return studyInstanceUid_;
198 }
199
200 const std::string& GetSeriesInstanceUid() const
201 {
202 return seriesInstanceUid_;
203 }
204
205 void AddInstance(const Orthanc::DicomMap& tags)
206 {
207 std::unique_ptr<Instance> instance(new Instance(tags));
208
209 std::string studyInstanceUid, seriesInstanceUid;
210 if (!tags.LookupStringValue(studyInstanceUid, Orthanc::DICOM_TAG_STUDY_INSTANCE_UID, false) ||
211 !tags.LookupStringValue(seriesInstanceUid, Orthanc::DICOM_TAG_SERIES_INSTANCE_UID, false))
212 {
213 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat);
214 }
215
216 if (instances_.empty())
217 {
218 studyInstanceUid_ = studyInstanceUid;
219 seriesInstanceUid_ = seriesInstanceUid;
220 }
221 else
222 {
223 if (studyInstanceUid_ != studyInstanceUid ||
224 seriesInstanceUid_ != seriesInstanceUid)
225 {
226 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange,
227 "Mixing instances from different series");
228 }
229 }
230
231 instances_.push_back(instance.release());
232 sorted_ = false;
233 frames_.clear();
234 }
235
236 size_t GetInstancesCount() const
237 {
238 return instances_.size();
239 }
240
241 const Orthanc::DicomMap& GetInstanceTags(size_t index) const
242 {
243 return GetInstance(index).GetTags();
244 }
245
246 const std::string& GetSopInstanceUid(size_t index) const
247 {
248 return GetInstance(index).GetSopInstanceUid();
249 }
250
251 bool IsSorted() const
252 {
253 return sorted_;
254 }
255
256 size_t GetFramesCount() const
257 {
258 if (sorted_)
259 {
260 return frames_.size();
261 }
262 else
263 {
264 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls,
265 "Sort() has not been called");
266 }
267 }
268
269 const Orthanc::DicomMap& GetFrameTags(size_t index) const
270 {
271 return GetFrame(index).GetInstance().GetTags();
272 }
273
274 const std::string& GetFrameSopInstanceUid(size_t index) const
275 {
276 return GetFrame(index).GetInstance().GetSopInstanceUid();
277 }
278
279 const unsigned int GetFrameSiblingsCount(size_t index) const
280 {
281 return GetFrame(index).GetInstance().GetNumberOfFrames();
282 }
283
284 const unsigned int GetFrameIndex(size_t index) const
285 {
286 return GetFrame(index).GetFrameIndex();
287 }
288
289
290 void Sort()
291 {
292 if (!sorted_)
293 {
294 size_t totalFrames = 0;
295 std::set<size_t> remainingInstances;
296
297 for (size_t i = 0; i < instances_.size(); i++)
298 {
299 assert(instances_[i] != NULL);
300 totalFrames += instances_[i]->GetNumberOfFrames();
301
302 remainingInstances.insert(i);
303 }
304
305 frames_.clear();
306 frames_.reserve(totalFrames);
307
308 SortUsingIntegerTag(remainingInstances, Orthanc::DICOM_TAG_INSTANCE_NUMBER); // VR is "IS"
309 SortUsingIntegerTag(remainingInstances, Orthanc::DICOM_TAG_IMAGE_INDEX); // VR is "US"
310 SortUsing3DLocation(remainingInstances);
311 SortUsingSopInstanceUid(remainingInstances);
312
313 // The following could in theory happen if several instances
314 // have the same SOPInstanceUID, no ordering is available
315 for (std::set<size_t>::const_iterator it = remainingInstances.begin();
316 it != remainingInstances.end(); it++)
317 {
318 AddFramesOfInstance(remainingInstances, *it);
319 }
320
321 if (frames_.size() != totalFrames ||
322 !remainingInstances.empty())
323 {
324 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
325 }
326
327 sorted_ = true;
328 }
329 }
330
331
332 private:
333 void AddFramesOfInstance(std::set<size_t>& remainingInstances,
334 size_t index)
335 {
336 assert(instances_[index] != NULL);
337 const Instance& instance = *instances_[index];
338
339 for (unsigned int i = 0; i < instance.GetNumberOfFrames(); i++)
340 {
341 frames_.push_back(Frame(instance, i));
342 }
343
344 assert(remainingInstances.find(index) != remainingInstances.end());
345 remainingInstances.erase(index);
346 }
347
348
349 template<typename T>
350 class SortableItem
351 {
352 private:
353 T value_;
354 size_t instance_;
355 std::string sopInstanceUid_;
356
357 public:
358 SortableItem(const T& value,
359 size_t instance,
360 const std::string& sopInstanceUid) :
361 value_(value),
362 instance_(instance),
363 sopInstanceUid_(sopInstanceUid)
364 {
365 }
366
367 size_t GetInstanceIndex() const
368 {
369 return instance_;
370 }
371
372 bool operator< (const SortableItem& other) const
373 {
374 return (value_ < other.value_ ||
375 (value_ == other.value_ &&
376 sopInstanceUid_ < other.sopInstanceUid_));
377 }
378 };
379
380
381 void SortUsingIntegerTag(std::set<size_t>& remainingInstances,
382 const Orthanc::DicomTag& tag)
383 {
384 std::vector< SortableItem<int32_t> > items;
385 items.reserve(remainingInstances.size());
386
387 for (std::set<size_t>::const_iterator it = remainingInstances.begin();
388 it != remainingInstances.end(); ++it)
389 {
390 assert(instances_[*it] != NULL);
391 const Instance& instance = *instances_[*it];
392
393 int32_t value;
394 std::string sopInstanceUid;
395 if (instance.GetTags().ParseInteger32(value, tag) &&
396 instance.GetTags().LookupStringValue(
397 sopInstanceUid, Orthanc::DICOM_TAG_SOP_INSTANCE_UID, false))
398 {
399 items.push_back(SortableItem<int32_t>(value, *it, sopInstanceUid));
400 }
401 }
402
403 std::sort(items.begin(), items.end());
404
405 for (size_t i = 0; i < items.size(); i++)
406 {
407 AddFramesOfInstance(remainingInstances, items[i].GetInstanceIndex());
408 }
409 }
410
411
412 void SortUsingSopInstanceUid(std::set<size_t>& remainingInstances)
413 {
414 std::vector<SortableItem<int32_t> > items;
415 items.reserve(remainingInstances.size());
416
417 for (std::set<size_t>::const_iterator it = remainingInstances.begin();
418 it != remainingInstances.end(); ++it)
419 {
420 assert(instances_[*it] != NULL);
421 const Instance& instance = *instances_[*it];
422
423 std::string sopInstanceUid;
424 if (instance.GetTags().LookupStringValue(
425 sopInstanceUid, Orthanc::DICOM_TAG_SOP_INSTANCE_UID, false))
426 {
427 items.push_back(SortableItem<int32_t>(0 /* arbitrary value */, *it, sopInstanceUid));
428 }
429 }
430
431 std::sort(items.begin(), items.end());
432
433 for (size_t i = 0; i < items.size(); i++)
434 {
435 AddFramesOfInstance(remainingInstances, items[i].GetInstanceIndex());
436 }
437 }
438
439
440 void SortUsing3DLocation(std::set<size_t>& remainingInstances)
441 {
442 /**
443 * Compute the mean of the normal vectors, using the recursive
444 * formula for arithmetic means for numerical stability.
445 * https://diego.assencio.com/?index=c34d06f4f4de2375658ed41f70177d59
446 **/
447
448 Vector meanNormal;
449 LinearAlgebra::AssignVector(meanNormal, 0, 0, 0);
450
451 unsigned int n = 0;
452
453 for (std::set<size_t>::const_iterator it = remainingInstances.begin();
454 it != remainingInstances.end(); ++it)
455 {
456 assert(instances_[*it] != NULL);
457 const Instance& instance = *instances_[*it];
458
459 if (instance.HasPosition())
460 {
461 n += 1;
462 meanNormal += (instance.GetNormal() - meanNormal) / static_cast<float>(n);
463 }
464 }
465
466 std::vector<SortableItem<float> > items;
467 items.reserve(n);
468
469 for (std::set<size_t>::const_iterator it = remainingInstances.begin();
470 it != remainingInstances.end(); ++it)
471 {
472 assert(instances_[*it] != NULL);
473 const Instance& instance = *instances_[*it];
474
475 std::string sopInstanceUid;
476 if (instance.HasPosition() &&
477 instance.GetTags().LookupStringValue(
478 sopInstanceUid, Orthanc::DICOM_TAG_SOP_INSTANCE_UID, false))
479 {
480 double p = LinearAlgebra::DotProduct(meanNormal, instance.GetPosition());
481 items.push_back(SortableItem<float>(p, *it, sopInstanceUid));
482 }
483 }
484
485 assert(items.size() <= n);
486
487 std::sort(items.begin(), items.end());
488 printf(">> %d\n", items.size());
489
490 for (size_t i = 0; i < items.size(); i++)
491 {
492 AddFramesOfInstance(remainingInstances, items[i].GetInstanceIndex());
493 }
494 }
495 };
496 }
497 27
498 28
499 TEST(SortedFrames, Basic) 29 TEST(SortedFrames, Basic)
500 { 30 {
501 OrthancStone::SortedFrames f; 31 OrthancStone::SortedFrames f;