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