|
78
|
1 /**
|
|
|
2 * Orthanc - A Lightweight, RESTful DICOM Store
|
|
122
|
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
|
|
78
|
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 "../PrecompiledHeaders.h"
|
|
|
34 #include "ImageProcessing.h"
|
|
|
35
|
|
|
36 #include "../OrthancException.h"
|
|
|
37
|
|
|
38 #include <boost/math/special_functions/round.hpp>
|
|
|
39
|
|
|
40 #include <cassert>
|
|
|
41 #include <string.h>
|
|
|
42 #include <limits>
|
|
|
43 #include <stdint.h>
|
|
|
44
|
|
|
45 namespace Orthanc
|
|
|
46 {
|
|
|
47 template <typename TargetType, typename SourceType>
|
|
|
48 static void ConvertInternal(ImageAccessor& target,
|
|
|
49 const ImageAccessor& source)
|
|
|
50 {
|
|
|
51 const TargetType minValue = std::numeric_limits<TargetType>::min();
|
|
|
52 const TargetType maxValue = std::numeric_limits<TargetType>::max();
|
|
|
53
|
|
|
54 for (unsigned int y = 0; y < source.GetHeight(); y++)
|
|
|
55 {
|
|
|
56 TargetType* t = reinterpret_cast<TargetType*>(target.GetRow(y));
|
|
|
57 const SourceType* s = reinterpret_cast<const SourceType*>(source.GetConstRow(y));
|
|
|
58
|
|
|
59 for (unsigned int x = 0; x < source.GetWidth(); x++, t++, s++)
|
|
|
60 {
|
|
|
61 if (static_cast<int32_t>(*s) < static_cast<int32_t>(minValue))
|
|
|
62 {
|
|
|
63 *t = minValue;
|
|
|
64 }
|
|
|
65 else if (static_cast<int32_t>(*s) > static_cast<int32_t>(maxValue))
|
|
|
66 {
|
|
|
67 *t = maxValue;
|
|
|
68 }
|
|
|
69 else
|
|
|
70 {
|
|
|
71 *t = static_cast<TargetType>(*s);
|
|
|
72 }
|
|
|
73 }
|
|
|
74 }
|
|
|
75 }
|
|
|
76
|
|
|
77
|
|
129
|
78 template <typename SourceType>
|
|
|
79 static void ConvertGrayscaleToFloat(ImageAccessor& target,
|
|
|
80 const ImageAccessor& source)
|
|
|
81 {
|
|
|
82 for (unsigned int y = 0; y < source.GetHeight(); y++)
|
|
|
83 {
|
|
|
84 float* t = reinterpret_cast<float*>(target.GetRow(y));
|
|
|
85 const SourceType* s = reinterpret_cast<const SourceType*>(source.GetConstRow(y));
|
|
|
86
|
|
|
87 for (unsigned int x = 0; x < source.GetWidth(); x++, t++, s++)
|
|
|
88 {
|
|
|
89 *t = static_cast<float>(*s);
|
|
|
90 }
|
|
|
91 }
|
|
|
92 }
|
|
|
93
|
|
|
94
|
|
78
|
95 template <typename TargetType>
|
|
|
96 static void ConvertColorToGrayscale(ImageAccessor& target,
|
|
129
|
97 const ImageAccessor& source)
|
|
78
|
98 {
|
|
|
99 assert(source.GetFormat() == PixelFormat_RGB24);
|
|
|
100
|
|
|
101 const TargetType minValue = std::numeric_limits<TargetType>::min();
|
|
|
102 const TargetType maxValue = std::numeric_limits<TargetType>::max();
|
|
|
103
|
|
|
104 for (unsigned int y = 0; y < source.GetHeight(); y++)
|
|
|
105 {
|
|
|
106 TargetType* t = reinterpret_cast<TargetType*>(target.GetRow(y));
|
|
|
107 const uint8_t* s = reinterpret_cast<const uint8_t*>(source.GetConstRow(y));
|
|
|
108
|
|
|
109 for (unsigned int x = 0; x < source.GetWidth(); x++, t++, s += 3)
|
|
|
110 {
|
|
|
111 // Y = 0.2126 R + 0.7152 G + 0.0722 B
|
|
|
112 int32_t v = (2126 * static_cast<int32_t>(s[0]) +
|
|
|
113 7152 * static_cast<int32_t>(s[1]) +
|
|
|
114 0722 * static_cast<int32_t>(s[2])) / 1000;
|
|
|
115
|
|
|
116 if (static_cast<int32_t>(v) < static_cast<int32_t>(minValue))
|
|
|
117 {
|
|
|
118 *t = minValue;
|
|
|
119 }
|
|
|
120 else if (static_cast<int32_t>(v) > static_cast<int32_t>(maxValue))
|
|
|
121 {
|
|
|
122 *t = maxValue;
|
|
|
123 }
|
|
|
124 else
|
|
|
125 {
|
|
|
126 *t = static_cast<TargetType>(v);
|
|
|
127 }
|
|
|
128 }
|
|
|
129 }
|
|
|
130 }
|
|
|
131
|
|
|
132
|
|
|
133 template <typename PixelType>
|
|
|
134 static void SetInternal(ImageAccessor& image,
|
|
|
135 int64_t constant)
|
|
|
136 {
|
|
|
137 for (unsigned int y = 0; y < image.GetHeight(); y++)
|
|
|
138 {
|
|
|
139 PixelType* p = reinterpret_cast<PixelType*>(image.GetRow(y));
|
|
|
140
|
|
|
141 for (unsigned int x = 0; x < image.GetWidth(); x++, p++)
|
|
|
142 {
|
|
|
143 *p = static_cast<PixelType>(constant);
|
|
|
144 }
|
|
|
145 }
|
|
|
146 }
|
|
|
147
|
|
|
148
|
|
|
149 template <typename PixelType>
|
|
|
150 static void GetMinMaxValueInternal(PixelType& minValue,
|
|
|
151 PixelType& maxValue,
|
|
|
152 const ImageAccessor& source)
|
|
|
153 {
|
|
|
154 // Deal with the special case of empty image
|
|
|
155 if (source.GetWidth() == 0 ||
|
|
|
156 source.GetHeight() == 0)
|
|
|
157 {
|
|
|
158 minValue = 0;
|
|
|
159 maxValue = 0;
|
|
|
160 return;
|
|
|
161 }
|
|
|
162
|
|
|
163 minValue = std::numeric_limits<PixelType>::max();
|
|
|
164 maxValue = std::numeric_limits<PixelType>::min();
|
|
|
165
|
|
|
166 for (unsigned int y = 0; y < source.GetHeight(); y++)
|
|
|
167 {
|
|
|
168 const PixelType* p = reinterpret_cast<const PixelType*>(source.GetConstRow(y));
|
|
|
169
|
|
|
170 for (unsigned int x = 0; x < source.GetWidth(); x++, p++)
|
|
|
171 {
|
|
|
172 if (*p < minValue)
|
|
|
173 {
|
|
|
174 minValue = *p;
|
|
|
175 }
|
|
|
176
|
|
|
177 if (*p > maxValue)
|
|
|
178 {
|
|
|
179 maxValue = *p;
|
|
|
180 }
|
|
|
181 }
|
|
|
182 }
|
|
|
183 }
|
|
|
184
|
|
|
185
|
|
|
186
|
|
|
187 template <typename PixelType>
|
|
|
188 static void AddConstantInternal(ImageAccessor& image,
|
|
|
189 int64_t constant)
|
|
|
190 {
|
|
|
191 if (constant == 0)
|
|
|
192 {
|
|
|
193 return;
|
|
|
194 }
|
|
|
195
|
|
|
196 const int64_t minValue = std::numeric_limits<PixelType>::min();
|
|
|
197 const int64_t maxValue = std::numeric_limits<PixelType>::max();
|
|
|
198
|
|
|
199 for (unsigned int y = 0; y < image.GetHeight(); y++)
|
|
|
200 {
|
|
|
201 PixelType* p = reinterpret_cast<PixelType*>(image.GetRow(y));
|
|
|
202
|
|
|
203 for (unsigned int x = 0; x < image.GetWidth(); x++, p++)
|
|
|
204 {
|
|
|
205 int64_t v = static_cast<int64_t>(*p) + constant;
|
|
|
206
|
|
|
207 if (v > maxValue)
|
|
|
208 {
|
|
|
209 *p = std::numeric_limits<PixelType>::max();
|
|
|
210 }
|
|
|
211 else if (v < minValue)
|
|
|
212 {
|
|
|
213 *p = std::numeric_limits<PixelType>::min();
|
|
|
214 }
|
|
|
215 else
|
|
|
216 {
|
|
|
217 *p = static_cast<PixelType>(v);
|
|
|
218 }
|
|
|
219 }
|
|
|
220 }
|
|
|
221 }
|
|
|
222
|
|
|
223
|
|
|
224
|
|
|
225 template <typename PixelType>
|
|
|
226 void MultiplyConstantInternal(ImageAccessor& image,
|
|
|
227 float factor)
|
|
|
228 {
|
|
|
229 if (std::abs(factor - 1.0f) <= std::numeric_limits<float>::epsilon())
|
|
|
230 {
|
|
|
231 return;
|
|
|
232 }
|
|
|
233
|
|
|
234 const int64_t minValue = std::numeric_limits<PixelType>::min();
|
|
|
235 const int64_t maxValue = std::numeric_limits<PixelType>::max();
|
|
|
236
|
|
|
237 for (unsigned int y = 0; y < image.GetHeight(); y++)
|
|
|
238 {
|
|
|
239 PixelType* p = reinterpret_cast<PixelType*>(image.GetRow(y));
|
|
|
240
|
|
|
241 for (unsigned int x = 0; x < image.GetWidth(); x++, p++)
|
|
|
242 {
|
|
|
243 int64_t v = boost::math::llround(static_cast<float>(*p) * factor);
|
|
|
244
|
|
|
245 if (v > maxValue)
|
|
|
246 {
|
|
|
247 *p = std::numeric_limits<PixelType>::max();
|
|
|
248 }
|
|
|
249 else if (v < minValue)
|
|
|
250 {
|
|
|
251 *p = std::numeric_limits<PixelType>::min();
|
|
|
252 }
|
|
|
253 else
|
|
|
254 {
|
|
|
255 *p = static_cast<PixelType>(v);
|
|
|
256 }
|
|
|
257 }
|
|
|
258 }
|
|
|
259 }
|
|
|
260
|
|
|
261
|
|
|
262 template <typename PixelType>
|
|
|
263 void ShiftScaleInternal(ImageAccessor& image,
|
|
|
264 float offset,
|
|
|
265 float scaling)
|
|
|
266 {
|
|
|
267 const float minValue = static_cast<float>(std::numeric_limits<PixelType>::min());
|
|
|
268 const float maxValue = static_cast<float>(std::numeric_limits<PixelType>::max());
|
|
|
269
|
|
|
270 for (unsigned int y = 0; y < image.GetHeight(); y++)
|
|
|
271 {
|
|
|
272 PixelType* p = reinterpret_cast<PixelType*>(image.GetRow(y));
|
|
|
273
|
|
|
274 for (unsigned int x = 0; x < image.GetWidth(); x++, p++)
|
|
|
275 {
|
|
|
276 float v = (static_cast<float>(*p) + offset) * scaling;
|
|
|
277
|
|
|
278 if (v > maxValue)
|
|
|
279 {
|
|
|
280 *p = std::numeric_limits<PixelType>::max();
|
|
|
281 }
|
|
|
282 else if (v < minValue)
|
|
|
283 {
|
|
|
284 *p = std::numeric_limits<PixelType>::min();
|
|
|
285 }
|
|
|
286 else
|
|
|
287 {
|
|
|
288 *p = static_cast<PixelType>(boost::math::iround(v));
|
|
|
289 }
|
|
|
290 }
|
|
|
291 }
|
|
|
292 }
|
|
|
293
|
|
|
294
|
|
|
295 void ImageProcessing::Copy(ImageAccessor& target,
|
|
|
296 const ImageAccessor& source)
|
|
|
297 {
|
|
|
298 if (target.GetWidth() != source.GetWidth() ||
|
|
|
299 target.GetHeight() != source.GetHeight())
|
|
|
300 {
|
|
|
301 throw OrthancException(ErrorCode_IncompatibleImageSize);
|
|
|
302 }
|
|
|
303
|
|
|
304 if (target.GetFormat() != source.GetFormat())
|
|
|
305 {
|
|
|
306 throw OrthancException(ErrorCode_IncompatibleImageFormat);
|
|
|
307 }
|
|
|
308
|
|
|
309 unsigned int lineSize = GetBytesPerPixel(source.GetFormat()) * source.GetWidth();
|
|
|
310
|
|
|
311 assert(source.GetPitch() >= lineSize && target.GetPitch() >= lineSize);
|
|
|
312
|
|
|
313 for (unsigned int y = 0; y < source.GetHeight(); y++)
|
|
|
314 {
|
|
|
315 memcpy(target.GetRow(y), source.GetConstRow(y), lineSize);
|
|
|
316 }
|
|
|
317 }
|
|
|
318
|
|
|
319
|
|
|
320 void ImageProcessing::Convert(ImageAccessor& target,
|
|
|
321 const ImageAccessor& source)
|
|
|
322 {
|
|
|
323 if (target.GetWidth() != source.GetWidth() ||
|
|
|
324 target.GetHeight() != source.GetHeight())
|
|
|
325 {
|
|
|
326 throw OrthancException(ErrorCode_IncompatibleImageSize);
|
|
|
327 }
|
|
|
328
|
|
|
329 if (source.GetFormat() == target.GetFormat())
|
|
|
330 {
|
|
|
331 Copy(target, source);
|
|
|
332 return;
|
|
|
333 }
|
|
|
334
|
|
|
335 if (target.GetFormat() == PixelFormat_Grayscale16 &&
|
|
|
336 source.GetFormat() == PixelFormat_Grayscale8)
|
|
|
337 {
|
|
|
338 ConvertInternal<uint16_t, uint8_t>(target, source);
|
|
|
339 return;
|
|
|
340 }
|
|
|
341
|
|
|
342 if (target.GetFormat() == PixelFormat_SignedGrayscale16 &&
|
|
|
343 source.GetFormat() == PixelFormat_Grayscale8)
|
|
|
344 {
|
|
|
345 ConvertInternal<int16_t, uint8_t>(target, source);
|
|
|
346 return;
|
|
|
347 }
|
|
|
348
|
|
|
349 if (target.GetFormat() == PixelFormat_Grayscale8 &&
|
|
|
350 source.GetFormat() == PixelFormat_Grayscale16)
|
|
|
351 {
|
|
|
352 ConvertInternal<uint8_t, uint16_t>(target, source);
|
|
|
353 return;
|
|
|
354 }
|
|
|
355
|
|
|
356 if (target.GetFormat() == PixelFormat_SignedGrayscale16 &&
|
|
|
357 source.GetFormat() == PixelFormat_Grayscale16)
|
|
|
358 {
|
|
|
359 ConvertInternal<int16_t, uint16_t>(target, source);
|
|
|
360 return;
|
|
|
361 }
|
|
|
362
|
|
|
363 if (target.GetFormat() == PixelFormat_Grayscale8 &&
|
|
|
364 source.GetFormat() == PixelFormat_SignedGrayscale16)
|
|
|
365 {
|
|
|
366 ConvertInternal<uint8_t, int16_t>(target, source);
|
|
|
367 return;
|
|
|
368 }
|
|
|
369
|
|
|
370 if (target.GetFormat() == PixelFormat_Grayscale16 &&
|
|
|
371 source.GetFormat() == PixelFormat_SignedGrayscale16)
|
|
|
372 {
|
|
|
373 ConvertInternal<uint16_t, int16_t>(target, source);
|
|
|
374 return;
|
|
|
375 }
|
|
|
376
|
|
|
377 if (target.GetFormat() == PixelFormat_Grayscale8 &&
|
|
|
378 source.GetFormat() == PixelFormat_RGB24)
|
|
|
379 {
|
|
|
380 ConvertColorToGrayscale<uint8_t>(target, source);
|
|
|
381 return;
|
|
|
382 }
|
|
|
383
|
|
|
384 if (target.GetFormat() == PixelFormat_Grayscale16 &&
|
|
|
385 source.GetFormat() == PixelFormat_RGB24)
|
|
|
386 {
|
|
|
387 ConvertColorToGrayscale<uint16_t>(target, source);
|
|
|
388 return;
|
|
|
389 }
|
|
|
390
|
|
|
391 if (target.GetFormat() == PixelFormat_SignedGrayscale16 &&
|
|
|
392 source.GetFormat() == PixelFormat_RGB24)
|
|
|
393 {
|
|
|
394 ConvertColorToGrayscale<int16_t>(target, source);
|
|
|
395 return;
|
|
|
396 }
|
|
|
397
|
|
129
|
398 if (target.GetFormat() == PixelFormat_Float32 &&
|
|
|
399 source.GetFormat() == PixelFormat_Grayscale8)
|
|
|
400 {
|
|
|
401 ConvertGrayscaleToFloat<uint8_t>(target, source);
|
|
|
402 return;
|
|
|
403 }
|
|
|
404
|
|
|
405 if (target.GetFormat() == PixelFormat_Float32 &&
|
|
|
406 source.GetFormat() == PixelFormat_Grayscale16)
|
|
|
407 {
|
|
|
408 ConvertGrayscaleToFloat<uint16_t>(target, source);
|
|
|
409 return;
|
|
|
410 }
|
|
|
411
|
|
|
412 if (target.GetFormat() == PixelFormat_Float32 &&
|
|
|
413 source.GetFormat() == PixelFormat_SignedGrayscale16)
|
|
|
414 {
|
|
|
415 ConvertGrayscaleToFloat<int16_t>(target, source);
|
|
|
416 return;
|
|
|
417 }
|
|
|
418
|
|
78
|
419 if (target.GetFormat() == PixelFormat_Grayscale8 &&
|
|
|
420 source.GetFormat() == PixelFormat_RGBA32)
|
|
|
421 {
|
|
|
422 for (unsigned int y = 0; y < source.GetHeight(); y++)
|
|
|
423 {
|
|
|
424 const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y));
|
|
|
425 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y));
|
|
|
426 for (unsigned int x = 0; x < source.GetWidth(); x++, q++)
|
|
|
427 {
|
|
|
428 *q = static_cast<uint8_t>((2126 * static_cast<uint32_t>(p[0]) +
|
|
|
429 7152 * static_cast<uint32_t>(p[1]) +
|
|
|
430 0722 * static_cast<uint32_t>(p[2])) / 10000);
|
|
|
431 p += 4;
|
|
|
432 }
|
|
|
433 }
|
|
|
434
|
|
|
435 return;
|
|
|
436 }
|
|
|
437
|
|
|
438 if (target.GetFormat() == PixelFormat_RGB24 &&
|
|
|
439 source.GetFormat() == PixelFormat_RGBA32)
|
|
|
440 {
|
|
|
441 for (unsigned int y = 0; y < source.GetHeight(); y++)
|
|
|
442 {
|
|
|
443 const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y));
|
|
|
444 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y));
|
|
|
445 for (unsigned int x = 0; x < source.GetWidth(); x++)
|
|
|
446 {
|
|
|
447 q[0] = p[0];
|
|
|
448 q[1] = p[1];
|
|
|
449 q[2] = p[2];
|
|
|
450 p += 4;
|
|
|
451 q += 3;
|
|
|
452 }
|
|
|
453 }
|
|
|
454
|
|
|
455 return;
|
|
|
456 }
|
|
|
457
|
|
|
458 if (target.GetFormat() == PixelFormat_RGBA32 &&
|
|
|
459 source.GetFormat() == PixelFormat_RGB24)
|
|
|
460 {
|
|
|
461 for (unsigned int y = 0; y < source.GetHeight(); y++)
|
|
|
462 {
|
|
|
463 const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y));
|
|
|
464 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y));
|
|
|
465 for (unsigned int x = 0; x < source.GetWidth(); x++)
|
|
|
466 {
|
|
|
467 q[0] = p[0];
|
|
|
468 q[1] = p[1];
|
|
|
469 q[2] = p[2];
|
|
|
470 q[3] = 255; // Set the alpha channel to full opacity
|
|
|
471 p += 3;
|
|
|
472 q += 4;
|
|
|
473 }
|
|
|
474 }
|
|
|
475
|
|
|
476 return;
|
|
|
477 }
|
|
|
478
|
|
129
|
479 if (target.GetFormat() == PixelFormat_RGB24 &&
|
|
|
480 source.GetFormat() == PixelFormat_Grayscale8)
|
|
|
481 {
|
|
|
482 for (unsigned int y = 0; y < source.GetHeight(); y++)
|
|
|
483 {
|
|
|
484 const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y));
|
|
|
485 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y));
|
|
|
486 for (unsigned int x = 0; x < source.GetWidth(); x++)
|
|
|
487 {
|
|
|
488 q[0] = *p;
|
|
|
489 q[1] = *p;
|
|
|
490 q[2] = *p;
|
|
|
491 p += 1;
|
|
|
492 q += 3;
|
|
|
493 }
|
|
|
494 }
|
|
|
495
|
|
|
496 return;
|
|
|
497 }
|
|
|
498
|
|
|
499 if (target.GetFormat() == PixelFormat_RGBA32 &&
|
|
|
500 source.GetFormat() == PixelFormat_Grayscale8)
|
|
|
501 {
|
|
|
502 for (unsigned int y = 0; y < source.GetHeight(); y++)
|
|
|
503 {
|
|
|
504 const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y));
|
|
|
505 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y));
|
|
|
506 for (unsigned int x = 0; x < source.GetWidth(); x++)
|
|
|
507 {
|
|
|
508 q[0] = *p;
|
|
|
509 q[1] = *p;
|
|
|
510 q[2] = *p;
|
|
|
511 q[3] = 255;
|
|
|
512 p += 1;
|
|
|
513 q += 4;
|
|
|
514 }
|
|
|
515 }
|
|
|
516
|
|
|
517 return;
|
|
|
518 }
|
|
|
519
|
|
78
|
520 throw OrthancException(ErrorCode_NotImplemented);
|
|
|
521 }
|
|
|
522
|
|
|
523
|
|
|
524
|
|
|
525 void ImageProcessing::Set(ImageAccessor& image,
|
|
|
526 int64_t value)
|
|
|
527 {
|
|
|
528 switch (image.GetFormat())
|
|
|
529 {
|
|
|
530 case PixelFormat_Grayscale8:
|
|
|
531 SetInternal<uint8_t>(image, value);
|
|
|
532 return;
|
|
|
533
|
|
|
534 case PixelFormat_Grayscale16:
|
|
|
535 SetInternal<uint16_t>(image, value);
|
|
|
536 return;
|
|
|
537
|
|
|
538 case PixelFormat_SignedGrayscale16:
|
|
|
539 SetInternal<int16_t>(image, value);
|
|
|
540 return;
|
|
|
541
|
|
|
542 default:
|
|
|
543 throw OrthancException(ErrorCode_NotImplemented);
|
|
|
544 }
|
|
|
545 }
|
|
|
546
|
|
|
547
|
|
|
548 void ImageProcessing::ShiftRight(ImageAccessor& image,
|
|
|
549 unsigned int shift)
|
|
|
550 {
|
|
|
551 if (image.GetWidth() == 0 ||
|
|
|
552 image.GetHeight() == 0 ||
|
|
|
553 shift == 0)
|
|
|
554 {
|
|
|
555 // Nothing to do
|
|
|
556 return;
|
|
|
557 }
|
|
|
558
|
|
|
559 throw OrthancException(ErrorCode_NotImplemented);
|
|
|
560 }
|
|
|
561
|
|
|
562
|
|
|
563 void ImageProcessing::GetMinMaxValue(int64_t& minValue,
|
|
|
564 int64_t& maxValue,
|
|
|
565 const ImageAccessor& image)
|
|
|
566 {
|
|
|
567 switch (image.GetFormat())
|
|
|
568 {
|
|
|
569 case PixelFormat_Grayscale8:
|
|
|
570 {
|
|
|
571 uint8_t a, b;
|
|
|
572 GetMinMaxValueInternal<uint8_t>(a, b, image);
|
|
|
573 minValue = a;
|
|
|
574 maxValue = b;
|
|
|
575 break;
|
|
|
576 }
|
|
|
577
|
|
|
578 case PixelFormat_Grayscale16:
|
|
|
579 {
|
|
|
580 uint16_t a, b;
|
|
|
581 GetMinMaxValueInternal<uint16_t>(a, b, image);
|
|
|
582 minValue = a;
|
|
|
583 maxValue = b;
|
|
|
584 break;
|
|
|
585 }
|
|
|
586
|
|
|
587 case PixelFormat_SignedGrayscale16:
|
|
|
588 {
|
|
|
589 int16_t a, b;
|
|
|
590 GetMinMaxValueInternal<int16_t>(a, b, image);
|
|
|
591 minValue = a;
|
|
|
592 maxValue = b;
|
|
|
593 break;
|
|
|
594 }
|
|
|
595
|
|
|
596 default:
|
|
|
597 throw OrthancException(ErrorCode_NotImplemented);
|
|
|
598 }
|
|
|
599 }
|
|
|
600
|
|
|
601
|
|
|
602
|
|
|
603 void ImageProcessing::AddConstant(ImageAccessor& image,
|
|
|
604 int64_t value)
|
|
|
605 {
|
|
|
606 switch (image.GetFormat())
|
|
|
607 {
|
|
|
608 case PixelFormat_Grayscale8:
|
|
|
609 AddConstantInternal<uint8_t>(image, value);
|
|
|
610 return;
|
|
|
611
|
|
|
612 case PixelFormat_Grayscale16:
|
|
|
613 AddConstantInternal<uint16_t>(image, value);
|
|
|
614 return;
|
|
|
615
|
|
|
616 case PixelFormat_SignedGrayscale16:
|
|
|
617 AddConstantInternal<int16_t>(image, value);
|
|
|
618 return;
|
|
|
619
|
|
|
620 default:
|
|
|
621 throw OrthancException(ErrorCode_NotImplemented);
|
|
|
622 }
|
|
|
623 }
|
|
|
624
|
|
|
625
|
|
|
626 void ImageProcessing::MultiplyConstant(ImageAccessor& image,
|
|
|
627 float factor)
|
|
|
628 {
|
|
|
629 switch (image.GetFormat())
|
|
|
630 {
|
|
|
631 case PixelFormat_Grayscale8:
|
|
|
632 MultiplyConstantInternal<uint8_t>(image, factor);
|
|
|
633 return;
|
|
|
634
|
|
|
635 case PixelFormat_Grayscale16:
|
|
|
636 MultiplyConstantInternal<uint16_t>(image, factor);
|
|
|
637 return;
|
|
|
638
|
|
|
639 case PixelFormat_SignedGrayscale16:
|
|
|
640 MultiplyConstantInternal<int16_t>(image, factor);
|
|
|
641 return;
|
|
|
642
|
|
|
643 default:
|
|
|
644 throw OrthancException(ErrorCode_NotImplemented);
|
|
|
645 }
|
|
|
646 }
|
|
|
647
|
|
|
648
|
|
|
649 void ImageProcessing::ShiftScale(ImageAccessor& image,
|
|
|
650 float offset,
|
|
|
651 float scaling)
|
|
|
652 {
|
|
|
653 switch (image.GetFormat())
|
|
|
654 {
|
|
|
655 case PixelFormat_Grayscale8:
|
|
|
656 ShiftScaleInternal<uint8_t>(image, offset, scaling);
|
|
|
657 return;
|
|
|
658
|
|
|
659 case PixelFormat_Grayscale16:
|
|
|
660 ShiftScaleInternal<uint16_t>(image, offset, scaling);
|
|
|
661 return;
|
|
|
662
|
|
|
663 case PixelFormat_SignedGrayscale16:
|
|
|
664 ShiftScaleInternal<int16_t>(image, offset, scaling);
|
|
|
665 return;
|
|
|
666
|
|
|
667 default:
|
|
|
668 throw OrthancException(ErrorCode_NotImplemented);
|
|
|
669 }
|
|
|
670 }
|
|
|
671 }
|
