|
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 General Public License as
|
|
|
8 * published by the Free Software Foundation, either version 3 of the
|
|
|
9 * License, or (at your option) any later version.
|
|
|
10 *
|
|
|
11 * In addition, as a special exception, the copyright holders of this
|
|
|
12 * program give permission to link the code of its release with the
|
|
|
13 * OpenSSL project's "OpenSSL" library (or with modified versions of it
|
|
|
14 * that use the same license as the "OpenSSL" library), and distribute
|
|
|
15 * the linked executables. You must obey the GNU General Public License
|
|
|
16 * in all respects for all of the code used other than "OpenSSL". If you
|
|
|
17 * modify file(s) with this exception, you may extend this exception to
|
|
|
18 * your version of the file(s), but you are not obligated to do so. If
|
|
|
19 * you do not wish to do so, delete this exception statement from your
|
|
|
20 * version. If you delete this exception statement from all source files
|
|
|
21 * in the program, then also delete it here.
|
|
|
22 *
|
|
|
23 * This program is distributed in the hope that it will be useful, but
|
|
|
24 * WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
26 * General Public License for more details.
|
|
|
27 *
|
|
|
28 * You should have received a copy of the GNU General Public License
|
|
|
29 * along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
30 **/
|
|
|
31
|
|
|
32
|
|
|
33 #include "Series.h"
|
|
|
34
|
|
|
35 #include "OrthancConnection.h"
|
|
|
36
|
|
|
37 #include <set>
|
|
|
38 #include <boost/lexical_cast.hpp>
|
|
|
39
|
|
|
40 namespace OrthancClient
|
|
|
41 {
|
|
|
42 namespace
|
|
|
43 {
|
|
|
44 class SliceLocator
|
|
|
45 {
|
|
|
46 private:
|
|
|
47 float normal_[3];
|
|
|
48
|
|
|
49 public:
|
|
|
50 SliceLocator(Instance& someSlice)
|
|
|
51 {
|
|
|
52 /**
|
|
|
53 * Compute the slice normal from Image Orientation Patient.
|
|
|
54 * http://nipy.sourceforge.net/nibabel/dicom/dicom_orientation.html#dicom-z-from-slice
|
|
|
55 * http://dicomiseasy.blogspot.be/2013/06/getting-oriented-using-image-plane.html
|
|
|
56 * http://www.itk.org/pipermail/insight-users/2003-September/004762.html
|
|
|
57 **/
|
|
|
58
|
|
|
59 std::vector<float> cosines;
|
|
|
60 someSlice.SplitVectorOfFloats(cosines, "ImageOrientationPatient"); // 0020-0037
|
|
|
61
|
|
|
62 if (cosines.size() != 6)
|
|
|
63 {
|
|
|
64 throw OrthancClientException(Orthanc::ErrorCode_BadFileFormat);
|
|
|
65 }
|
|
|
66
|
|
|
67 normal_[0] = cosines[1] * cosines[5] - cosines[2] * cosines[4];
|
|
|
68 normal_[1] = cosines[2] * cosines[3] - cosines[0] * cosines[5];
|
|
|
69 normal_[2] = cosines[0] * cosines[4] - cosines[1] * cosines[3];
|
|
|
70 }
|
|
|
71
|
|
|
72
|
|
|
73 /**
|
|
|
74 * Compute the distance of some slice along the slice normal.
|
|
|
75 **/
|
|
|
76 float ComputeSliceLocation(Instance& instance) const
|
|
|
77 {
|
|
|
78 std::vector<float> ipp;
|
|
|
79 instance.SplitVectorOfFloats(ipp, "ImagePositionPatient"); // 0020-0032
|
|
|
80 if (ipp.size() != 3)
|
|
|
81 {
|
|
|
82 throw OrthancClientException(Orthanc::ErrorCode_BadFileFormat);
|
|
|
83 }
|
|
|
84
|
|
|
85 float dist = 0;
|
|
|
86
|
|
|
87 for (int i = 0; i < 3; i++)
|
|
|
88 {
|
|
|
89 dist += normal_[i] * ipp[i];
|
|
|
90 }
|
|
|
91
|
|
|
92 return dist;
|
|
|
93 }
|
|
|
94 };
|
|
|
95
|
|
|
96 class ImageDownloadCommand : public Orthanc::ICommand
|
|
|
97 {
|
|
|
98 private:
|
|
|
99 Orthanc::PixelFormat format_;
|
|
|
100 Orthanc::ImageExtractionMode mode_;
|
|
|
101 Instance& instance_;
|
|
|
102 void* target_;
|
|
|
103 size_t lineStride_;
|
|
|
104
|
|
|
105 public:
|
|
|
106 ImageDownloadCommand(Instance& instance,
|
|
|
107 Orthanc::PixelFormat format,
|
|
|
108 Orthanc::ImageExtractionMode mode,
|
|
|
109 void* target,
|
|
|
110 size_t lineStride) :
|
|
|
111 format_(format),
|
|
|
112 mode_(mode),
|
|
|
113 instance_(instance),
|
|
|
114 target_(target),
|
|
|
115 lineStride_(lineStride)
|
|
|
116 {
|
|
|
117 instance_.SetImageExtractionMode(mode);
|
|
|
118 }
|
|
|
119
|
|
|
120 virtual bool Execute()
|
|
|
121 {
|
|
|
122 using namespace Orthanc;
|
|
|
123
|
|
|
124 unsigned int width = instance_.GetHeight();
|
|
|
125
|
|
|
126 for (unsigned int y = 0; y < instance_.GetHeight(); y++)
|
|
|
127 {
|
|
|
128 uint8_t* p = reinterpret_cast<uint8_t*>(target_) + y * lineStride_;
|
|
|
129
|
|
|
130 if (instance_.GetPixelFormat() == format_)
|
|
|
131 {
|
|
|
132 memcpy(p, instance_.GetBuffer(y), GetBytesPerPixel(instance_.GetPixelFormat()) * instance_.GetWidth());
|
|
|
133 }
|
|
|
134 else if (instance_.GetPixelFormat() == PixelFormat_Grayscale8 &&
|
|
|
135 format_ == PixelFormat_RGB24)
|
|
|
136 {
|
|
|
137 const uint8_t* s = reinterpret_cast<const uint8_t*>(instance_.GetBuffer(y));
|
|
|
138 for (unsigned int x = 0; x < width; x++, s++, p += 3)
|
|
|
139 {
|
|
|
140 p[0] = *s;
|
|
|
141 p[1] = *s;
|
|
|
142 p[2] = *s;
|
|
|
143 }
|
|
|
144 }
|
|
|
145 else
|
|
|
146 {
|
|
|
147 throw OrthancClientException(ErrorCode_NotImplemented);
|
|
|
148 }
|
|
|
149 }
|
|
|
150
|
|
|
151 // Do not keep the image in memory, as we are loading 3D images
|
|
|
152 instance_.DiscardImage();
|
|
|
153
|
|
|
154 return true;
|
|
|
155 }
|
|
|
156 };
|
|
|
157
|
|
|
158
|
|
|
159 class ProgressToFloatListener : public Orthanc::ThreadedCommandProcessor::IListener
|
|
|
160 {
|
|
|
161 private:
|
|
|
162 float* target_;
|
|
|
163
|
|
|
164 public:
|
|
|
165 ProgressToFloatListener(float* target) : target_(target)
|
|
|
166 {
|
|
|
167 }
|
|
|
168
|
|
|
169 virtual void SignalProgress(unsigned int current,
|
|
|
170 unsigned int total)
|
|
|
171 {
|
|
|
172 if (total == 0)
|
|
|
173 {
|
|
|
174 *target_ = 0;
|
|
|
175 }
|
|
|
176 else
|
|
|
177 {
|
|
|
178 *target_ = static_cast<float>(current) / static_cast<float>(total);
|
|
|
179 }
|
|
|
180 }
|
|
|
181
|
|
|
182 virtual void SignalSuccess(unsigned int total)
|
|
|
183 {
|
|
|
184 *target_ = 1;
|
|
|
185 }
|
|
|
186
|
|
|
187 virtual void SignalFailure()
|
|
|
188 {
|
|
|
189 *target_ = 0;
|
|
|
190 }
|
|
|
191
|
|
|
192 virtual void SignalCancel()
|
|
|
193 {
|
|
|
194 *target_ = 0;
|
|
|
195 }
|
|
|
196 };
|
|
|
197
|
|
|
198 }
|
|
|
199
|
|
|
200
|
|
|
201 void Series::Check3DImage()
|
|
|
202 {
|
|
|
203 if (!Is3DImage())
|
|
|
204 {
|
|
|
205 throw OrthancClientException(Orthanc::ErrorCode_NotImplemented);
|
|
|
206 }
|
|
|
207 }
|
|
|
208
|
|
|
209 bool Series::Is3DImageInternal()
|
|
|
210 {
|
|
|
211 try
|
|
|
212 {
|
|
|
213 if (GetInstanceCount() == 0)
|
|
|
214 {
|
|
|
215 // Empty image, use some default value (should never happen)
|
|
|
216 voxelSizeX_ = 1;
|
|
|
217 voxelSizeY_ = 1;
|
|
|
218 voxelSizeZ_ = 1;
|
|
|
219 sliceThickness_ = 1;
|
|
|
220
|
|
|
221 return true;
|
|
|
222 }
|
|
|
223
|
|
|
224 // Choose a reference slice
|
|
|
225 Instance& reference = GetInstance(0);
|
|
|
226
|
|
|
227 // Check that all the child instances share the same 3D parameters
|
|
|
228 for (unsigned int i = 0; i < GetInstanceCount(); i++)
|
|
|
229 {
|
|
|
230 Instance& i2 = GetInstance(i);
|
|
|
231
|
|
|
232 if (std::string(reference.GetTagAsString("Columns")) != std::string(i2.GetTagAsString("Columns")) ||
|
|
|
233 std::string(reference.GetTagAsString("Rows")) != std::string(i2.GetTagAsString("Rows")) ||
|
|
|
234 std::string(reference.GetTagAsString("ImageOrientationPatient")) != std::string(i2.GetTagAsString("ImageOrientationPatient")) ||
|
|
|
235 std::string(reference.GetTagAsString("SliceThickness")) != std::string(i2.GetTagAsString("SliceThickness")) ||
|
|
|
236 std::string(reference.GetTagAsString("PixelSpacing")) != std::string(i2.GetTagAsString("PixelSpacing")))
|
|
|
237 {
|
|
|
238 return false;
|
|
|
239 }
|
|
|
240 }
|
|
|
241
|
|
|
242
|
|
|
243 // Extract X/Y voxel size and slice thickness
|
|
|
244 std::string s = GetInstance(0).GetTagAsString("PixelSpacing"); // 0028-0030
|
|
|
245 size_t pos = s.find('\\');
|
|
|
246 assert(pos != std::string::npos);
|
|
|
247 std::string sy = s.substr(0, pos);
|
|
|
248 std::string sx = s.substr(pos + 1);
|
|
|
249
|
|
|
250 try
|
|
|
251 {
|
|
|
252 voxelSizeX_ = boost::lexical_cast<float>(sx);
|
|
|
253 voxelSizeY_ = boost::lexical_cast<float>(sy);
|
|
|
254 }
|
|
|
255 catch (boost::bad_lexical_cast)
|
|
|
256 {
|
|
|
257 throw OrthancClientException(Orthanc::ErrorCode_BadFileFormat);
|
|
|
258 }
|
|
|
259
|
|
|
260 sliceThickness_ = GetInstance(0).GetTagAsFloat("SliceThickness"); // 0018-0050
|
|
|
261
|
|
|
262
|
|
|
263 // Compute the location of each slice to extract the voxel size along Z
|
|
|
264 voxelSizeZ_ = std::numeric_limits<float>::infinity();
|
|
|
265
|
|
|
266 SliceLocator locator(reference);
|
|
|
267 float referenceSliceLocation = locator.ComputeSliceLocation(reference);
|
|
|
268
|
|
|
269 std::set<float> l;
|
|
|
270 for (unsigned int i = 0; i < GetInstanceCount(); i++)
|
|
|
271 {
|
|
|
272 float location = locator.ComputeSliceLocation(GetInstance(i));
|
|
|
273 float distanceToReferenceSlice = fabs(location - referenceSliceLocation);
|
|
|
274
|
|
|
275 l.insert(location);
|
|
|
276
|
|
|
277 if (distanceToReferenceSlice > std::numeric_limits<float>::epsilon() &&
|
|
|
278 distanceToReferenceSlice < voxelSizeZ_)
|
|
|
279 {
|
|
|
280 voxelSizeZ_ = distanceToReferenceSlice;
|
|
|
281 }
|
|
|
282 }
|
|
|
283
|
|
|
284
|
|
|
285 // Make sure that 2 slices do not share the same Z location
|
|
|
286 return l.size() == GetInstanceCount();
|
|
|
287 }
|
|
|
288 catch (OrthancClientException)
|
|
|
289 {
|
|
|
290 return false;
|
|
|
291 }
|
|
|
292 }
|
|
|
293
|
|
|
294 void Series::ReadSeries()
|
|
|
295 {
|
|
|
296 Orthanc::HttpClient client(connection_.GetHttpClient());
|
|
|
297
|
|
|
298 client.SetUrl(std::string(connection_.GetOrthancUrl()) + "/series/" + id_);
|
|
|
299 Json::Value v;
|
|
|
300 if (!client.Apply(series_))
|
|
|
301 {
|
|
|
302 throw OrthancClientException(Orthanc::ErrorCode_NetworkProtocol);
|
|
|
303 }
|
|
|
304 }
|
|
|
305
|
|
|
306 Orthanc::IDynamicObject* Series::GetFillerItem(size_t index)
|
|
|
307 {
|
|
|
308 Json::Value::ArrayIndex tmp = static_cast<Json::Value::ArrayIndex>(index);
|
|
|
309 std::string id = series_["Instances"][tmp].asString();
|
|
|
310 return new Instance(connection_, id.c_str());
|
|
|
311 }
|
|
|
312
|
|
|
313 Series::Series(const OrthancConnection& connection,
|
|
|
314 const char* id) :
|
|
|
315 connection_(connection),
|
|
|
316 id_(id),
|
|
|
317 instances_(*this)
|
|
|
318 {
|
|
|
319 ReadSeries();
|
|
|
320 status_ = Status3DImage_NotTested;
|
|
|
321 url_ = std::string(connection_.GetOrthancUrl()) + "/series/" + id_;
|
|
|
322
|
|
|
323 voxelSizeX_ = 0;
|
|
|
324 voxelSizeY_ = 0;
|
|
|
325 voxelSizeZ_ = 0;
|
|
|
326 sliceThickness_ = 0;
|
|
|
327
|
|
|
328 instances_.SetThreadCount(connection.GetThreadCount());
|
|
|
329 }
|
|
|
330
|
|
|
331
|
|
|
332 bool Series::Is3DImage()
|
|
|
333 {
|
|
|
334 if (status_ == Status3DImage_NotTested)
|
|
|
335 {
|
|
|
336 status_ = Is3DImageInternal() ? Status3DImage_True : Status3DImage_False;
|
|
|
337 }
|
|
|
338
|
|
|
339 return status_ == Status3DImage_True;
|
|
|
340 }
|
|
|
341
|
|
|
342 unsigned int Series::GetInstanceCount()
|
|
|
343 {
|
|
|
344 return instances_.GetSize();
|
|
|
345 }
|
|
|
346
|
|
|
347 Instance& Series::GetInstance(unsigned int index)
|
|
|
348 {
|
|
|
349 return dynamic_cast<Instance&>(instances_.GetItem(index));
|
|
|
350 }
|
|
|
351
|
|
|
352 unsigned int Series::GetWidth()
|
|
|
353 {
|
|
|
354 Check3DImage();
|
|
|
355
|
|
|
356 if (GetInstanceCount() == 0)
|
|
|
357 return 0;
|
|
|
358 else
|
|
|
359 return GetInstance(0).GetTagAsInt("Columns");
|
|
|
360 }
|
|
|
361
|
|
|
362 unsigned int Series::GetHeight()
|
|
|
363 {
|
|
|
364 Check3DImage();
|
|
|
365
|
|
|
366 if (GetInstanceCount() == 0)
|
|
|
367 return 0;
|
|
|
368 else
|
|
|
369 return GetInstance(0).GetTagAsInt("Rows");
|
|
|
370 }
|
|
|
371
|
|
|
372 const char* Series::GetMainDicomTag(const char* tag, const char* defaultValue) const
|
|
|
373 {
|
|
|
374 if (series_["MainDicomTags"].isMember(tag))
|
|
|
375 {
|
|
|
376 return series_["MainDicomTags"][tag].asCString();
|
|
|
377 }
|
|
|
378 else
|
|
|
379 {
|
|
|
380 return defaultValue;
|
|
|
381 }
|
|
|
382 }
|
|
|
383
|
|
|
384
|
|
|
385
|
|
|
386 void Series::Load3DImageInternal(void* target,
|
|
|
387 Orthanc::PixelFormat format,
|
|
|
388 size_t lineStride,
|
|
|
389 size_t stackStride,
|
|
|
390 Orthanc::ThreadedCommandProcessor::IListener* listener)
|
|
|
391 {
|
|
|
392 using namespace Orthanc;
|
|
|
393
|
|
|
394 // Choose the extraction mode, depending on the format of the
|
|
|
395 // target image.
|
|
|
396
|
|
|
397 uint8_t bytesPerPixel;
|
|
|
398 ImageExtractionMode mode;
|
|
|
399
|
|
|
400 switch (format)
|
|
|
401 {
|
|
|
402 case PixelFormat_RGB24:
|
|
|
403 bytesPerPixel = 3;
|
|
|
404 mode = ImageExtractionMode_Preview;
|
|
|
405 break;
|
|
|
406
|
|
|
407 case PixelFormat_Grayscale8:
|
|
|
408 bytesPerPixel = 1;
|
|
|
409 mode = ImageExtractionMode_UInt8; // Preview ???
|
|
|
410 break;
|
|
|
411
|
|
|
412 case PixelFormat_Grayscale16:
|
|
|
413 bytesPerPixel = 2;
|
|
|
414 mode = ImageExtractionMode_UInt16;
|
|
|
415 break;
|
|
|
416
|
|
|
417 case PixelFormat_SignedGrayscale16:
|
|
|
418 bytesPerPixel = 2;
|
|
|
419 mode = ImageExtractionMode_UInt16;
|
|
|
420 format = PixelFormat_Grayscale16;
|
|
|
421 break;
|
|
|
422
|
|
|
423 default:
|
|
|
424 throw OrthancClientException(ErrorCode_NotImplemented);
|
|
|
425 }
|
|
|
426
|
|
|
427
|
|
|
428 // Check that the target image is properly sized
|
|
|
429 unsigned int sx = GetWidth();
|
|
|
430 unsigned int sy = GetHeight();
|
|
|
431
|
|
|
432 if (lineStride < sx * bytesPerPixel ||
|
|
|
433 stackStride < sx * sy * bytesPerPixel)
|
|
|
434 {
|
|
|
435 throw OrthancClientException(ErrorCode_BadRequest);
|
|
|
436 }
|
|
|
437
|
|
|
438 if (sx == 0 || sy == 0 || GetInstanceCount() == 0)
|
|
|
439 {
|
|
|
440 // Empty image, nothing to do
|
|
|
441 if (listener)
|
|
|
442 listener->SignalSuccess(0);
|
|
|
443 return;
|
|
|
444 }
|
|
|
445
|
|
|
446
|
|
|
447 /**
|
|
|
448 * Order the stacks according to their distance along the slice
|
|
|
449 * normal (using the "Image Position Patient" tag). This works
|
|
|
450 * even if the "SliceLocation" tag is absent.
|
|
|
451 **/
|
|
|
452 SliceLocator locator(GetInstance(0));
|
|
|
453
|
|
|
454 typedef std::map<float, Instance*> Instances;
|
|
|
455 Instances instances;
|
|
|
456 for (unsigned int i = 0; i < GetInstanceCount(); i++)
|
|
|
457 {
|
|
|
458 float dist = locator.ComputeSliceLocation(GetInstance(i));
|
|
|
459 instances[dist] = &GetInstance(i);
|
|
|
460 }
|
|
|
461
|
|
|
462 if (instances.size() != GetInstanceCount())
|
|
|
463 {
|
|
|
464 // Several instances have the same Z coordinate
|
|
|
465 throw OrthancClientException(ErrorCode_NotImplemented);
|
|
|
466 }
|
|
|
467
|
|
|
468
|
|
|
469 // Submit the download of each stack as a set of commands
|
|
|
470 ThreadedCommandProcessor processor(connection_.GetThreadCount());
|
|
|
471
|
|
|
472 if (listener != NULL)
|
|
|
473 {
|
|
|
474 processor.SetListener(*listener);
|
|
|
475 }
|
|
|
476
|
|
|
477 uint8_t* stackTarget = reinterpret_cast<uint8_t*>(target);
|
|
|
478 for (Instances::iterator it = instances.begin(); it != instances.end(); ++it)
|
|
|
479 {
|
|
|
480 processor.Post(new ImageDownloadCommand(*it->second, format, mode, stackTarget, lineStride));
|
|
|
481 stackTarget += stackStride;
|
|
|
482 }
|
|
|
483
|
|
|
484
|
|
|
485 // Wait for all the stacks to be downloaded
|
|
|
486 if (!processor.Join())
|
|
|
487 {
|
|
|
488 throw OrthancClientException(ErrorCode_NetworkProtocol);
|
|
|
489 }
|
|
|
490 }
|
|
|
491
|
|
|
492 float Series::GetVoxelSizeX()
|
|
|
493 {
|
|
|
494 Check3DImage(); // Is3DImageInternal() will compute the voxel sizes
|
|
|
495 return voxelSizeX_;
|
|
|
496 }
|
|
|
497
|
|
|
498 float Series::GetVoxelSizeY()
|
|
|
499 {
|
|
|
500 Check3DImage(); // Is3DImageInternal() will compute the voxel sizes
|
|
|
501 return voxelSizeY_;
|
|
|
502 }
|
|
|
503
|
|
|
504 float Series::GetVoxelSizeZ()
|
|
|
505 {
|
|
|
506 Check3DImage(); // Is3DImageInternal() will compute the voxel sizes
|
|
|
507 return voxelSizeZ_;
|
|
|
508 }
|
|
|
509
|
|
|
510 float Series::GetSliceThickness()
|
|
|
511 {
|
|
|
512 Check3DImage(); // Is3DImageInternal() will compute the voxel sizes
|
|
|
513 return sliceThickness_;
|
|
|
514 }
|
|
|
515
|
|
|
516 void Series::Load3DImage(void* target,
|
|
|
517 Orthanc::PixelFormat format,
|
|
|
518 int64_t lineStride,
|
|
|
519 int64_t stackStride,
|
|
|
520 float* progress)
|
|
|
521 {
|
|
|
522 ProgressToFloatListener listener(progress);
|
|
|
523 Load3DImageInternal(target, format, static_cast<size_t>(lineStride),
|
|
|
524 static_cast<size_t>(stackStride), &listener);
|
|
|
525 }
|
|
|
526 }
|
