|
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 "DecodedImageAdapter.h"
|
|
|
22
|
|
96
|
23 #include "../Orthanc/Core/Images/ImageBuffer.h"
|
|
|
24 #include "../Orthanc/Core/Images/ImageProcessing.h"
|
|
|
25 #include "../Orthanc/Core/OrthancException.h"
|
|
|
26 #include "../Orthanc/Plugins/Samples/GdcmDecoder/OrthancImageWrapper.h"
|
|
|
27 #include "../Orthanc/Resources/ThirdParty/base64/base64.h"
|
|
|
28 #include "ParsedDicomImage.h"
|
|
0
|
29 #include "ViewerToolbox.h"
|
|
|
30
|
|
|
31 #include <boost/lexical_cast.hpp>
|
|
|
32 #include <boost/algorithm/string/predicate.hpp>
|
|
|
33 #include <json/writer.h>
|
|
|
34
|
|
|
35 namespace OrthancPlugins
|
|
|
36 {
|
|
|
37 bool DecodedImageAdapter::ParseUri(CompressionType& type,
|
|
|
38 uint8_t& compressionLevel,
|
|
|
39 std::string& instanceId,
|
|
|
40 const std::string& uri)
|
|
|
41 {
|
|
|
42 size_t separator = uri.find('-');
|
|
|
43 if (separator == std::string::npos &&
|
|
|
44 separator >= 1)
|
|
|
45 {
|
|
|
46 return false;
|
|
|
47 }
|
|
|
48
|
|
|
49 std::string compression = uri.substr(0, separator);
|
|
|
50 instanceId = uri.substr(separator + 1);
|
|
|
51
|
|
|
52 if (compression == "deflate")
|
|
|
53 {
|
|
|
54 type = CompressionType_Deflate;
|
|
|
55 }
|
|
|
56 else if (boost::starts_with(compression, "jpeg"))
|
|
|
57 {
|
|
|
58 type = CompressionType_Jpeg;
|
|
|
59 int level = boost::lexical_cast<int>(compression.substr(4));
|
|
|
60 if (level <= 0 || level > 100)
|
|
|
61 {
|
|
|
62 return false;
|
|
|
63 }
|
|
|
64
|
|
|
65 compressionLevel = static_cast<uint8_t>(level);
|
|
|
66 }
|
|
|
67 else
|
|
|
68 {
|
|
|
69 return false;
|
|
|
70 }
|
|
|
71
|
|
|
72 return true;
|
|
|
73 }
|
|
|
74
|
|
|
75
|
|
|
76
|
|
|
77 bool DecodedImageAdapter::Create(std::string& content,
|
|
|
78 const std::string& uri)
|
|
|
79 {
|
|
|
80 std::string message = "Decoding DICOM instance: " + uri;
|
|
|
81 OrthancPluginLogInfo(context_, message.c_str());
|
|
|
82
|
|
|
83 CompressionType type;
|
|
|
84 uint8_t level;
|
|
|
85 std::string instanceId;
|
|
|
86
|
|
|
87 if (!ParseUri(type, level, instanceId, uri))
|
|
|
88 {
|
|
|
89 return false;
|
|
|
90 }
|
|
|
91
|
|
96
|
92
|
|
|
93 bool ok = false;
|
|
|
94
|
|
|
95 #if 1
|
|
|
96 Json::Value tags;
|
|
|
97 std::string dicom;
|
|
|
98 if (!GetStringFromOrthanc(dicom, context_, "/instances/" + instanceId + "/file") ||
|
|
|
99 !GetJsonFromOrthanc(tags, context_, "/instances/" + instanceId + "/tags"))
|
|
|
100 {
|
|
|
101 throw Orthanc::OrthancException(Orthanc::ErrorCode_UnknownResource);
|
|
|
102 }
|
|
|
103
|
|
|
104 std::auto_ptr<OrthancImageWrapper> image(decoderCache_.Decode(context_, dicom.c_str(), dicom.size(), 0 /* TODO Frame */));
|
|
|
105
|
|
|
106 Json::Value json;
|
|
|
107 if (GetCornerstoneMetadata(json, tags, *image))
|
|
|
108 {
|
|
|
109 if (type == CompressionType_Deflate)
|
|
|
110 {
|
|
|
111 ok = EncodeUsingDeflate(json, *image, 9);
|
|
|
112 }
|
|
|
113 else if (type == CompressionType_Jpeg)
|
|
|
114 {
|
|
|
115 ok = EncodeUsingJpeg(json, *image, level);
|
|
|
116 }
|
|
|
117 }
|
|
|
118
|
|
|
119 #else
|
|
|
120
|
|
31
|
121 ParsedDicomImage image(context_, instanceId);
|
|
0
|
122
|
|
|
123 Json::Value json;
|
|
|
124
|
|
|
125 if (type == CompressionType_Deflate)
|
|
|
126 {
|
|
31
|
127 ok = image.EncodeUsingDeflate(json, 9);
|
|
0
|
128 }
|
|
|
129 else if (type == CompressionType_Jpeg)
|
|
|
130 {
|
|
31
|
131 ok = image.EncodeUsingJpeg(json, level);
|
|
|
132 }
|
|
96
|
133 #endif
|
|
31
|
134
|
|
|
135 if (ok)
|
|
|
136 {
|
|
|
137 Json::FastWriter writer;
|
|
|
138 content = writer.write(json);
|
|
|
139 return true;
|
|
0
|
140 }
|
|
|
141 else
|
|
|
142 {
|
|
31
|
143 char msg[1024];
|
|
|
144 sprintf(msg, "Unable to decode the following instance: %s", uri.c_str());
|
|
|
145 OrthancPluginLogWarning(context_, msg);
|
|
0
|
146 return false;
|
|
|
147 }
|
|
|
148 }
|
|
96
|
149
|
|
|
150
|
|
|
151 static bool GetTagValue(std::string& value,
|
|
|
152 const Json::Value& tags,
|
|
|
153 const std::string& tag)
|
|
|
154 {
|
|
|
155 if (tags.type() == Json::objectValue &&
|
|
|
156 tags.isMember(tag) &&
|
|
|
157 tags[tag].type() == Json::objectValue &&
|
|
|
158 tags[tag].isMember("Type") &&
|
|
|
159 tags[tag].isMember("Value") &&
|
|
|
160 tags[tag]["Type"].type() == Json::stringValue &&
|
|
|
161 tags[tag]["Value"].type() == Json::stringValue &&
|
|
|
162 tags[tag]["Type"].asString() == "String")
|
|
|
163 {
|
|
|
164 value = tags[tag]["Value"].asString();
|
|
|
165 return true;
|
|
|
166 }
|
|
|
167 else
|
|
|
168 {
|
|
|
169 return false;
|
|
|
170 }
|
|
|
171 }
|
|
|
172
|
|
|
173
|
|
|
174
|
|
|
175 bool DecodedImageAdapter::GetCornerstoneMetadata(Json::Value& result,
|
|
|
176 const Json::Value& tags,
|
|
|
177 OrthancImageWrapper& image)
|
|
|
178 {
|
|
|
179 using namespace Orthanc;
|
|
|
180
|
|
|
181 float windowCenter, windowWidth;
|
|
|
182
|
|
|
183 Orthanc::ImageAccessor accessor;
|
|
|
184 accessor.AssignReadOnly(OrthancPlugins::Convert(image.GetFormat()), image.GetWidth(),
|
|
|
185 image.GetHeight(), image.GetPitch(), image.GetBuffer());
|
|
|
186
|
|
|
187 switch (accessor.GetFormat())
|
|
|
188 {
|
|
|
189 case PixelFormat_Grayscale8:
|
|
|
190 case PixelFormat_Grayscale16:
|
|
|
191 case PixelFormat_SignedGrayscale16:
|
|
|
192 {
|
|
|
193 int64_t a, b;
|
|
|
194 Orthanc::ImageProcessing::GetMinMaxValue(a, b, accessor);
|
|
|
195 result["minPixelValue"] = (a < 0 ? static_cast<int32_t>(a) : 0);
|
|
|
196 result["maxPixelValue"] = (b > 0 ? static_cast<int32_t>(b) : 1);
|
|
|
197 result["color"] = false;
|
|
|
198
|
|
|
199 windowCenter = static_cast<float>(a + b) / 2.0f;
|
|
|
200
|
|
|
201 if (a == b)
|
|
|
202 {
|
|
|
203 windowWidth = 256.0f; // Arbitrary value
|
|
|
204 }
|
|
|
205 else
|
|
|
206 {
|
|
|
207 windowWidth = static_cast<float>(b - a) / 2.0f;
|
|
|
208 }
|
|
|
209
|
|
|
210 break;
|
|
|
211 }
|
|
|
212
|
|
|
213 case PixelFormat_RGB24:
|
|
|
214 result["minPixelValue"] = 0;
|
|
|
215 result["maxPixelValue"] = 255;
|
|
|
216 result["color"] = true;
|
|
|
217 windowCenter = 127.5f;
|
|
|
218 windowWidth = 256.0f;
|
|
|
219 break;
|
|
|
220
|
|
|
221 default:
|
|
|
222 return false;
|
|
|
223 }
|
|
|
224
|
|
|
225 result["slope"] = image.GetSlope();
|
|
|
226 result["intercept"] = image.GetIntercept();
|
|
|
227 result["rows"] = image.GetHeight();
|
|
|
228 result["columns"] = image.GetWidth();
|
|
|
229 result["height"] = image.GetHeight();
|
|
|
230 result["width"] = image.GetWidth();
|
|
|
231 result["columnPixelSpacing"] = image.GetColumnPixelSpacing();
|
|
|
232 result["rowPixelSpacing"] = image.GetRowPixelSpacing();
|
|
|
233
|
|
|
234 result["windowCenter"] = windowCenter * image.GetSlope() + image.GetIntercept();
|
|
|
235 result["windowWidth"] = windowWidth * image.GetSlope();
|
|
|
236
|
|
|
237 try
|
|
|
238 {
|
|
|
239 std::string width, center;
|
|
|
240 if (GetTagValue(center, tags, "0028,1050" /*DICOM_TAG_WINDOW_CENTER*/) &&
|
|
|
241 GetTagValue(width, tags, "0028,1051" /*DICOM_TAG_WINDOW_WIDTH*/))
|
|
|
242 {
|
|
|
243 float a = boost::lexical_cast<float>(width);
|
|
|
244 float b = boost::lexical_cast<float>(center);
|
|
|
245 result["windowWidth"] = a;
|
|
|
246 result["windowCenter"] = b;
|
|
|
247 }
|
|
|
248 }
|
|
|
249 catch (boost::bad_lexical_cast&)
|
|
|
250 {
|
|
|
251 }
|
|
|
252
|
|
|
253 return true;
|
|
|
254 }
|
|
|
255
|
|
|
256
|
|
|
257
|
|
|
258 bool DecodedImageAdapter::EncodeUsingDeflate(Json::Value& result,
|
|
|
259 OrthancImageWrapper& image,
|
|
|
260 uint8_t compressionLevel /* between 0 and 9 */)
|
|
|
261 {
|
|
|
262 Orthanc::ImageAccessor accessor;
|
|
|
263 accessor.AssignReadOnly(OrthancPlugins::Convert(image.GetFormat()), image.GetWidth(),
|
|
|
264 image.GetHeight(), image.GetPitch(), image.GetBuffer());
|
|
|
265
|
|
|
266 Orthanc::ImageBuffer buffer;
|
|
|
267 buffer.SetMinimalPitchForced(true);
|
|
|
268
|
|
|
269 Orthanc::ImageAccessor converted;
|
|
|
270
|
|
|
271 switch (accessor.GetFormat())
|
|
|
272 {
|
|
|
273 case Orthanc::PixelFormat_RGB24:
|
|
|
274 converted = accessor;
|
|
|
275 break;
|
|
|
276
|
|
|
277 case Orthanc::PixelFormat_Grayscale8:
|
|
|
278 case Orthanc::PixelFormat_Grayscale16:
|
|
|
279 buffer.SetFormat(Orthanc::PixelFormat_SignedGrayscale16);
|
|
|
280 buffer.SetWidth(accessor.GetWidth());
|
|
|
281 buffer.SetHeight(accessor.GetHeight());
|
|
|
282 converted = buffer.GetAccessor();
|
|
|
283 Orthanc::ImageProcessing::Convert(converted, accessor);
|
|
|
284 break;
|
|
|
285
|
|
|
286 case Orthanc::PixelFormat_SignedGrayscale16:
|
|
|
287 converted = accessor;
|
|
|
288 break;
|
|
|
289
|
|
|
290 default:
|
|
|
291 // Unsupported pixel format
|
|
|
292 return false;
|
|
|
293 }
|
|
|
294
|
|
|
295 // Sanity check: The pitch must be minimal
|
|
|
296 assert(converted.GetSize() == converted.GetWidth() * converted.GetHeight() *
|
|
|
297 GetBytesPerPixel(converted.GetFormat()));
|
|
|
298 result["Orthanc"]["Compression"] = "Deflate";
|
|
|
299 result["sizeInBytes"] = converted.GetSize();
|
|
|
300
|
|
|
301 std::string z;
|
|
|
302 CompressUsingDeflate(z, image.GetContext(), converted.GetConstBuffer(), converted.GetSize());
|
|
|
303
|
|
|
304 result["Orthanc"]["PixelData"] = base64_encode(z);
|
|
|
305
|
|
|
306 return true;
|
|
|
307 }
|
|
|
308
|
|
|
309
|
|
|
310
|
|
|
311 template <typename TargetType, typename SourceType>
|
|
|
312 static void ChangeDynamics(Orthanc::ImageAccessor& target,
|
|
|
313 const Orthanc::ImageAccessor& source,
|
|
|
314 SourceType source1, TargetType target1,
|
|
|
315 SourceType source2, TargetType target2)
|
|
|
316 {
|
|
|
317 if (source.GetWidth() != target.GetWidth() ||
|
|
|
318 source.GetHeight() != target.GetHeight())
|
|
|
319 {
|
|
|
320 throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageSize);
|
|
|
321 }
|
|
|
322
|
|
|
323 float scale = static_cast<float>(target2 - target1) / static_cast<float>(source2 - source1);
|
|
|
324 float offset = static_cast<float>(target1) - scale * static_cast<float>(source1);
|
|
|
325
|
|
|
326 const float minValue = static_cast<float>(std::numeric_limits<TargetType>::min());
|
|
|
327 const float maxValue = static_cast<float>(std::numeric_limits<TargetType>::max());
|
|
|
328
|
|
|
329 for (unsigned int y = 0; y < source.GetHeight(); y++)
|
|
|
330 {
|
|
|
331 const SourceType* p = reinterpret_cast<const SourceType*>(source.GetConstRow(y));
|
|
|
332 TargetType* q = reinterpret_cast<TargetType*>(target.GetRow(y));
|
|
|
333
|
|
|
334 for (unsigned int x = 0; x < source.GetWidth(); x++, p++, q++)
|
|
|
335 {
|
|
|
336 float v = (scale * static_cast<float>(*p)) + offset;
|
|
|
337
|
|
|
338 if (v > maxValue)
|
|
|
339 {
|
|
|
340 *q = std::numeric_limits<TargetType>::max();
|
|
|
341 }
|
|
|
342 else if (v < minValue)
|
|
|
343 {
|
|
|
344 *q = std::numeric_limits<TargetType>::min();
|
|
|
345 }
|
|
|
346 else
|
|
|
347 {
|
|
|
348 *q = static_cast<TargetType>(boost::math::iround(v));
|
|
|
349 }
|
|
|
350 }
|
|
|
351 }
|
|
|
352 }
|
|
|
353
|
|
|
354
|
|
|
355 bool DecodedImageAdapter::EncodeUsingJpeg(Json::Value& result,
|
|
|
356 OrthancImageWrapper& image,
|
|
|
357 uint8_t quality /* between 0 and 100 */)
|
|
|
358 {
|
|
|
359 Orthanc::ImageAccessor accessor;
|
|
|
360 accessor.AssignReadOnly(OrthancPlugins::Convert(image.GetFormat()), image.GetWidth(),
|
|
|
361 image.GetHeight(), image.GetPitch(), image.GetBuffer());
|
|
|
362
|
|
|
363 Orthanc::ImageBuffer buffer;
|
|
|
364 buffer.SetMinimalPitchForced(true);
|
|
|
365
|
|
|
366 Orthanc::ImageAccessor converted;
|
|
|
367
|
|
|
368 if (accessor.GetFormat() == Orthanc::PixelFormat_Grayscale8 ||
|
|
|
369 accessor.GetFormat() == Orthanc::PixelFormat_RGB24)
|
|
|
370 {
|
|
|
371 result["Orthanc"]["Stretched"] = false;
|
|
|
372 converted = accessor;
|
|
|
373 }
|
|
|
374 else if (accessor.GetFormat() == Orthanc::PixelFormat_Grayscale16 ||
|
|
|
375 accessor.GetFormat() == Orthanc::PixelFormat_SignedGrayscale16)
|
|
|
376 {
|
|
|
377 result["Orthanc"]["Stretched"] = true;
|
|
|
378 buffer.SetFormat(Orthanc::PixelFormat_Grayscale8);
|
|
|
379 buffer.SetWidth(accessor.GetWidth());
|
|
|
380 buffer.SetHeight(accessor.GetHeight());
|
|
|
381 converted = buffer.GetAccessor();
|
|
|
382
|
|
|
383 int64_t a, b;
|
|
|
384 Orthanc::ImageProcessing::GetMinMaxValue(a, b, accessor);
|
|
|
385 result["Orthanc"]["StretchLow"] = static_cast<int32_t>(a);
|
|
|
386 result["Orthanc"]["StretchHigh"] = static_cast<int32_t>(b);
|
|
|
387
|
|
|
388 if (accessor.GetFormat() == Orthanc::PixelFormat_Grayscale16)
|
|
|
389 {
|
|
|
390 ChangeDynamics<uint8_t, uint16_t>(converted, accessor, a, 0, b, 255);
|
|
|
391 }
|
|
|
392 else
|
|
|
393 {
|
|
|
394 ChangeDynamics<uint8_t, int16_t>(converted, accessor, a, 0, b, 255);
|
|
|
395 }
|
|
|
396 }
|
|
|
397 else
|
|
|
398 {
|
|
|
399 return false;
|
|
|
400 }
|
|
|
401
|
|
|
402 result["Orthanc"]["Compression"] = "Jpeg";
|
|
|
403 result["sizeInBytes"] = converted.GetSize();
|
|
|
404
|
|
|
405 std::string jpeg;
|
|
|
406 WriteJpegToMemory(jpeg, image.GetContext(), converted, quality);
|
|
|
407
|
|
|
408 result["Orthanc"]["PixelData"] = base64_encode(jpeg);
|
|
|
409 return true;
|
|
|
410 }
|
|
0
|
411 }
|
