Mercurial > hg > orthanc

comparison OrthancFramework/UnitTestsSources/ImageProcessingTests.cpp @ 4044:d25f4c0fa160 framework

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
splitting code into OrthancFramework and OrthancServer
author Sebastien Jodogne <s.jodogne@gmail.com>
date Wed, 10 Jun 2020 20:30:34 +0200
parents UnitTestsSources/ImageProcessingTests.cpp@27628b0f6ada
children 05b8fd21089c
comparison
equal deleted inserted replaced
4043:6c6239aec462 4044:d25f4c0fa160
1 /**
2 * Orthanc - A Lightweight, RESTful DICOM Store
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
4 * Department, University Hospital of Liege, Belgium
5 * Copyright (C) 2017-2020 Osimis S.A., Belgium
6 *
7 * This program is free software: you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License as
9 * published by the Free Software Foundation, either version 3 of the
10 * License, or (at your option) any later version.
11 *
12 * In addition, as a special exception, the copyright holders of this
13 * program give permission to link the code of its release with the
14 * OpenSSL project's "OpenSSL" library (or with modified versions of it
15 * that use the same license as the "OpenSSL" library), and distribute
16 * the linked executables. You must obey the GNU General Public License
17 * in all respects for all of the code used other than "OpenSSL". If you
18 * modify file(s) with this exception, you may extend this exception to
19 * your version of the file(s), but you are not obligated to do so. If
20 * you do not wish to do so, delete this exception statement from your
21 * version. If you delete this exception statement from all source files
22 * in the program, then also delete it here.
23 *
24 * This program is distributed in the hope that it will be useful, but
25 * WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
27 * General Public License for more details.
28 *
29 * You should have received a copy of the GNU General Public License
30 * along with this program. If not, see <http://www.gnu.org/licenses/>.
31 **/
32
33
34 #if ORTHANC_UNIT_TESTS_LINK_FRAMEWORK == 1
35 # include <OrthancFramework.h>
36 #endif
37
38 #include "PrecompiledHeadersUnitTests.h"
39 #include "gtest/gtest.h"
40
41 #include "../Core/Compatibility.h"
42 #include "../Core/DicomFormat/DicomImageInformation.h"
43 #include "../Core/Images/Image.h"
44 #include "../Core/Images/ImageProcessing.h"
45 #include "../Core/Images/ImageTraits.h"
46 #include "../Core/OrthancException.h"
47
48 #include <memory>
49
50 using namespace Orthanc;
51
52
53 TEST(DicomImageInformation, ExtractPixelFormat1)
54 {
55 // Cardiac/MR*
56 DicomMap m;
57 m.SetValue(DICOM_TAG_ROWS, "24", false);
58 m.SetValue(DICOM_TAG_COLUMNS, "16", false);
59 m.SetValue(DICOM_TAG_BITS_ALLOCATED, "16", false);
60 m.SetValue(DICOM_TAG_SAMPLES_PER_PIXEL, "1", false);
61 m.SetValue(DICOM_TAG_BITS_STORED, "12", false);
62 m.SetValue(DICOM_TAG_HIGH_BIT, "11", false);
63 m.SetValue(DICOM_TAG_PIXEL_REPRESENTATION, "0", false);
64 m.SetValue(DICOM_TAG_PHOTOMETRIC_INTERPRETATION, "MONOCHROME2", false);
65
66 DicomImageInformation info(m);
67 PixelFormat format;
68 ASSERT_TRUE(info.ExtractPixelFormat(format, false));
69 ASSERT_EQ(PixelFormat_Grayscale16, format);
70 }
71
72
73 TEST(DicomImageInformation, ExtractPixelFormat2)
74 {
75 // Delphine CT
76 DicomMap m;
77 m.SetValue(DICOM_TAG_ROWS, "24", false);
78 m.SetValue(DICOM_TAG_COLUMNS, "16", false);
79 m.SetValue(DICOM_TAG_BITS_ALLOCATED, "16", false);
80 m.SetValue(DICOM_TAG_SAMPLES_PER_PIXEL, "1", false);
81 m.SetValue(DICOM_TAG_BITS_STORED, "16", false);
82 m.SetValue(DICOM_TAG_HIGH_BIT, "15", false);
83 m.SetValue(DICOM_TAG_PIXEL_REPRESENTATION, "1", false);
84 m.SetValue(DICOM_TAG_PHOTOMETRIC_INTERPRETATION, "MONOCHROME2", false);
85
86 DicomImageInformation info(m);
87 PixelFormat format;
88 ASSERT_TRUE(info.ExtractPixelFormat(format, false));
89 ASSERT_EQ(PixelFormat_SignedGrayscale16, format);
90 }
91
92
93
94 namespace
95 {
96 template <typename T>
97 class TestImageTraits : public ::testing::Test
98 {
99 private:
100 std::unique_ptr<Image> image_;
101
102 protected:
103 virtual void SetUp() ORTHANC_OVERRIDE
104 {
105 image_.reset(new Image(ImageTraits::PixelTraits::GetPixelFormat(), 7, 9, false));
106 }
107
108 virtual void TearDown() ORTHANC_OVERRIDE
109 {
110 image_.reset(NULL);
111 }
112
113 public:
114 typedef T ImageTraits;
115
116 ImageAccessor& GetImage()
117 {
118 return *image_;
119 }
120 };
121
122 template <typename T>
123 class TestIntegerImageTraits : public TestImageTraits<T>
124 {
125 };
126 }
127
128
129 typedef ::testing::Types<
130 ImageTraits<PixelFormat_Grayscale8>,
131 ImageTraits<PixelFormat_Grayscale16>,
132 ImageTraits<PixelFormat_SignedGrayscale16>
133 > IntegerFormats;
134 TYPED_TEST_CASE(TestIntegerImageTraits, IntegerFormats);
135
136 typedef ::testing::Types<
137 ImageTraits<PixelFormat_Grayscale8>,
138 ImageTraits<PixelFormat_Grayscale16>,
139 ImageTraits<PixelFormat_SignedGrayscale16>,
140 ImageTraits<PixelFormat_RGB24>,
141 ImageTraits<PixelFormat_BGRA32>
142 > AllFormats;
143 TYPED_TEST_CASE(TestImageTraits, AllFormats);
144
145
146 TYPED_TEST(TestImageTraits, SetZero)
147 {
148 ImageAccessor& image = this->GetImage();
149
150 memset(image.GetBuffer(), 128, image.GetHeight() * image.GetWidth());
151
152 switch (image.GetFormat())
153 {
154 case PixelFormat_Grayscale8:
155 case PixelFormat_Grayscale16:
156 case PixelFormat_SignedGrayscale16:
157 ImageProcessing::Set(image, 0);
158 break;
159
160 case PixelFormat_RGB24:
161 case PixelFormat_BGRA32:
162 ImageProcessing::Set(image, 0, 0, 0, 0);
163 break;
164
165 default:
166 ASSERT_TRUE(0);
167 }
168
169 typename TestFixture::ImageTraits::PixelType zero, value;
170 TestFixture::ImageTraits::PixelTraits::SetZero(zero);
171
172 for (unsigned int y = 0; y < image.GetHeight(); y++)
173 {
174 for (unsigned int x = 0; x < image.GetWidth(); x++)
175 {
176 TestFixture::ImageTraits::GetPixel(value, image, x, y);
177 ASSERT_TRUE(TestFixture::ImageTraits::PixelTraits::IsEqual(zero, value));
178 }
179 }
180 }
181
182
183 TYPED_TEST(TestIntegerImageTraits, SetZeroFloat)
184 {
185 ImageAccessor& image = this->GetImage();
186
187 memset(image.GetBuffer(), 128, image.GetHeight() * image.GetWidth());
188
189 float c = 0.0f;
190 for (unsigned int y = 0; y < image.GetHeight(); y++)
191 {
192 for (unsigned int x = 0; x < image.GetWidth(); x++, c++)
193 {
194 TestFixture::ImageTraits::SetFloatPixel(image, c, x, y);
195 }
196 }
197
198 c = 0.0f;
199 for (unsigned int y = 0; y < image.GetHeight(); y++)
200 {
201 for (unsigned int x = 0; x < image.GetWidth(); x++, c++)
202 {
203 ASSERT_FLOAT_EQ(c, TestFixture::ImageTraits::GetFloatPixel(image, x, y));
204 }
205 }
206 }
207
208 TYPED_TEST(TestIntegerImageTraits, FillPolygon)
209 {
210 ImageAccessor& image = this->GetImage();
211
212 ImageProcessing::Set(image, 128);
213
214 // draw a triangle
215 std::vector<ImageProcessing::ImagePoint> points;
216 points.push_back(ImageProcessing::ImagePoint(1,1));
217 points.push_back(ImageProcessing::ImagePoint(1,5));
218 points.push_back(ImageProcessing::ImagePoint(5,5));
219
220 ImageProcessing::FillPolygon(image, points, 255);
221
222 // outside polygon
223 ASSERT_FLOAT_EQ(128, TestFixture::ImageTraits::GetFloatPixel(image, 0, 0));
224 ASSERT_FLOAT_EQ(128, TestFixture::ImageTraits::GetFloatPixel(image, 0, 6));
225 ASSERT_FLOAT_EQ(128, TestFixture::ImageTraits::GetFloatPixel(image, 6, 6));
226 ASSERT_FLOAT_EQ(128, TestFixture::ImageTraits::GetFloatPixel(image, 6, 0));
227
228 ASSERT_FLOAT_EQ(255, TestFixture::ImageTraits::GetFloatPixel(image, 1, 1));
229 ASSERT_FLOAT_EQ(255, TestFixture::ImageTraits::GetFloatPixel(image, 1, 2));
230 ASSERT_FLOAT_EQ(255, TestFixture::ImageTraits::GetFloatPixel(image, 1, 5));
231 ASSERT_FLOAT_EQ(255, TestFixture::ImageTraits::GetFloatPixel(image, 2, 4));
232 ASSERT_FLOAT_EQ(255, TestFixture::ImageTraits::GetFloatPixel(image, 5, 5));
233 }
234
235 TYPED_TEST(TestIntegerImageTraits, FillPolygonLargerThanImage)
236 {
237 ImageAccessor& image = this->GetImage();
238
239 ImageProcessing::Set(image, 0);
240
241 std::vector<ImageProcessing::ImagePoint> points;
242 points.push_back(ImageProcessing::ImagePoint(0, 0));
243 points.push_back(ImageProcessing::ImagePoint(image.GetWidth(),0));
244 points.push_back(ImageProcessing::ImagePoint(image.GetWidth(),image.GetHeight()));
245 points.push_back(ImageProcessing::ImagePoint(0,image.GetHeight()));
246
247 ASSERT_THROW(ImageProcessing::FillPolygon(image, points, 255), OrthancException);
248 }
249
250 TYPED_TEST(TestIntegerImageTraits, FillPolygonFullImage)
251 {
252 ImageAccessor& image = this->GetImage();
253
254 ImageProcessing::Set(image, 0);
255
256 std::vector<ImageProcessing::ImagePoint> points;
257 points.push_back(ImageProcessing::ImagePoint(0, 0));
258 points.push_back(ImageProcessing::ImagePoint(image.GetWidth() - 1,0));
259 points.push_back(ImageProcessing::ImagePoint(image.GetWidth() - 1,image.GetHeight() - 1));
260 points.push_back(ImageProcessing::ImagePoint(0,image.GetHeight() - 1));
261
262 ImageProcessing::FillPolygon(image, points, 255);
263
264 ASSERT_FLOAT_EQ(255, TestFixture::ImageTraits::GetFloatPixel(image, 0, 0));
265 ASSERT_FLOAT_EQ(255, TestFixture::ImageTraits::GetFloatPixel(image, image.GetWidth() - 1, image.GetHeight() - 1));
266 }
267
268
269
270
271 static void SetGrayscale8Pixel(ImageAccessor& image,
272 unsigned int x,
273 unsigned int y,
274 uint8_t value)
275 {
276 ImageTraits<PixelFormat_Grayscale8>::SetPixel(image, value, x, y);
277 }
278
279 static bool TestGrayscale8Pixel(const ImageAccessor& image,
280 unsigned int x,
281 unsigned int y,
282 uint8_t value)
283 {
284 PixelTraits<PixelFormat_Grayscale8>::PixelType p;
285 ImageTraits<PixelFormat_Grayscale8>::GetPixel(p, image, x, y);
286 if (p != value) printf("%d %d\n", p, value);
287 return p == value;
288 }
289
290 static void SetGrayscale16Pixel(ImageAccessor& image,
291 unsigned int x,
292 unsigned int y,
293 uint16_t value)
294 {
295 ImageTraits<PixelFormat_Grayscale16>::SetPixel(image, value, x, y);
296 }
297
298 static bool TestGrayscale16Pixel(const ImageAccessor& image,
299 unsigned int x,
300 unsigned int y,
301 uint16_t value)
302 {
303 PixelTraits<PixelFormat_Grayscale16>::PixelType p;
304 ImageTraits<PixelFormat_Grayscale16>::GetPixel(p, image, x, y);
305 if (p != value) printf("%d %d\n", p, value);
306 return p == value;
307 }
308
309 static void SetSignedGrayscale16Pixel(ImageAccessor& image,
310 unsigned int x,
311 unsigned int y,
312 int16_t value)
313 {
314 ImageTraits<PixelFormat_SignedGrayscale16>::SetPixel(image, value, x, y);
315 }
316
317 static bool TestSignedGrayscale16Pixel(const ImageAccessor& image,
318 unsigned int x,
319 unsigned int y,
320 int16_t value)
321 {
322 PixelTraits<PixelFormat_SignedGrayscale16>::PixelType p;
323 ImageTraits<PixelFormat_SignedGrayscale16>::GetPixel(p, image, x, y);
324 if (p != value) printf("%d %d\n", p, value);
325 return p == value;
326 }
327
328 static void SetRGB24Pixel(ImageAccessor& image,
329 unsigned int x,
330 unsigned int y,
331 uint8_t red,
332 uint8_t green,
333 uint8_t blue)
334 {
335 PixelTraits<PixelFormat_RGB24>::PixelType p;
336 p.red_ = red;
337 p.green_ = green;
338 p.blue_ = blue;
339 ImageTraits<PixelFormat_RGB24>::SetPixel(image, p, x, y);
340 }
341
342 static bool TestRGB24Pixel(const ImageAccessor& image,
343 unsigned int x,
344 unsigned int y,
345 uint8_t red,
346 uint8_t green,
347 uint8_t blue)
348 {
349 PixelTraits<PixelFormat_RGB24>::PixelType p;
350 ImageTraits<PixelFormat_RGB24>::GetPixel(p, image, x, y);
351 bool ok = (p.red_ == red &&
352 p.green_ == green &&
353 p.blue_ == blue);
354 if (!ok) printf("%d,%d,%d %d,%d,%d\n", p.red_, p.green_, p.blue_, red, green, blue);
355 return ok;
356 }
357
358
359 TEST(ImageProcessing, FlipGrayscale8)
360 {
361 {
362 Image image(PixelFormat_Grayscale8, 0, 0, false);
363 ImageProcessing::FlipX(image);
364 ImageProcessing::FlipY(image);
365 }
366
367 {
368 Image image(PixelFormat_Grayscale8, 1, 1, false);
369 SetGrayscale8Pixel(image, 0, 0, 128);
370 ImageProcessing::FlipX(image);
371 ImageProcessing::FlipY(image);
372 ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 128));
373 }
374
375 {
376 Image image(PixelFormat_Grayscale8, 3, 2, false);
377 SetGrayscale8Pixel(image, 0, 0, 10);
378 SetGrayscale8Pixel(image, 1, 0, 20);
379 SetGrayscale8Pixel(image, 2, 0, 30);
380 SetGrayscale8Pixel(image, 0, 1, 40);
381 SetGrayscale8Pixel(image, 1, 1, 50);
382 SetGrayscale8Pixel(image, 2, 1, 60);
383
384 ImageProcessing::FlipX(image);
385 ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 30));
386 ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 0, 20));
387 ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 0, 10));
388 ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 1, 60));
389 ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 1, 50));
390 ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 1, 40));
391
392 ImageProcessing::FlipY(image);
393 ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 60));
394 ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 0, 50));
395 ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 0, 40));
396 ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 1, 30));
397 ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 1, 20));
398 ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 1, 10));
399 }
400 }
401
402
403
404 TEST(ImageProcessing, FlipRGB24)
405 {
406 Image image(PixelFormat_RGB24, 2, 2, false);
407 SetRGB24Pixel(image, 0, 0, 10, 100, 110);
408 SetRGB24Pixel(image, 1, 0, 20, 100, 110);
409 SetRGB24Pixel(image, 0, 1, 30, 100, 110);
410 SetRGB24Pixel(image, 1, 1, 40, 100, 110);
411
412 ImageProcessing::FlipX(image);
413 ASSERT_TRUE(TestRGB24Pixel(image, 0, 0, 20, 100, 110));
414 ASSERT_TRUE(TestRGB24Pixel(image, 1, 0, 10, 100, 110));
415 ASSERT_TRUE(TestRGB24Pixel(image, 0, 1, 40, 100, 110));
416 ASSERT_TRUE(TestRGB24Pixel(image, 1, 1, 30, 100, 110));
417
418 ImageProcessing::FlipY(image);
419 ASSERT_TRUE(TestRGB24Pixel(image, 0, 0, 40, 100, 110));
420 ASSERT_TRUE(TestRGB24Pixel(image, 1, 0, 30, 100, 110));
421 ASSERT_TRUE(TestRGB24Pixel(image, 0, 1, 20, 100, 110));
422 ASSERT_TRUE(TestRGB24Pixel(image, 1, 1, 10, 100, 110));
423 }
424
425
426 TEST(ImageProcessing, ResizeBasicGrayscale8)
427 {
428 Image source(PixelFormat_Grayscale8, 2, 2, false);
429 SetGrayscale8Pixel(source, 0, 0, 10);
430 SetGrayscale8Pixel(source, 1, 0, 20);
431 SetGrayscale8Pixel(source, 0, 1, 30);
432 SetGrayscale8Pixel(source, 1, 1, 40);
433
434 {
435 Image target(PixelFormat_Grayscale8, 2, 4, false);
436 ImageProcessing::Resize(target, source);
437 ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 10));
438 ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 20));
439 ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 1, 10));
440 ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 1, 20));
441 ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 2, 30));
442 ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 2, 40));
443 ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 3, 30));
444 ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 3, 40));
445 }
446
447 {
448 Image target(PixelFormat_Grayscale8, 4, 2, false);
449 ImageProcessing::Resize(target, source);
450 ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 10));
451 ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 10));
452 ASSERT_TRUE(TestGrayscale8Pixel(target, 2, 0, 20));
453 ASSERT_TRUE(TestGrayscale8Pixel(target, 3, 0, 20));
454 ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 1, 30));
455 ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 1, 30));
456 ASSERT_TRUE(TestGrayscale8Pixel(target, 2, 1, 40));
457 ASSERT_TRUE(TestGrayscale8Pixel(target, 3, 1, 40));
458 }
459 }
460
461
462 TEST(ImageProcessing, ResizeBasicRGB24)
463 {
464 Image source(PixelFormat_RGB24, 2, 2, false);
465 SetRGB24Pixel(source, 0, 0, 10, 100, 110);
466 SetRGB24Pixel(source, 1, 0, 20, 100, 110);
467 SetRGB24Pixel(source, 0, 1, 30, 100, 110);
468 SetRGB24Pixel(source, 1, 1, 40, 100, 110);
469
470 {
471 Image target(PixelFormat_RGB24, 2, 4, false);
472 ImageProcessing::Resize(target, source);
473 ASSERT_TRUE(TestRGB24Pixel(target, 0, 0, 10, 100, 110));
474 ASSERT_TRUE(TestRGB24Pixel(target, 1, 0, 20, 100, 110));
475 ASSERT_TRUE(TestRGB24Pixel(target, 0, 1, 10, 100, 110));
476 ASSERT_TRUE(TestRGB24Pixel(target, 1, 1, 20, 100, 110));
477 ASSERT_TRUE(TestRGB24Pixel(target, 0, 2, 30, 100, 110));
478 ASSERT_TRUE(TestRGB24Pixel(target, 1, 2, 40, 100, 110));
479 ASSERT_TRUE(TestRGB24Pixel(target, 0, 3, 30, 100, 110));
480 ASSERT_TRUE(TestRGB24Pixel(target, 1, 3, 40, 100, 110));
481 }
482
483 {
484 Image target(PixelFormat_RGB24, 4, 2, false);
485 ImageProcessing::Resize(target, source);
486 ASSERT_TRUE(TestRGB24Pixel(target, 0, 0, 10, 100, 110));
487 ASSERT_TRUE(TestRGB24Pixel(target, 1, 0, 10, 100, 110));
488 ASSERT_TRUE(TestRGB24Pixel(target, 2, 0, 20, 100, 110));
489 ASSERT_TRUE(TestRGB24Pixel(target, 3, 0, 20, 100, 110));
490 ASSERT_TRUE(TestRGB24Pixel(target, 0, 1, 30, 100, 110));
491 ASSERT_TRUE(TestRGB24Pixel(target, 1, 1, 30, 100, 110));
492 ASSERT_TRUE(TestRGB24Pixel(target, 2, 1, 40, 100, 110));
493 ASSERT_TRUE(TestRGB24Pixel(target, 3, 1, 40, 100, 110));
494 }
495 }
496
497
498 TEST(ImageProcessing, ResizeEmptyGrayscale8)
499 {
500 {
501 Image source(PixelFormat_Grayscale8, 0, 0, false);
502 Image target(PixelFormat_Grayscale8, 2, 2, false);
503 ImageProcessing::Resize(target, source);
504 ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 0));
505 ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 0));
506 ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 1, 0));
507 ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 1, 0));
508 }
509
510 {
511 Image source(PixelFormat_Grayscale8, 2, 2, false);
512 Image target(PixelFormat_Grayscale8, 0, 0, false);
513 ImageProcessing::Resize(target, source);
514 }
515 }
516
517
518 TEST(ImageProcessing, Convolution)
519 {
520 std::vector<float> k1(5, 1);
521 std::vector<float> k2(1, 1);
522
523 {
524 Image image(PixelFormat_Grayscale8, 1, 1, false);
525 SetGrayscale8Pixel(image, 0, 0, 100);
526 ImageProcessing::SeparableConvolution(image, k1, 2, k2, 0);
527 ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 100));
528 ImageProcessing::SeparableConvolution(image, k1, 2, k1, 2);
529 ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 100));
530 ImageProcessing::SeparableConvolution(image, k2, 0, k1, 2);
531 ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 100));
532 ImageProcessing::SeparableConvolution(image, k2, 0, k2, 0);
533 ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 100));
534 }
535
536 {
537 Image image(PixelFormat_RGB24, 1, 1, false);
538 SetRGB24Pixel(image, 0, 0, 10, 20, 30);
539 ImageProcessing::SeparableConvolution(image, k1, 2, k2, 0);
540 ASSERT_TRUE(TestRGB24Pixel(image, 0, 0, 10, 20, 30));
541 ImageProcessing::SeparableConvolution(image, k1, 2, k1, 2);
542 ASSERT_TRUE(TestRGB24Pixel(image, 0, 0, 10, 20, 30));
543 ImageProcessing::SeparableConvolution(image, k2, 0, k1, 2);
544 ASSERT_TRUE(TestRGB24Pixel(image, 0, 0, 10, 20, 30));
545 ImageProcessing::SeparableConvolution(image, k2, 0, k2, 0);
546 ASSERT_TRUE(TestRGB24Pixel(image, 0, 0, 10, 20, 30));
547 }
548
549 {
550 Image dirac(PixelFormat_Grayscale8, 9, 1, false);
551 ImageProcessing::Set(dirac, 0);
552 SetGrayscale8Pixel(dirac, 4, 0, 100);
553
554 {
555 std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
556 ImageProcessing::SeparableConvolution(*image, k1, 2, k2, 0);
557 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 0, 0));
558 ASSERT_TRUE(TestGrayscale8Pixel(*image, 1, 0, 0));
559 ASSERT_TRUE(TestGrayscale8Pixel(*image, 2, 0, 20));
560 ASSERT_TRUE(TestGrayscale8Pixel(*image, 3, 0, 20));
561 ASSERT_TRUE(TestGrayscale8Pixel(*image, 4, 0, 20));
562 ASSERT_TRUE(TestGrayscale8Pixel(*image, 5, 0, 20));
563 ASSERT_TRUE(TestGrayscale8Pixel(*image, 6, 0, 20));
564 ASSERT_TRUE(TestGrayscale8Pixel(*image, 7, 0, 0));
565 ASSERT_TRUE(TestGrayscale8Pixel(*image, 8, 0, 0));
566 }
567
568 {
569 std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
570 ImageProcessing::SeparableConvolution(*image, k2, 0, k1, 2);
571 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 0, 0));
572 ASSERT_TRUE(TestGrayscale8Pixel(*image, 1, 0, 0));
573 ASSERT_TRUE(TestGrayscale8Pixel(*image, 2, 0, 0));
574 ASSERT_TRUE(TestGrayscale8Pixel(*image, 3, 0, 0));
575 ASSERT_TRUE(TestGrayscale8Pixel(*image, 4, 0, 100));
576 ASSERT_TRUE(TestGrayscale8Pixel(*image, 5, 0, 0));
577 ASSERT_TRUE(TestGrayscale8Pixel(*image, 6, 0, 0));
578 ASSERT_TRUE(TestGrayscale8Pixel(*image, 7, 0, 0));
579 ASSERT_TRUE(TestGrayscale8Pixel(*image, 8, 0, 0));
580 }
581
582 {
583 std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
584 ImageProcessing::SeparableConvolution(*image, k2, 0, k2, 0);
585 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 0, 0));
586 ASSERT_TRUE(TestGrayscale8Pixel(*image, 1, 0, 0));
587 ASSERT_TRUE(TestGrayscale8Pixel(*image, 2, 0, 0));
588 ASSERT_TRUE(TestGrayscale8Pixel(*image, 3, 0, 0));
589 ASSERT_TRUE(TestGrayscale8Pixel(*image, 4, 0, 100));
590 ASSERT_TRUE(TestGrayscale8Pixel(*image, 5, 0, 0));
591 ASSERT_TRUE(TestGrayscale8Pixel(*image, 6, 0, 0));
592 ASSERT_TRUE(TestGrayscale8Pixel(*image, 7, 0, 0));
593 ASSERT_TRUE(TestGrayscale8Pixel(*image, 8, 0, 0));
594 }
595 }
596
597 {
598 Image dirac(PixelFormat_Grayscale8, 1, 9, false);
599 ImageProcessing::Set(dirac, 0);
600 SetGrayscale8Pixel(dirac, 0, 4, 100);
601
602 {
603 std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
604 ImageProcessing::SeparableConvolution(*image, k2, 0, k1, 2);
605 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 0, 0));
606 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 1, 0));
607 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 2, 20));
608 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 3, 20));
609 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 4, 20));
610 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 5, 20));
611 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 6, 20));
612 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 7, 0));
613 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 8, 0));
614 }
615
616 {
617 std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
618 ImageProcessing::SeparableConvolution(*image, k1, 2, k2, 0);
619 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 0, 0));
620 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 1, 0));
621 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 2, 0));
622 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 3, 0));
623 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 4, 100));
624 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 5, 0));
625 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 6, 0));
626 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 7, 0));
627 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 8, 0));
628 }
629
630 {
631 std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
632 ImageProcessing::SeparableConvolution(*image, k2, 0, k2, 0);
633 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 0, 0));
634 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 1, 0));
635 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 2, 0));
636 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 3, 0));
637 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 4, 100));
638 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 5, 0));
639 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 6, 0));
640 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 7, 0));
641 ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 8, 0));
642 }
643 }
644
645 {
646 Image dirac(PixelFormat_RGB24, 9, 1, false);
647 ImageProcessing::Set(dirac, 0);
648 SetRGB24Pixel(dirac, 4, 0, 100, 120, 140);
649
650 {
651 std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
652 ImageProcessing::SeparableConvolution(*image, k1, 2, k2, 0);
653 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 0, 0, 0, 0));
654 ASSERT_TRUE(TestRGB24Pixel(*image, 1, 0, 0, 0, 0));
655 ASSERT_TRUE(TestRGB24Pixel(*image, 2, 0, 20, 24, 28));
656 ASSERT_TRUE(TestRGB24Pixel(*image, 3, 0, 20, 24, 28));
657 ASSERT_TRUE(TestRGB24Pixel(*image, 4, 0, 20, 24, 28));
658 ASSERT_TRUE(TestRGB24Pixel(*image, 5, 0, 20, 24, 28));
659 ASSERT_TRUE(TestRGB24Pixel(*image, 6, 0, 20, 24, 28));
660 ASSERT_TRUE(TestRGB24Pixel(*image, 7, 0, 0, 0, 0));
661 ASSERT_TRUE(TestRGB24Pixel(*image, 8, 0, 0, 0, 0));
662 }
663
664 {
665 std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
666 ImageProcessing::SeparableConvolution(*image, k2, 0, k1, 2);
667 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 0, 0, 0, 0));
668 ASSERT_TRUE(TestRGB24Pixel(*image, 1, 0, 0, 0, 0));
669 ASSERT_TRUE(TestRGB24Pixel(*image, 2, 0, 0, 0, 0));
670 ASSERT_TRUE(TestRGB24Pixel(*image, 3, 0, 0, 0, 0));
671 ASSERT_TRUE(TestRGB24Pixel(*image, 4, 0, 100, 120, 140));
672 ASSERT_TRUE(TestRGB24Pixel(*image, 5, 0, 0, 0, 0));
673 ASSERT_TRUE(TestRGB24Pixel(*image, 6, 0, 0, 0, 0));
674 ASSERT_TRUE(TestRGB24Pixel(*image, 7, 0, 0, 0, 0));
675 ASSERT_TRUE(TestRGB24Pixel(*image, 8, 0, 0, 0, 0));
676 }
677
678 {
679 std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
680 ImageProcessing::SeparableConvolution(*image, k2, 0, k2, 0);
681 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 0, 0, 0, 0));
682 ASSERT_TRUE(TestRGB24Pixel(*image, 1, 0, 0, 0, 0));
683 ASSERT_TRUE(TestRGB24Pixel(*image, 2, 0, 0, 0, 0));
684 ASSERT_TRUE(TestRGB24Pixel(*image, 3, 0, 0, 0, 0));
685 ASSERT_TRUE(TestRGB24Pixel(*image, 4, 0, 100, 120, 140));
686 ASSERT_TRUE(TestRGB24Pixel(*image, 5, 0, 0, 0, 0));
687 ASSERT_TRUE(TestRGB24Pixel(*image, 6, 0, 0, 0, 0));
688 ASSERT_TRUE(TestRGB24Pixel(*image, 7, 0, 0, 0, 0));
689 ASSERT_TRUE(TestRGB24Pixel(*image, 8, 0, 0, 0, 0));
690 }
691 }
692
693 {
694 Image dirac(PixelFormat_RGB24, 1, 9, false);
695 ImageProcessing::Set(dirac, 0);
696 SetRGB24Pixel(dirac, 0, 4, 100, 120, 140);
697
698 {
699 std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
700 ImageProcessing::SeparableConvolution(*image, k2, 0, k1, 2);
701 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 0, 0, 0, 0));
702 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 1, 0, 0, 0));
703 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 2, 20, 24, 28));
704 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 3, 20, 24, 28));
705 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 4, 20, 24, 28));
706 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 5, 20, 24, 28));
707 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 6, 20, 24, 28));
708 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 7, 0, 0, 0));
709 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 8, 0, 0, 0));
710 }
711
712 {
713 std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
714 ImageProcessing::SeparableConvolution(*image, k1, 2, k2, 0);
715 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 0, 0, 0, 0));
716 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 1, 0, 0, 0));
717 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 2, 0, 0, 0));
718 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 3, 0, 0, 0));
719 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 4, 100, 120, 140));
720 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 5, 0, 0, 0));
721 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 6, 0, 0, 0));
722 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 7, 0, 0, 0));
723 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 8, 0, 0, 0));
724 }
725
726 {
727 std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
728 ImageProcessing::SeparableConvolution(*image, k2, 0, k2, 0);
729 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 0, 0, 0, 0));
730 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 1, 0, 0, 0));
731 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 2, 0, 0, 0));
732 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 3, 0, 0, 0));
733 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 4, 100, 120, 140));
734 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 5, 0, 0, 0));
735 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 6, 0, 0, 0));
736 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 7, 0, 0, 0));
737 ASSERT_TRUE(TestRGB24Pixel(*image, 0, 8, 0, 0, 0));
738 }
739 }
740 }
741
742
743 TEST(ImageProcessing, SmoothGaussian5x5)
744 {
745 /**
746 Test the point spread function, as can be seen in Octave:
747 g1 = [ 1 4 6 4 1 ];
748 g1 /= sum(g1);
749 g2 = conv2(g1, g1');
750 floor(conv2(diag([ 0 0 100 0 0 ]), g2, 'same')) % red/green channels
751 floor(conv2(diag([ 0 0 200 0 0 ]), g2, 'same')) % blue channel
752 **/
753
754 {
755 Image image(PixelFormat_Grayscale8, 5, 5, false);
756 ImageProcessing::Set(image, 0);
757 SetGrayscale8Pixel(image, 2, 2, 100);
758 ImageProcessing::SmoothGaussian5x5(image);
759
760 ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 0));
761 ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 0, 1));
762 ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 0, 2));
763 ASSERT_TRUE(TestGrayscale8Pixel(image, 3, 0, 1));
764 ASSERT_TRUE(TestGrayscale8Pixel(image, 4, 0, 0));
765 ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 1, 1));
766 ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 1, 6));
767 ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 1, 9));
768 ASSERT_TRUE(TestGrayscale8Pixel(image, 3, 1, 6));
769 ASSERT_TRUE(TestGrayscale8Pixel(image, 4, 1, 1));
770 ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 2, 2));
771 ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 2, 9));
772 ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 2, 14));
773 ASSERT_TRUE(TestGrayscale8Pixel(image, 3, 2, 9));
774 ASSERT_TRUE(TestGrayscale8Pixel(image, 4, 2, 2));
775 ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 3, 1));
776 ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 3, 6));
777 ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 3, 9));
778 ASSERT_TRUE(TestGrayscale8Pixel(image, 3, 3, 6));
779 ASSERT_TRUE(TestGrayscale8Pixel(image, 4, 3, 1));
780 ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 4, 0));
781 ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 4, 1));
782 ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 4, 2));
783 ASSERT_TRUE(TestGrayscale8Pixel(image, 3, 4, 1));
784 ASSERT_TRUE(TestGrayscale8Pixel(image, 4, 4, 0));
785 }
786
787 {
788 Image image(PixelFormat_RGB24, 5, 5, false);
789 ImageProcessing::Set(image, 0);
790 SetRGB24Pixel(image, 2, 2, 100, 100, 200);
791 ImageProcessing::SmoothGaussian5x5(image);
792
793 ASSERT_TRUE(TestRGB24Pixel(image, 0, 0, 0, 0, 0));
794 ASSERT_TRUE(TestRGB24Pixel(image, 1, 0, 1, 1, 3));
795 ASSERT_TRUE(TestRGB24Pixel(image, 2, 0, 2, 2, 4));
796 ASSERT_TRUE(TestRGB24Pixel(image, 3, 0, 1, 1, 3));
797 ASSERT_TRUE(TestRGB24Pixel(image, 4, 0, 0, 0, 0));
798 ASSERT_TRUE(TestRGB24Pixel(image, 0, 1, 1, 1, 3));
799 ASSERT_TRUE(TestRGB24Pixel(image, 1, 1, 6, 6, 12));
800 ASSERT_TRUE(TestRGB24Pixel(image, 2, 1, 9, 9, 18));
801 ASSERT_TRUE(TestRGB24Pixel(image, 3, 1, 6, 6, 12));
802 ASSERT_TRUE(TestRGB24Pixel(image, 4, 1, 1, 1, 3));
803 ASSERT_TRUE(TestRGB24Pixel(image, 0, 2, 2, 2, 4));
804 ASSERT_TRUE(TestRGB24Pixel(image, 1, 2, 9, 9, 18));
805 ASSERT_TRUE(TestRGB24Pixel(image, 2, 2, 14, 14, 28));
806 ASSERT_TRUE(TestRGB24Pixel(image, 3, 2, 9, 9, 18));
807 ASSERT_TRUE(TestRGB24Pixel(image, 4, 2, 2, 2, 4));
808 ASSERT_TRUE(TestRGB24Pixel(image, 0, 3, 1, 1, 3));
809 ASSERT_TRUE(TestRGB24Pixel(image, 1, 3, 6, 6, 12));
810 ASSERT_TRUE(TestRGB24Pixel(image, 2, 3, 9, 9, 18));
811 ASSERT_TRUE(TestRGB24Pixel(image, 3, 3, 6, 6, 12));
812 ASSERT_TRUE(TestRGB24Pixel(image, 4, 3, 1, 1, 3));
813 ASSERT_TRUE(TestRGB24Pixel(image, 0, 4, 0, 0, 0));
814 ASSERT_TRUE(TestRGB24Pixel(image, 1, 4, 1, 1, 3));
815 ASSERT_TRUE(TestRGB24Pixel(image, 2, 4, 2, 2, 4));
816 ASSERT_TRUE(TestRGB24Pixel(image, 3, 4, 1, 1, 3));
817 ASSERT_TRUE(TestRGB24Pixel(image, 4, 4, 0, 0, 0));
818 }
819 }
820
821 TEST(ImageProcessing, ApplyWindowingFloatToGrayScale8)
822 {
823 {
824 Image image(PixelFormat_Float32, 6, 1, false);
825 ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, -5.0f, 0, 0);
826 ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 0.0f, 1, 0);
827 ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 5.0f, 2, 0);
828 ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 10.0f, 3, 0);
829 ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 1000.0f, 4, 0);
830 ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 2.0f, 5, 0);
831
832 {
833 Image target(PixelFormat_Grayscale8, 6, 1, false);
834 ImageProcessing::ApplyWindowing_Deprecated(target, image, 5.0f, 10.0f, 1.0f, 0.0f, false);
835
836 ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 0));
837 ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 0));
838 ASSERT_TRUE(TestGrayscale8Pixel(target, 2, 0, 128));
839 ASSERT_TRUE(TestGrayscale8Pixel(target, 3, 0, 255));
840 ASSERT_TRUE(TestGrayscale8Pixel(target, 4, 0, 255));
841 ASSERT_TRUE(TestGrayscale8Pixel(target, 5, 0, 255*2/10));
842 }
843
844 {
845 Image target(PixelFormat_Grayscale8, 6, 1, false);
846 ImageProcessing::ApplyWindowing_Deprecated(target, image, 5.0f, 10.0f, 1.0f, 0.0f, true);
847
848 ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 255));
849 ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 255));
850 ASSERT_TRUE(TestGrayscale8Pixel(target, 2, 0, 127));
851 ASSERT_TRUE(TestGrayscale8Pixel(target, 3, 0, 0));
852 ASSERT_TRUE(TestGrayscale8Pixel(target, 4, 0, 0));
853 ASSERT_TRUE(TestGrayscale8Pixel(target, 5, 0, 255 - 255*2/10));
854 }
855
856 {
857 Image target(PixelFormat_Grayscale8, 6, 1, false);
858 ImageProcessing::ApplyWindowing_Deprecated(target, image, 5000.0f, 10000.01f, 1000.0f, 0.0f, false);
859
860 ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 0));
861 ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 0));
862 ASSERT_TRUE(TestGrayscale8Pixel(target, 2, 0, 128));
863 ASSERT_TRUE(TestGrayscale8Pixel(target, 3, 0, 255));
864 ASSERT_TRUE(TestGrayscale8Pixel(target, 4, 0, 255));
865 ASSERT_TRUE(TestGrayscale8Pixel(target, 5, 0, 255*2/10));
866 }
867
868 {
869 Image target(PixelFormat_Grayscale8, 6, 1, false);
870 ImageProcessing::ApplyWindowing_Deprecated(target, image, 5000.0f, 10000.01f, 1000.0f, 0.0f, true);
871
872 ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 255));
873 ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 255));
874 ASSERT_TRUE(TestGrayscale8Pixel(target, 2, 0, 127));
875 ASSERT_TRUE(TestGrayscale8Pixel(target, 3, 0, 0));
876 ASSERT_TRUE(TestGrayscale8Pixel(target, 4, 0, 0));
877 ASSERT_TRUE(TestGrayscale8Pixel(target, 5, 0, 255 - 256*2/10));
878 }
879
880 {
881 Image target(PixelFormat_Grayscale8, 6, 1, false);
882 ImageProcessing::ApplyWindowing_Deprecated(target, image, 50.0f, 100.1f, 10.0f, 30.0f, false);
883
884 ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 0)); // (-5 * 10) + 30 => pixel value = -20 => 0
885 ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 256*30/100)); // ((0 * 10) + 30 => pixel value = 30 => 30%
886 ASSERT_TRUE(TestGrayscale8Pixel(target, 2, 0, 256*80/100)); // ((5 * 10) + 30 => pixel value = 80 => 80%
887 ASSERT_TRUE(TestGrayscale8Pixel(target, 3, 0, 255)); // ((10 * 10) + 30 => pixel value = 130 => 100%
888 ASSERT_TRUE(TestGrayscale8Pixel(target, 4, 0, 255)); // ((1000 * 10) + 30 => pixel value = 10030 => 100%
889 ASSERT_TRUE(TestGrayscale8Pixel(target, 5, 0, 128)); // ((2 * 10) + 30 => pixel value = 50 => 50%
890 }
891
892 }
893 }
894
895 TEST(ImageProcessing, ApplyWindowingFloatToGrayScale16)
896 {
897 {
898 Image image(PixelFormat_Float32, 6, 1, false);
899 ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, -5.0f, 0, 0);
900 ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 0.0f, 1, 0);
901 ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 5.0f, 2, 0);
902 ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 10.0f, 3, 0);
903 ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 1000.0f, 4, 0);
904 ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 2.0f, 5, 0);
905
906 {
907 Image target(PixelFormat_Grayscale16, 6, 1, false);
908 ImageProcessing::ApplyWindowing_Deprecated(target, image, 5.0f, 10.0f, 1.0f, 0.0f, false);
909
910 ASSERT_TRUE(TestGrayscale16Pixel(target, 0, 0, 0));
911 ASSERT_TRUE(TestGrayscale16Pixel(target, 1, 0, 0));
912 ASSERT_TRUE(TestGrayscale16Pixel(target, 2, 0, 32768));
913 ASSERT_TRUE(TestGrayscale16Pixel(target, 3, 0, 65535));
914 ASSERT_TRUE(TestGrayscale16Pixel(target, 4, 0, 65535));
915 ASSERT_TRUE(TestGrayscale16Pixel(target, 5, 0, 65536*2/10));
916 }
917 }
918 }
919
920 TEST(ImageProcessing, ApplyWindowingGrayScale8ToGrayScale16)
921 {
922 {
923 Image image(PixelFormat_Grayscale8, 5, 1, false);
924 SetGrayscale8Pixel(image, 0, 0, 0);
925 SetGrayscale8Pixel(image, 1, 0, 2);
926 SetGrayscale8Pixel(image, 2, 0, 5);
927 SetGrayscale8Pixel(image, 3, 0, 10);
928 SetGrayscale8Pixel(image, 4, 0, 255);
929
930 {
931 Image target(PixelFormat_Grayscale16, 5, 1, false);
932 ImageProcessing::ApplyWindowing_Deprecated(target, image, 5.0f, 10.0f, 1.0f, 0.0f, false);
933
934 ASSERT_TRUE(TestGrayscale16Pixel(target, 0, 0, 0));
935 ASSERT_TRUE(TestGrayscale16Pixel(target, 1, 0, 65536*2/10));
936 ASSERT_TRUE(TestGrayscale16Pixel(target, 2, 0, 65536*5/10));
937 ASSERT_TRUE(TestGrayscale16Pixel(target, 3, 0, 65535));
938 ASSERT_TRUE(TestGrayscale16Pixel(target, 4, 0, 65535));
939 }
940 }
941 }
942
943 TEST(ImageProcessing, ApplyWindowingGrayScale16ToGrayScale16)
944 {
945 {
946 Image image(PixelFormat_Grayscale16, 5, 1, false);
947 SetGrayscale16Pixel(image, 0, 0, 0);
948 SetGrayscale16Pixel(image, 1, 0, 2);
949 SetGrayscale16Pixel(image, 2, 0, 5);
950 SetGrayscale16Pixel(image, 3, 0, 10);
951 SetGrayscale16Pixel(image, 4, 0, 255);
952
953 {
954 Image target(PixelFormat_Grayscale16, 5, 1, false);
955 ImageProcessing::ApplyWindowing_Deprecated(target, image, 5.0f, 10.0f, 1.0f, 0.0f, false);
956
957 ASSERT_TRUE(TestGrayscale16Pixel(target, 0, 0, 0));
958 ASSERT_TRUE(TestGrayscale16Pixel(target, 1, 0, 65536*2/10));
959 ASSERT_TRUE(TestGrayscale16Pixel(target, 2, 0, 65536*5/10));
960 ASSERT_TRUE(TestGrayscale16Pixel(target, 3, 0, 65535));
961 ASSERT_TRUE(TestGrayscale16Pixel(target, 4, 0, 65535));
962 }
963 }
964 }
965
966
967 TEST(ImageProcessing, ShiftScaleGrayscale8)
968 {
969 Image image(PixelFormat_Grayscale8, 5, 1, false);
970 SetGrayscale8Pixel(image, 0, 0, 0);
971 SetGrayscale8Pixel(image, 1, 0, 2);
972 SetGrayscale8Pixel(image, 2, 0, 5);
973 SetGrayscale8Pixel(image, 3, 0, 10);
974 SetGrayscale8Pixel(image, 4, 0, 255);
975
976 ImageProcessing::ShiftScale(image, -1.1, 1.5, true);
977 ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 0));
978 ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 0, 1));
979 ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 0, 6));
980 ASSERT_TRUE(TestGrayscale8Pixel(image, 3, 0, 13));
981 ASSERT_TRUE(TestGrayscale8Pixel(image, 4, 0, 255));
982 }
983
984
985 TEST(ImageProcessing, ShiftScaleGrayscale16)
986 {
987 Image image(PixelFormat_Grayscale16, 5, 1, false);
988 SetGrayscale16Pixel(image, 0, 0, 0);
989 SetGrayscale16Pixel(image, 1, 0, 2);
990 SetGrayscale16Pixel(image, 2, 0, 5);
991 SetGrayscale16Pixel(image, 3, 0, 10);
992 SetGrayscale16Pixel(image, 4, 0, 255);
993
994 ImageProcessing::ShiftScale(image, -1.1, 1.5, true);
995 ASSERT_TRUE(TestGrayscale16Pixel(image, 0, 0, 0));
996 ASSERT_TRUE(TestGrayscale16Pixel(image, 1, 0, 1));
997 ASSERT_TRUE(TestGrayscale16Pixel(image, 2, 0, 6));
998 ASSERT_TRUE(TestGrayscale16Pixel(image, 3, 0, 13));
999 ASSERT_TRUE(TestGrayscale16Pixel(image, 4, 0, 381));
1000 }
1001
1002
1003 TEST(ImageProcessing, ShiftScaleSignedGrayscale16)
1004 {
1005 Image image(PixelFormat_SignedGrayscale16, 5, 1, false);
1006 SetSignedGrayscale16Pixel(image, 0, 0, 0);
1007 SetSignedGrayscale16Pixel(image, 1, 0, 2);
1008 SetSignedGrayscale16Pixel(image, 2, 0, 5);
1009 SetSignedGrayscale16Pixel(image, 3, 0, 10);
1010 SetSignedGrayscale16Pixel(image, 4, 0, 255);
1011
1012 ImageProcessing::ShiftScale(image, -17.1, 11.5, true);
1013 ASSERT_TRUE(TestSignedGrayscale16Pixel(image, 0, 0, -197));
1014 ASSERT_TRUE(TestSignedGrayscale16Pixel(image, 1, 0, -174));
1015 ASSERT_TRUE(TestSignedGrayscale16Pixel(image, 2, 0, -139));
1016 ASSERT_TRUE(TestSignedGrayscale16Pixel(image, 3, 0, -82));
1017 ASSERT_TRUE(TestSignedGrayscale16Pixel(image, 4, 0, 2736));
1018 }