rohit/Orthanc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
ca33816a8c
Orthanc/OrthancFramework/UnitTestsSources/ImageProcessingTests.cpp
rohit 1fe2b563f2 DICOM test1
2025-06-23 19:07:37 +05:30

1552 lines
57 KiB
C++
Raw Blame History

/**
* Orthanc - A Lightweight, RESTful DICOM Store
* Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
* Department, University Hospital of Liege, Belgium
* Copyright (C) 2017-2023 Osimis S.A., Belgium
* Copyright (C) 2024-2025 Orthanc Team SRL, Belgium
* Copyright (C) 2021-2025 Sebastien Jodogne, ICTEAM UCLouvain, Belgium
*
* This program is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program. If not, see
* <http://www.gnu.org/licenses/>.
**/
#if ORTHANC_UNIT_TESTS_LINK_FRAMEWORK == 1
// Must be the first to be sure to use the Orthanc framework shared library
# include <OrthancFramework.h>
#endif
#include <gtest/gtest.h>
#include "../Sources/Compatibility.h"
#include "../Sources/DicomFormat/DicomImageInformation.h"
#include "../Sources/Images/Image.h"
#include "../Sources/Images/ImageProcessing.h"
#include "../Sources/Images/ImageTraits.h"
#include "../Sources/OrthancException.h"
#include <memory>
using namespace Orthanc;
TEST(DicomImageInformation, ExtractPixelFormat1)
{
// Cardiac/MR*
DicomMap m;
m.SetValue(DICOM_TAG_ROWS, "24", false);
m.SetValue(DICOM_TAG_COLUMNS, "16", false);
m.SetValue(DICOM_TAG_BITS_ALLOCATED, "16", false);
m.SetValue(DICOM_TAG_SAMPLES_PER_PIXEL, "1", false);
m.SetValue(DICOM_TAG_BITS_STORED, "12", false);
m.SetValue(DICOM_TAG_HIGH_BIT, "11", false);
m.SetValue(DICOM_TAG_PIXEL_REPRESENTATION, "0", false);
m.SetValue(DICOM_TAG_PHOTOMETRIC_INTERPRETATION, "MONOCHROME2", false);
DicomImageInformation info(m);
PixelFormat format;
ASSERT_TRUE(info.ExtractPixelFormat(format, false));
ASSERT_EQ(PixelFormat_Grayscale16, format);
}
TEST(DicomImageInformation, ExtractPixelFormat2)
{
// Delphine CT
DicomMap m;
m.SetValue(DICOM_TAG_ROWS, "24", false);
m.SetValue(DICOM_TAG_COLUMNS, "16", false);
m.SetValue(DICOM_TAG_BITS_ALLOCATED, "16", false);
m.SetValue(DICOM_TAG_SAMPLES_PER_PIXEL, "1", false);
m.SetValue(DICOM_TAG_BITS_STORED, "16", false);
m.SetValue(DICOM_TAG_HIGH_BIT, "15", false);
m.SetValue(DICOM_TAG_PIXEL_REPRESENTATION, "1", false);
m.SetValue(DICOM_TAG_PHOTOMETRIC_INTERPRETATION, "MONOCHROME2", false);
DicomImageInformation info(m);
PixelFormat format;
ASSERT_TRUE(info.ExtractPixelFormat(format, false));
ASSERT_EQ(PixelFormat_SignedGrayscale16, format);
}
TEST(DicomImageInformation, Windowing)
{
DicomMap m;
m.SetValue(DICOM_TAG_ROWS, "24", false);
m.SetValue(DICOM_TAG_COLUMNS, "16", false);
m.SetValue(DICOM_TAG_BITS_ALLOCATED, "16", false);
m.SetValue(DICOM_TAG_PHOTOMETRIC_INTERPRETATION, "MONOCHROME2", false);
{
DicomImageInformation info(m);
ASSERT_DOUBLE_EQ(1.0, info.GetRescaleSlope());
ASSERT_DOUBLE_EQ(0.0, info.GetRescaleIntercept());
ASSERT_EQ(PhotometricInterpretation_Monochrome2, info.GetPhotometricInterpretation());
ASSERT_EQ(0, info.GetWindowsCount());
ASSERT_DOUBLE_EQ(14.0, info.ApplyRescale(14.0));
}
m.SetValue(DICOM_TAG_RESCALE_SLOPE, "10.25", false);
m.SetValue(DICOM_TAG_RESCALE_INTERCEPT, "-1.75", false);
m.SetValue(DICOM_TAG_PHOTOMETRIC_INTERPRETATION, "MONOCHROME1", false);
{
DicomImageInformation info(m);
ASSERT_DOUBLE_EQ(10.25, info.GetRescaleSlope());
ASSERT_DOUBLE_EQ(-1.75, info.GetRescaleIntercept());
ASSERT_EQ(PhotometricInterpretation_Monochrome1, info.GetPhotometricInterpretation());
ASSERT_FALSE(info.HasWindows());
ASSERT_EQ(0, info.GetWindowsCount());
ASSERT_THROW(info.GetWindow(0), OrthancException);
ASSERT_DOUBLE_EQ(141.75, info.ApplyRescale(14.0));
}
m.SetValue(Orthanc::DICOM_TAG_WINDOW_CENTER, "10\\100\\1000", false);
m.SetValue(Orthanc::DICOM_TAG_WINDOW_WIDTH, "50\\60\\70", false);
{
DicomImageInformation info(m);
ASSERT_TRUE(info.HasWindows());
ASSERT_EQ(3u, info.GetWindowsCount());
ASSERT_DOUBLE_EQ(10.0, info.GetWindow(0).GetCenter());
ASSERT_DOUBLE_EQ(50.0, info.GetWindow(0).GetWidth());
ASSERT_DOUBLE_EQ(100.0, info.GetWindow(1).GetCenter());
ASSERT_DOUBLE_EQ(60.0, info.GetWindow(1).GetWidth());
ASSERT_DOUBLE_EQ(1000.0, info.GetWindow(2).GetCenter());
ASSERT_DOUBLE_EQ(70.0, info.GetWindow(2).GetWidth());
ASSERT_THROW(info.GetWindow(3), OrthancException);
}
}
TEST(DicomImageInformation, FromDcmtkTests)
{
// This replicates TEST(ParsedDicomFile, ImageInformation) in
// "FromDcmtkTests.cpp", without the handling of frames and sequences
DicomMap m;
m.SetValue(DICOM_TAG_ROWS, "24", false);
m.SetValue(DICOM_TAG_COLUMNS, "16", false);
m.SetValue(DICOM_TAG_BITS_ALLOCATED, "8", false);
{
DicomImageInformation info(m);
Window w = info.GetDefaultWindow();
ASSERT_DOUBLE_EQ(128.0, w.GetCenter());
ASSERT_DOUBLE_EQ(256.0, w.GetWidth());
ASSERT_EQ(PhotometricInterpretation_Unknown, info.GetPhotometricInterpretation());
ASSERT_DOUBLE_EQ(0.0, info.GetRescaleIntercept());
ASSERT_DOUBLE_EQ(1.0, info.GetRescaleSlope());
double offset, scaling, x;
info.ComputeRenderingTransform(offset, scaling, Window(-100, 200));
x = -200; ASSERT_NEAR(0, x * scaling + offset, 0.000001);
x = -100; ASSERT_NEAR(127.5, x * scaling + offset, 0.000001);
x = 0; ASSERT_NEAR(255, x * scaling + offset, 0.000001);
}
m.SetValue(DICOM_TAG_PHOTOMETRIC_INTERPRETATION, "MONOCHROME1", false);
{
DicomImageInformation info(m);
ASSERT_EQ(PhotometricInterpretation_Monochrome1, info.GetPhotometricInterpretation());
double offset, scaling, x;
info.ComputeRenderingTransform(offset, scaling, Window(-100, 200));
x = -200; ASSERT_NEAR(255, x * scaling + offset, 0.000001);
x = -100; ASSERT_NEAR(127.5, x * scaling + offset, 0.000001);
x = 0; ASSERT_NEAR(0, x * scaling + offset, 0.000001);
}
m.SetValue(DICOM_TAG_PHOTOMETRIC_INTERPRETATION, "MONOCHROME2", false);
m.SetValue(DICOM_TAG_RESCALE_SLOPE, "20", false);
m.SetValue(DICOM_TAG_RESCALE_INTERCEPT, "-100", false);
{
DicomImageInformation info(m);
ASSERT_EQ(PhotometricInterpretation_Monochrome2, info.GetPhotometricInterpretation());
double offset, scaling, x;
info.ComputeRenderingTransform(offset, scaling, Window(-100, 200));
x = -5; ASSERT_NEAR(0, x * scaling + offset, 0.000001);
x = 0; ASSERT_NEAR(127.5, x * scaling + offset, 0.000001);
x = 5; ASSERT_NEAR(255, x * scaling + offset, 0.000001);
}
m.SetValue(DICOM_TAG_PHOTOMETRIC_INTERPRETATION, "MONOCHROME1", false);
{
DicomImageInformation info(m);
ASSERT_EQ(PhotometricInterpretation_Monochrome1, info.GetPhotometricInterpretation());
double offset, scaling, x;
info.ComputeRenderingTransform(offset, scaling, Window(-100, 200));
x = -5; ASSERT_NEAR(255, x * scaling + offset, 0.000001);
x = 0; ASSERT_NEAR(127.5, x * scaling + offset, 0.000001);
x = 5; ASSERT_NEAR(0, x * scaling + offset, 0.000001);
}
m.SetValue(DICOM_TAG_PHOTOMETRIC_INTERPRETATION, "RGB", false);
m.SetValue(DICOM_TAG_BITS_STORED, "4", false);
{
DicomImageInformation info(m);
Window w = info.GetDefaultWindow();
ASSERT_DOUBLE_EQ(8.0, w.GetCenter());
ASSERT_DOUBLE_EQ(16.0, w.GetWidth());
ASSERT_EQ(PhotometricInterpretation_RGB, info.GetPhotometricInterpretation());
}
m.SetValue(DICOM_TAG_WINDOW_CENTER, "12", false);
m.SetValue(DICOM_TAG_WINDOW_WIDTH, "-22", false);
m.SetValue(DICOM_TAG_RESCALE_INTERCEPT, "-22", false);
m.SetValue(DICOM_TAG_RESCALE_SLOPE, "-23", false);
{
DicomImageInformation info(m);
Window w = info.GetDefaultWindow();
ASSERT_DOUBLE_EQ(12.0, w.GetCenter());
ASSERT_DOUBLE_EQ(22.0, w.GetWidth());
ASSERT_DOUBLE_EQ(-22.0, info.GetRescaleIntercept());
ASSERT_DOUBLE_EQ(-23.0, info.GetRescaleSlope());
}
m.Remove(DICOM_TAG_RESCALE_SLOPE);
m.Remove(DICOM_TAG_RESCALE_INTERCEPT);
m.SetValue(DICOM_TAG_WINDOW_CENTER, "12\\13\\14", false);
m.SetValue(DICOM_TAG_WINDOW_WIDTH, "-22\\-23\\-24", false);
m.SetValue(DICOM_TAG_RESCALE_INTERCEPT, "-22\\33\\34", false);
m.SetValue(DICOM_TAG_RESCALE_SLOPE, "-23\\-43\\-44", false);
{
DicomImageInformation info(m);
Window w = info.GetDefaultWindow();
ASSERT_DOUBLE_EQ(12.0, w.GetCenter());
ASSERT_DOUBLE_EQ(22.0, w.GetWidth());
ASSERT_DOUBLE_EQ(0.0, info.GetRescaleIntercept());
ASSERT_DOUBLE_EQ(1.0, info.GetRescaleSlope());
}
}
namespace
{
template <typename T>
class TestImageTraits : public ::testing::Test
{
private:
std::unique_ptr<Image> image_;
protected:
virtual void SetUp() ORTHANC_OVERRIDE
{
image_.reset(new Image(ImageTraits::PixelTraits::GetPixelFormat(), 7, 9, false));
}
virtual void TearDown() ORTHANC_OVERRIDE
{
image_.reset(NULL);
}
public:
typedef T ImageTraits;
ImageAccessor& GetImage()
{
return *image_;
}
};
template <typename T>
class TestIntegerImageTraits : public TestImageTraits<T>
{
};
}
typedef ::testing::Types<
ImageTraits<PixelFormat_Grayscale8>,
ImageTraits<PixelFormat_Grayscale16>,
ImageTraits<PixelFormat_SignedGrayscale16>
> IntegerFormats;
TYPED_TEST_CASE(TestIntegerImageTraits, IntegerFormats);
typedef ::testing::Types<
ImageTraits<PixelFormat_Grayscale8>,
ImageTraits<PixelFormat_Grayscale16>,
ImageTraits<PixelFormat_SignedGrayscale16>,
ImageTraits<PixelFormat_RGB24>,
ImageTraits<PixelFormat_BGRA32>
> AllFormats;
TYPED_TEST_CASE(TestImageTraits, AllFormats);
TYPED_TEST(TestImageTraits, SetZero)
{
ImageAccessor& image = this->GetImage();
memset(image.GetBuffer(), 128, image.GetHeight() * image.GetWidth());
switch (image.GetFormat())
{
case PixelFormat_Grayscale8:
case PixelFormat_Grayscale16:
case PixelFormat_SignedGrayscale16:
ImageProcessing::Set(image, 0);
break;
case PixelFormat_RGB24:
case PixelFormat_BGRA32:
ImageProcessing::Set(image, 0, 0, 0, 0);
break;
default:
ASSERT_TRUE(0);
}
typename TestFixture::ImageTraits::PixelType zero, value;
TestFixture::ImageTraits::PixelTraits::SetZero(zero);
for (unsigned int y = 0; y < image.GetHeight(); y++)
{
for (unsigned int x = 0; x < image.GetWidth(); x++)
{
TestFixture::ImageTraits::GetPixel(value, image, x, y);
ASSERT_TRUE(TestFixture::ImageTraits::PixelTraits::IsEqual(zero, value));
}
}
}
TYPED_TEST(TestIntegerImageTraits, SetZeroFloat)
{
ImageAccessor& image = this->GetImage();
memset(image.GetBuffer(), 128, image.GetHeight() * image.GetWidth());
float c = 0.0f;
for (unsigned int y = 0; y < image.GetHeight(); y++)
{
for (unsigned int x = 0; x < image.GetWidth(); x++, c++)
{
TestFixture::ImageTraits::SetFloatPixel(image, c, x, y);
}
}
c = 0.0f;
for (unsigned int y = 0; y < image.GetHeight(); y++)
{
for (unsigned int x = 0; x < image.GetWidth(); x++, c++)
{
ASSERT_FLOAT_EQ(c, TestFixture::ImageTraits::GetFloatPixel(image, x, y));
}
}
}
TYPED_TEST(TestIntegerImageTraits, FillPolygon)
{
ImageAccessor& image = this->GetImage();
ImageProcessing::Set(image, 128);
// draw a triangle
std::vector<ImageProcessing::ImagePoint> points;
points.push_back(ImageProcessing::ImagePoint(1,1));
points.push_back(ImageProcessing::ImagePoint(1,5));
points.push_back(ImageProcessing::ImagePoint(5,5));
ImageProcessing::FillPolygon(image, points, 255);
// outside polygon
ASSERT_FLOAT_EQ(128, TestFixture::ImageTraits::GetFloatPixel(image, 0, 0));
ASSERT_FLOAT_EQ(128, TestFixture::ImageTraits::GetFloatPixel(image, 0, 6));
ASSERT_FLOAT_EQ(128, TestFixture::ImageTraits::GetFloatPixel(image, 6, 6));
ASSERT_FLOAT_EQ(128, TestFixture::ImageTraits::GetFloatPixel(image, 6, 0));
ASSERT_FLOAT_EQ(255, TestFixture::ImageTraits::GetFloatPixel(image, 1, 1));
ASSERT_FLOAT_EQ(255, TestFixture::ImageTraits::GetFloatPixel(image, 1, 2));
ASSERT_FLOAT_EQ(255, TestFixture::ImageTraits::GetFloatPixel(image, 1, 5));
ASSERT_FLOAT_EQ(255, TestFixture::ImageTraits::GetFloatPixel(image, 2, 4));
ASSERT_FLOAT_EQ(255, TestFixture::ImageTraits::GetFloatPixel(image, 5, 5));
}
TYPED_TEST(TestIntegerImageTraits, FillPolygonLargerThanImage)
{
ImageAccessor& image = this->GetImage();
ImageProcessing::Set(image, 0);
std::vector<ImageProcessing::ImagePoint> points;
points.push_back(ImageProcessing::ImagePoint(0, 0));
points.push_back(ImageProcessing::ImagePoint(image.GetWidth(),0));
points.push_back(ImageProcessing::ImagePoint(image.GetWidth(),image.GetHeight()));
points.push_back(ImageProcessing::ImagePoint(0,image.GetHeight()));
ImageProcessing::FillPolygon(image, points, 255);
for (unsigned int y = 0; y < image.GetHeight(); y++)
{
for (unsigned int x = 0; x < image.GetWidth(); x++)
{
ASSERT_FLOAT_EQ(255, TestFixture::ImageTraits::GetFloatPixel(image, x, y));
}
}
}
TYPED_TEST(TestIntegerImageTraits, FillPolygonFullImage)
{
ImageAccessor& image = this->GetImage();
ImageProcessing::Set(image, 0);
std::vector<ImageProcessing::ImagePoint> points;
points.push_back(ImageProcessing::ImagePoint(0, 0));
points.push_back(ImageProcessing::ImagePoint(image.GetWidth() - 1,0));
points.push_back(ImageProcessing::ImagePoint(image.GetWidth() - 1,image.GetHeight() - 1));
points.push_back(ImageProcessing::ImagePoint(0,image.GetHeight() - 1));
ImageProcessing::FillPolygon(image, points, 255);
ASSERT_FLOAT_EQ(255, TestFixture::ImageTraits::GetFloatPixel(image, 0, 0));
ASSERT_FLOAT_EQ(255, TestFixture::ImageTraits::GetFloatPixel(image, image.GetWidth() - 1, image.GetHeight() - 1));
}
static void SetGrayscale8Pixel(ImageAccessor& image,
unsigned int x,
unsigned int y,
uint8_t value)
{
ImageTraits<PixelFormat_Grayscale8>::SetPixel(image, value, x, y);
}
static bool TestGrayscale8Pixel(const ImageAccessor& image,
unsigned int x,
unsigned int y,
uint8_t value)
{
PixelTraits<PixelFormat_Grayscale8>::PixelType p;
ImageTraits<PixelFormat_Grayscale8>::GetPixel(p, image, x, y);
if (p != value) printf("%d %d\n", p, value);
return p == value;
}
static void SetGrayscale16Pixel(ImageAccessor& image,
unsigned int x,
unsigned int y,
uint16_t value)
{
ImageTraits<PixelFormat_Grayscale16>::SetPixel(image, value, x, y);
}
static bool TestGrayscale16Pixel(const ImageAccessor& image,
unsigned int x,
unsigned int y,
uint16_t value)
{
PixelTraits<PixelFormat_Grayscale16>::PixelType p;
ImageTraits<PixelFormat_Grayscale16>::GetPixel(p, image, x, y);
if (p != value) printf("%d %d\n", p, value);
return p == value;
}
static void SetSignedGrayscale16Pixel(ImageAccessor& image,
unsigned int x,
unsigned int y,
int16_t value)
{
ImageTraits<PixelFormat_SignedGrayscale16>::SetPixel(image, value, x, y);
}
static bool TestSignedGrayscale16Pixel(const ImageAccessor& image,
unsigned int x,
unsigned int y,
int16_t value)
{
PixelTraits<PixelFormat_SignedGrayscale16>::PixelType p;
ImageTraits<PixelFormat_SignedGrayscale16>::GetPixel(p, image, x, y);
if (p != value) printf("%d %d\n", p, value);
return p == value;
}
static void SetRGB24Pixel(ImageAccessor& image,
unsigned int x,
unsigned int y,
uint8_t red,
uint8_t green,
uint8_t blue)
{
PixelTraits<PixelFormat_RGB24>::PixelType p;
p.red_ = red;
p.green_ = green;
p.blue_ = blue;
ImageTraits<PixelFormat_RGB24>::SetPixel(image, p, x, y);
}
static bool TestRGB24Pixel(const ImageAccessor& image,
unsigned int x,
unsigned int y,
uint8_t red,
uint8_t green,
uint8_t blue)
{
PixelTraits<PixelFormat_RGB24>::PixelType p;
ImageTraits<PixelFormat_RGB24>::GetPixel(p, image, x, y);
bool ok = (p.red_ == red &&
p.green_ == green &&
p.blue_ == blue);
if (!ok) printf("%d,%d,%d %d,%d,%d\n", p.red_, p.green_, p.blue_, red, green, blue);
return ok;
}
TEST(ImageProcessing, FlipGrayscale8)
{
{
Image image(PixelFormat_Grayscale8, 0, 0, false);
ImageProcessing::FlipX(image);
ImageProcessing::FlipY(image);
}
{
Image image(PixelFormat_Grayscale8, 1, 1, false);
SetGrayscale8Pixel(image, 0, 0, 128);
ImageProcessing::FlipX(image);
ImageProcessing::FlipY(image);
ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 128));
}
{
Image image(PixelFormat_Grayscale8, 3, 2, false);
SetGrayscale8Pixel(image, 0, 0, 10);
SetGrayscale8Pixel(image, 1, 0, 20);
SetGrayscale8Pixel(image, 2, 0, 30);
SetGrayscale8Pixel(image, 0, 1, 40);
SetGrayscale8Pixel(image, 1, 1, 50);
SetGrayscale8Pixel(image, 2, 1, 60);
ImageProcessing::FlipX(image);
ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 30));
ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 0, 20));
ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 0, 10));
ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 1, 60));
ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 1, 50));
ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 1, 40));
ImageProcessing::FlipY(image);
ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 60));
ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 0, 50));
ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 0, 40));
ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 1, 30));
ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 1, 20));
ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 1, 10));
}
}
TEST(ImageProcessing, FlipRGB24)
{
Image image(PixelFormat_RGB24, 2, 2, false);
SetRGB24Pixel(image, 0, 0, 10, 100, 110);
SetRGB24Pixel(image, 1, 0, 20, 100, 110);
SetRGB24Pixel(image, 0, 1, 30, 100, 110);
SetRGB24Pixel(image, 1, 1, 40, 100, 110);
ImageProcessing::FlipX(image);
ASSERT_TRUE(TestRGB24Pixel(image, 0, 0, 20, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(image, 1, 0, 10, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(image, 0, 1, 40, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(image, 1, 1, 30, 100, 110));
ImageProcessing::FlipY(image);
ASSERT_TRUE(TestRGB24Pixel(image, 0, 0, 40, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(image, 1, 0, 30, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(image, 0, 1, 20, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(image, 1, 1, 10, 100, 110));
}
TEST(ImageProcessing, ResizeBasicGrayscale8)
{
Image source(PixelFormat_Grayscale8, 2, 2, false);
SetGrayscale8Pixel(source, 0, 0, 10);
SetGrayscale8Pixel(source, 1, 0, 20);
SetGrayscale8Pixel(source, 0, 1, 30);
SetGrayscale8Pixel(source, 1, 1, 40);
{
Image target(PixelFormat_Grayscale8, 2, 4, false);
ImageProcessing::Resize(target, source);
ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 10));
ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 20));
ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 1, 10));
ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 1, 20));
ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 2, 30));
ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 2, 40));
ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 3, 30));
ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 3, 40));
}
{
Image target(PixelFormat_Grayscale8, 4, 2, false);
ImageProcessing::Resize(target, source);
ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 10));
ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 10));
ASSERT_TRUE(TestGrayscale8Pixel(target, 2, 0, 20));
ASSERT_TRUE(TestGrayscale8Pixel(target, 3, 0, 20));
ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 1, 30));
ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 1, 30));
ASSERT_TRUE(TestGrayscale8Pixel(target, 2, 1, 40));
ASSERT_TRUE(TestGrayscale8Pixel(target, 3, 1, 40));
}
}
TEST(ImageProcessing, ResizeBasicRGB24)
{
Image source(PixelFormat_RGB24, 2, 2, false);
SetRGB24Pixel(source, 0, 0, 10, 100, 110);
SetRGB24Pixel(source, 1, 0, 20, 100, 110);
SetRGB24Pixel(source, 0, 1, 30, 100, 110);
SetRGB24Pixel(source, 1, 1, 40, 100, 110);
{
Image target(PixelFormat_RGB24, 2, 4, false);
ImageProcessing::Resize(target, source);
ASSERT_TRUE(TestRGB24Pixel(target, 0, 0, 10, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(target, 1, 0, 20, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(target, 0, 1, 10, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(target, 1, 1, 20, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(target, 0, 2, 30, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(target, 1, 2, 40, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(target, 0, 3, 30, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(target, 1, 3, 40, 100, 110));
}
{
Image target(PixelFormat_RGB24, 4, 2, false);
ImageProcessing::Resize(target, source);
ASSERT_TRUE(TestRGB24Pixel(target, 0, 0, 10, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(target, 1, 0, 10, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(target, 2, 0, 20, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(target, 3, 0, 20, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(target, 0, 1, 30, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(target, 1, 1, 30, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(target, 2, 1, 40, 100, 110));
ASSERT_TRUE(TestRGB24Pixel(target, 3, 1, 40, 100, 110));
}
}
TEST(ImageProcessing, ResizeEmptyGrayscale8)
{
{
Image source(PixelFormat_Grayscale8, 0, 0, false);
Image target(PixelFormat_Grayscale8, 2, 2, false);
ImageProcessing::Resize(target, source);
ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 1, 0));
ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 1, 0));
}
{
Image source(PixelFormat_Grayscale8, 2, 2, false);
Image target(PixelFormat_Grayscale8, 0, 0, false);
ImageProcessing::Resize(target, source);
}
}
TEST(ImageProcessing, Convolution)
{
std::vector<float> k1(5, 1);
std::vector<float> k2(1, 1);
{
Image image(PixelFormat_Grayscale8, 1, 1, false);
SetGrayscale8Pixel(image, 0, 0, 100);
ImageProcessing::SeparableConvolution(image, k1, 2, k2, 0, true /* round */);
ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 100));
ImageProcessing::SeparableConvolution(image, k1, 2, k1, 2, true /* round */);
ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 100));
ImageProcessing::SeparableConvolution(image, k2, 0, k1, 2, true /* round */);
ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 100));
ImageProcessing::SeparableConvolution(image, k2, 0, k2, 0, true /* round */);
ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 100));
}
{
Image image(PixelFormat_RGB24, 1, 1, false);
SetRGB24Pixel(image, 0, 0, 10, 20, 30);
ImageProcessing::SeparableConvolution(image, k1, 2, k2, 0, true /* round */);
ASSERT_TRUE(TestRGB24Pixel(image, 0, 0, 10, 20, 30));
ImageProcessing::SeparableConvolution(image, k1, 2, k1, 2, true /* round */);
ASSERT_TRUE(TestRGB24Pixel(image, 0, 0, 10, 20, 30));
ImageProcessing::SeparableConvolution(image, k2, 0, k1, 2, true /* round */);
ASSERT_TRUE(TestRGB24Pixel(image, 0, 0, 10, 20, 30));
ImageProcessing::SeparableConvolution(image, k2, 0, k2, 0, true /* round */);
ASSERT_TRUE(TestRGB24Pixel(image, 0, 0, 10, 20, 30));
}
{
Image dirac(PixelFormat_Grayscale8, 9, 1, false);
ImageProcessing::Set(dirac, 0);
SetGrayscale8Pixel(dirac, 4, 0, 100);
{
std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
ImageProcessing::SeparableConvolution(*image, k1, 2, k2, 0, true /* round */);
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 1, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 2, 0, 20));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 3, 0, 20));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 4, 0, 20));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 5, 0, 20));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 6, 0, 20));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 7, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 8, 0, 0));
}
{
std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
ImageProcessing::SeparableConvolution(*image, k2, 0, k1, 2, true /* round */);
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 1, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 2, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 3, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 4, 0, 100));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 5, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 6, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 7, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 8, 0, 0));
}
{
std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
ImageProcessing::SeparableConvolution(*image, k2, 0, k2, 0, true /* round */);
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 1, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 2, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 3, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 4, 0, 100));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 5, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 6, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 7, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 8, 0, 0));
}
}
{
Image dirac(PixelFormat_Grayscale8, 1, 9, false);
ImageProcessing::Set(dirac, 0);
SetGrayscale8Pixel(dirac, 0, 4, 100);
{
std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
ImageProcessing::SeparableConvolution(*image, k2, 0, k1, 2, true /* round */);
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 1, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 2, 20));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 3, 20));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 4, 20));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 5, 20));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 6, 20));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 7, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 8, 0));
}
{
std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
ImageProcessing::SeparableConvolution(*image, k1, 2, k2, 0, true /* round */);
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 1, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 2, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 3, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 4, 100));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 5, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 6, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 7, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 8, 0));
}
{
std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
ImageProcessing::SeparableConvolution(*image, k2, 0, k2, 0, true /* round */);
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 1, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 2, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 3, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 4, 100));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 5, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 6, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 7, 0));
ASSERT_TRUE(TestGrayscale8Pixel(*image, 0, 8, 0));
}
}
{
Image dirac(PixelFormat_RGB24, 9, 1, false);
ImageProcessing::Set(dirac, 0);
SetRGB24Pixel(dirac, 4, 0, 100, 120, 140);
{
std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
ImageProcessing::SeparableConvolution(*image, k1, 2, k2, 0, true /* round */);
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 1, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 2, 0, 20, 24, 28));
ASSERT_TRUE(TestRGB24Pixel(*image, 3, 0, 20, 24, 28));
ASSERT_TRUE(TestRGB24Pixel(*image, 4, 0, 20, 24, 28));
ASSERT_TRUE(TestRGB24Pixel(*image, 5, 0, 20, 24, 28));
ASSERT_TRUE(TestRGB24Pixel(*image, 6, 0, 20, 24, 28));
ASSERT_TRUE(TestRGB24Pixel(*image, 7, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 8, 0, 0, 0, 0));
}
{
std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
ImageProcessing::SeparableConvolution(*image, k2, 0, k1, 2, true /* round */);
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 1, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 2, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 3, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 4, 0, 100, 120, 140));
ASSERT_TRUE(TestRGB24Pixel(*image, 5, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 6, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 7, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 8, 0, 0, 0, 0));
}
{
std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
ImageProcessing::SeparableConvolution(*image, k2, 0, k2, 0, true /* round */);
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 1, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 2, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 3, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 4, 0, 100, 120, 140));
ASSERT_TRUE(TestRGB24Pixel(*image, 5, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 6, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 7, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 8, 0, 0, 0, 0));
}
}
{
Image dirac(PixelFormat_RGB24, 1, 9, false);
ImageProcessing::Set(dirac, 0);
SetRGB24Pixel(dirac, 0, 4, 100, 120, 140);
{
std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
ImageProcessing::SeparableConvolution(*image, k2, 0, k1, 2, true /* round */);
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 1, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 2, 20, 24, 28));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 3, 20, 24, 28));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 4, 20, 24, 28));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 5, 20, 24, 28));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 6, 20, 24, 28));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 7, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 8, 0, 0, 0));
}
{
std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
ImageProcessing::SeparableConvolution(*image, k1, 2, k2, 0, true /* round */);
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 1, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 2, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 3, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 4, 100, 120, 140));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 5, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 6, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 7, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 8, 0, 0, 0));
}
{
std::unique_ptr<ImageAccessor> image(Image::Clone(dirac));
ImageProcessing::SeparableConvolution(*image, k2, 0, k2, 0, true /* round */);
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 0, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 1, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 2, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 3, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 4, 100, 120, 140));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 5, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 6, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 7, 0, 0, 0));
ASSERT_TRUE(TestRGB24Pixel(*image, 0, 8, 0, 0, 0));
}
}
}
TEST(ImageProcessing, SmoothGaussian5x5)
{
/**
Test the point spread function, as can be seen in Octave:
g1 = [ 1 4 6 4 1 ];
g1 /= sum(g1);
g2 = conv2(g1, g1');
floor(conv2(diag([ 0 0 100 0 0 ]), g2, 'same')) % red/green channels
floor(conv2(diag([ 0 0 200 0 0 ]), g2, 'same')) % blue channel
**/
{
Image image(PixelFormat_Grayscale8, 5, 5, false);
ImageProcessing::Set(image, 0);
SetGrayscale8Pixel(image, 2, 2, 100);
ImageProcessing::SmoothGaussian5x5(image, true /* round */);
// In Octave: round(conv2([1 4 6 4 1],[1 4 6 4 1]')/256*100)
ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 0, 2));
ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 0, 2));
ASSERT_TRUE(TestGrayscale8Pixel(image, 3, 0, 2));
ASSERT_TRUE(TestGrayscale8Pixel(image, 4, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 1, 2));
ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 1, 6));
ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 1, 9));
ASSERT_TRUE(TestGrayscale8Pixel(image, 3, 1, 6));
ASSERT_TRUE(TestGrayscale8Pixel(image, 4, 1, 2));
ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 2, 2));
ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 2, 9));
ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 2, 14));
ASSERT_TRUE(TestGrayscale8Pixel(image, 3, 2, 9));
ASSERT_TRUE(TestGrayscale8Pixel(image, 4, 2, 2));
ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 3, 2));
ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 3, 6));
ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 3, 9));
ASSERT_TRUE(TestGrayscale8Pixel(image, 3, 3, 6));
ASSERT_TRUE(TestGrayscale8Pixel(image, 4, 3, 2));
ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 4, 0));
ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 4, 2));
ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 4, 2));
ASSERT_TRUE(TestGrayscale8Pixel(image, 3, 4, 2));
ASSERT_TRUE(TestGrayscale8Pixel(image, 4, 4, 0));
}
{
Image image(PixelFormat_RGB24, 5, 5, false);
ImageProcessing::Set(image, 0);
SetRGB24Pixel(image, 2, 2, 100, 100, 200);
ImageProcessing::SmoothGaussian5x5(image, true /* round */);
// In Octave:
// R,G = round(conv2([1 4 6 4 1],[1 4 6 4 1]')/256*100)
// B = round(conv2([1 4 6 4 1],[1 4 6 4 1]')/256*200)
ASSERT_TRUE(TestRGB24Pixel(image, 0, 0, 0, 0, 1));
ASSERT_TRUE(TestRGB24Pixel(image, 1, 0, 2, 2, 3));
ASSERT_TRUE(TestRGB24Pixel(image, 2, 0, 2, 2, 5));
ASSERT_TRUE(TestRGB24Pixel(image, 3, 0, 2, 2, 3));
ASSERT_TRUE(TestRGB24Pixel(image, 4, 0, 0, 0, 1));
ASSERT_TRUE(TestRGB24Pixel(image, 0, 1, 2, 2, 3));
ASSERT_TRUE(TestRGB24Pixel(image, 1, 1, 6, 6, 13));
ASSERT_TRUE(TestRGB24Pixel(image, 2, 1, 9, 9, 19));
ASSERT_TRUE(TestRGB24Pixel(image, 3, 1, 6, 6, 13));
ASSERT_TRUE(TestRGB24Pixel(image, 4, 1, 2, 2, 3));
ASSERT_TRUE(TestRGB24Pixel(image, 0, 2, 2, 2, 5));
ASSERT_TRUE(TestRGB24Pixel(image, 1, 2, 9, 9, 19));
ASSERT_TRUE(TestRGB24Pixel(image, 2, 2, 14, 14, 28));
ASSERT_TRUE(TestRGB24Pixel(image, 3, 2, 9, 9, 19));
ASSERT_TRUE(TestRGB24Pixel(image, 4, 2, 2, 2, 5));
ASSERT_TRUE(TestRGB24Pixel(image, 0, 3, 2, 2, 3));
ASSERT_TRUE(TestRGB24Pixel(image, 1, 3, 6, 6, 13));
ASSERT_TRUE(TestRGB24Pixel(image, 2, 3, 9, 9, 19));
ASSERT_TRUE(TestRGB24Pixel(image, 3, 3, 6, 6, 13));
ASSERT_TRUE(TestRGB24Pixel(image, 4, 3, 2, 2, 3));
ASSERT_TRUE(TestRGB24Pixel(image, 0, 4, 0, 0, 1));
ASSERT_TRUE(TestRGB24Pixel(image, 1, 4, 2, 2, 3));
ASSERT_TRUE(TestRGB24Pixel(image, 2, 4, 2, 2, 5));
ASSERT_TRUE(TestRGB24Pixel(image, 3, 4, 2, 2, 3));
ASSERT_TRUE(TestRGB24Pixel(image, 4, 4, 0, 0, 1));
}
}
TEST(ImageProcessing, ApplyWindowingFloatToGrayScale8)
{
{
Image image(PixelFormat_Float32, 6, 1, false);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, -5.0f, 0, 0);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 0.0f, 1, 0);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 5.0f, 2, 0);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 10.0f, 3, 0);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 1000.0f, 4, 0);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 2.0f, 5, 0);
{
Image target(PixelFormat_Grayscale8, 6, 1, false);
ImageProcessing::ApplyWindowing_Deprecated(target, image, 5.0f, 10.0f, 1.0f, 0.0f, false);
ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(target, 2, 0, 128));
ASSERT_TRUE(TestGrayscale8Pixel(target, 3, 0, 255));
ASSERT_TRUE(TestGrayscale8Pixel(target, 4, 0, 255));
ASSERT_TRUE(TestGrayscale8Pixel(target, 5, 0, 255*2/10));
}
{
Image target(PixelFormat_Grayscale8, 6, 1, false);
ImageProcessing::ApplyWindowing_Deprecated(target, image, 5.0f, 10.0f, 1.0f, 0.0f, true);
ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 255));
ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 255));
ASSERT_TRUE(TestGrayscale8Pixel(target, 2, 0, 127));
ASSERT_TRUE(TestGrayscale8Pixel(target, 3, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(target, 4, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(target, 5, 0, 255 - 255*2/10));
}
{
Image target(PixelFormat_Grayscale8, 6, 1, false);
ImageProcessing::ApplyWindowing_Deprecated(target, image, 5000.0f, 10000.01f, 1000.0f, 0.0f, false);
ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(target, 2, 0, 128));
ASSERT_TRUE(TestGrayscale8Pixel(target, 3, 0, 255));
ASSERT_TRUE(TestGrayscale8Pixel(target, 4, 0, 255));
ASSERT_TRUE(TestGrayscale8Pixel(target, 5, 0, 255*2/10));
}
{
Image target(PixelFormat_Grayscale8, 6, 1, false);
ImageProcessing::ApplyWindowing_Deprecated(target, image, 5000.0f, 10000.01f, 1000.0f, 0.0f, true);
ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 255));
ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 255));
ASSERT_TRUE(TestGrayscale8Pixel(target, 2, 0, 127));
ASSERT_TRUE(TestGrayscale8Pixel(target, 3, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(target, 4, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(target, 5, 0, 255 - 256*2/10));
}
{
Image target(PixelFormat_Grayscale8, 6, 1, false);
ImageProcessing::ApplyWindowing_Deprecated(target, image, 50.0f, 100.1f, 10.0f, 30.0f, false);
ASSERT_TRUE(TestGrayscale8Pixel(target, 0, 0, 0)); // (-5 * 10) + 30 => pixel value = -20 => 0
ASSERT_TRUE(TestGrayscale8Pixel(target, 1, 0, 256*30/100)); // ((0 * 10) + 30 => pixel value = 30 => 30%
ASSERT_TRUE(TestGrayscale8Pixel(target, 2, 0, 256*80/100)); // ((5 * 10) + 30 => pixel value = 80 => 80%
ASSERT_TRUE(TestGrayscale8Pixel(target, 3, 0, 255)); // ((10 * 10) + 30 => pixel value = 130 => 100%
ASSERT_TRUE(TestGrayscale8Pixel(target, 4, 0, 255)); // ((1000 * 10) + 30 => pixel value = 10030 => 100%
ASSERT_TRUE(TestGrayscale8Pixel(target, 5, 0, 128)); // ((2 * 10) + 30 => pixel value = 50 => 50%
}
}
}
TEST(ImageProcessing, ApplyWindowingFloatToGrayScale16)
{
{
Image image(PixelFormat_Float32, 6, 1, false);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, -5.0f, 0, 0);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 0.0f, 1, 0);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 5.0f, 2, 0);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 10.0f, 3, 0);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 1000.0f, 4, 0);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 2.0f, 5, 0);
{
Image target(PixelFormat_Grayscale16, 6, 1, false);
ImageProcessing::ApplyWindowing_Deprecated(target, image, 5.0f, 10.0f, 1.0f, 0.0f, false);
ASSERT_TRUE(TestGrayscale16Pixel(target, 0, 0, 0));
ASSERT_TRUE(TestGrayscale16Pixel(target, 1, 0, 0));
ASSERT_TRUE(TestGrayscale16Pixel(target, 2, 0, 32768));
ASSERT_TRUE(TestGrayscale16Pixel(target, 3, 0, 65535));
ASSERT_TRUE(TestGrayscale16Pixel(target, 4, 0, 65535));
ASSERT_TRUE(TestGrayscale16Pixel(target, 5, 0, 65536*2/10));
}
}
}
TEST(ImageProcessing, ApplyWindowingGrayScale8ToGrayScale16)
{
{
Image image(PixelFormat_Grayscale8, 5, 1, false);
SetGrayscale8Pixel(image, 0, 0, 0);
SetGrayscale8Pixel(image, 1, 0, 2);
SetGrayscale8Pixel(image, 2, 0, 5);
SetGrayscale8Pixel(image, 3, 0, 10);
SetGrayscale8Pixel(image, 4, 0, 255);
{
Image target(PixelFormat_Grayscale16, 5, 1, false);
ImageProcessing::ApplyWindowing_Deprecated(target, image, 5.0f, 10.0f, 1.0f, 0.0f, false);
ASSERT_TRUE(TestGrayscale16Pixel(target, 0, 0, 0));
ASSERT_TRUE(TestGrayscale16Pixel(target, 1, 0, 65536*2/10));
ASSERT_TRUE(TestGrayscale16Pixel(target, 2, 0, 65536*5/10));
ASSERT_TRUE(TestGrayscale16Pixel(target, 3, 0, 65535));
ASSERT_TRUE(TestGrayscale16Pixel(target, 4, 0, 65535));
}
}
}
TEST(ImageProcessing, ApplyWindowingGrayScale16ToGrayScale16)
{
{
Image image(PixelFormat_Grayscale16, 5, 1, false);
SetGrayscale16Pixel(image, 0, 0, 0);
SetGrayscale16Pixel(image, 1, 0, 2);
SetGrayscale16Pixel(image, 2, 0, 5);
SetGrayscale16Pixel(image, 3, 0, 10);
SetGrayscale16Pixel(image, 4, 0, 255);
{
Image target(PixelFormat_Grayscale16, 5, 1, false);
ImageProcessing::ApplyWindowing_Deprecated(target, image, 5.0f, 10.0f, 1.0f, 0.0f, false);
ASSERT_TRUE(TestGrayscale16Pixel(target, 0, 0, 0));
ASSERT_TRUE(TestGrayscale16Pixel(target, 1, 0, 65536*2/10));
ASSERT_TRUE(TestGrayscale16Pixel(target, 2, 0, 65536*5/10));
ASSERT_TRUE(TestGrayscale16Pixel(target, 3, 0, 65535));
ASSERT_TRUE(TestGrayscale16Pixel(target, 4, 0, 65535));
}
}
}
TEST(ImageProcessing, ShiftScaleGrayscale8)
{
Image image(PixelFormat_Grayscale8, 5, 1, false);
SetGrayscale8Pixel(image, 0, 0, 0);
SetGrayscale8Pixel(image, 1, 0, 2);
SetGrayscale8Pixel(image, 2, 0, 5);
SetGrayscale8Pixel(image, 3, 0, 10);
SetGrayscale8Pixel(image, 4, 0, 255);
ImageProcessing::ShiftScale(image, -1.1f, 1.5f, true);
ASSERT_TRUE(TestGrayscale8Pixel(image, 0, 0, 0)); // (0 - 1.1) * 1.5 = -1.65 ==> 0
ASSERT_TRUE(TestGrayscale8Pixel(image, 1, 0, 1)); // (2 - 1.1) * 1.5 = 1.35 => 1
ASSERT_TRUE(TestGrayscale8Pixel(image, 2, 0, 6)); // (5 - 1.1) * 1.5 = 5.85 => 6
ASSERT_TRUE(TestGrayscale8Pixel(image, 3, 0, 13)); // (10 - 1.1) * 1.5 = 13.35 => 13
ASSERT_TRUE(TestGrayscale8Pixel(image, 4, 0, 255));
}
TEST(ImageProcessing, Grayscale8_Identity)
{
Image image(PixelFormat_Float32, 5, 1, false);
ImageTraits<PixelFormat_Float32>::SetPixel(image, 0, 0, 0);
ImageTraits<PixelFormat_Float32>::SetPixel(image, 2.5, 1, 0);
ImageTraits<PixelFormat_Float32>::SetPixel(image, 5.5, 2, 0);
ImageTraits<PixelFormat_Float32>::SetPixel(image, 10.5, 3, 0);
ImageTraits<PixelFormat_Float32>::SetPixel(image, 255.5, 4, 0);
Image image2(PixelFormat_Grayscale8, 5, 1, false);
ImageProcessing::ShiftScale(image2, image, 0, 1, false);
ASSERT_TRUE(TestGrayscale8Pixel(image2, 0, 0, 0));
ASSERT_TRUE(TestGrayscale8Pixel(image2, 1, 0, 2));
ASSERT_TRUE(TestGrayscale8Pixel(image2, 2, 0, 5));
ASSERT_TRUE(TestGrayscale8Pixel(image2, 3, 0, 10));
ASSERT_TRUE(TestGrayscale8Pixel(image2, 4, 0, 255));
}
TEST(ImageProcessing, ShiftScaleGrayscale16)
{
Image image(PixelFormat_Grayscale16, 5, 1, false);
SetGrayscale16Pixel(image, 0, 0, 0);
SetGrayscale16Pixel(image, 1, 0, 2);
SetGrayscale16Pixel(image, 2, 0, 5);
SetGrayscale16Pixel(image, 3, 0, 10);
SetGrayscale16Pixel(image, 4, 0, 255);
ImageProcessing::ShiftScale(image, -1.1f, 1.5f, true);
ASSERT_TRUE(TestGrayscale16Pixel(image, 0, 0, 0));
ASSERT_TRUE(TestGrayscale16Pixel(image, 1, 0, 1));
ASSERT_TRUE(TestGrayscale16Pixel(image, 2, 0, 6));
ASSERT_TRUE(TestGrayscale16Pixel(image, 3, 0, 13));
ASSERT_TRUE(TestGrayscale16Pixel(image, 4, 0, 381));
}
TEST(ImageProcessing, ShiftScaleSignedGrayscale16)
{
Image image(PixelFormat_SignedGrayscale16, 5, 1, false);
SetSignedGrayscale16Pixel(image, 0, 0, 0);
SetSignedGrayscale16Pixel(image, 1, 0, 2);
SetSignedGrayscale16Pixel(image, 2, 0, 5);
SetSignedGrayscale16Pixel(image, 3, 0, 10);
SetSignedGrayscale16Pixel(image, 4, 0, 255);
ImageProcessing::ShiftScale(image, -17.1f, 11.5f, true);
ASSERT_TRUE(TestSignedGrayscale16Pixel(image, 0, 0, -197));
ASSERT_TRUE(TestSignedGrayscale16Pixel(image, 1, 0, -174));
ASSERT_TRUE(TestSignedGrayscale16Pixel(image, 2, 0, -139));
ASSERT_TRUE(TestSignedGrayscale16Pixel(image, 3, 0, -82));
ASSERT_TRUE(TestSignedGrayscale16Pixel(image, 4, 0, 2736));
}
TEST(ImageProcessing, ShiftScaleSignedGrayscale16_Identity)
{
Image image(PixelFormat_SignedGrayscale16, 5, 1, false);
SetSignedGrayscale16Pixel(image, 0, 0, 0);
SetSignedGrayscale16Pixel(image, 1, 0, 2);
SetSignedGrayscale16Pixel(image, 2, 0, 5);
SetSignedGrayscale16Pixel(image, 3, 0, 10);
SetSignedGrayscale16Pixel(image, 4, 0, 255);
ImageProcessing::ShiftScale(image, 0, 1, true);
ASSERT_TRUE(TestSignedGrayscale16Pixel(image, 0, 0, 0));
ASSERT_TRUE(TestSignedGrayscale16Pixel(image, 1, 0, 2));
ASSERT_TRUE(TestSignedGrayscale16Pixel(image, 2, 0, 5));
ASSERT_TRUE(TestSignedGrayscale16Pixel(image, 3, 0, 10));
ASSERT_TRUE(TestSignedGrayscale16Pixel(image, 4, 0, 255));
}
TEST(ImageProcessing, ShiftFloatBuggy)
{
// This test failed in Orthanc 1.10.1
Image image(PixelFormat_Float32, 3, 1, false);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, -1.0f, 0, 0);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 0.0f, 1, 0);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(image, 1.0f, 2, 0);
std::unique_ptr<Image> cloned(Image::Clone(image));
ImageProcessing::ShiftScale2(image, 0, 0.000539, true);
ASSERT_FLOAT_EQ(-0.000539f, ImageTraits<PixelFormat_Float32>::GetFloatPixel(image, 0, 0));
ASSERT_FLOAT_EQ(0.0f, ImageTraits<PixelFormat_Float32>::GetFloatPixel(image, 1, 0));
ASSERT_FLOAT_EQ(0.000539f, ImageTraits<PixelFormat_Float32>::GetFloatPixel(image, 2, 0));
ImageProcessing::ShiftScale2(*cloned, 0, 0.000539, false);
ASSERT_FLOAT_EQ(-0.000539f, ImageTraits<PixelFormat_Float32>::GetFloatPixel(*cloned, 0, 0));
ASSERT_FLOAT_EQ(0.0f, ImageTraits<PixelFormat_Float32>::GetFloatPixel(*cloned, 1, 0));
ASSERT_FLOAT_EQ(0.000539f, ImageTraits<PixelFormat_Float32>::GetFloatPixel(*cloned, 2, 0));
}
TEST(ImageProcessing, ShiftScale2)
{
std::vector<float> va;
va.push_back(0);
va.push_back(-10);
va.push_back(5);
std::vector<float> vb;
vb.push_back(0);
vb.push_back(-42);
vb.push_back(42);
Image source(PixelFormat_Float32, 1, 1, false);
ImageTraits<PixelFormat_Float32>::SetFloatPixel(source, 10, 0, 0);
for (std::vector<float>::const_iterator a = va.begin(); a != va.end(); ++a)
{
for (std::vector<float>::const_iterator b = vb.begin(); b != vb.end(); ++b)
{
Image target(PixelFormat_Float32, 1, 1, false);
ImageProcessing::Copy(target, source);
ImageProcessing::ShiftScale2(target, *b, *a, false);
ASSERT_FLOAT_EQ((*a) * 10.0f + (*b),
ImageTraits<PixelFormat_Float32>::GetFloatPixel(target, 0, 0));
ImageProcessing::Copy(target, source);
ImageProcessing::ShiftScale(target, *b, *a, false);
ASSERT_FLOAT_EQ((*a) * (10.0f + (*b)),
ImageTraits<PixelFormat_Float32>::GetFloatPixel(target, 0, 0));
}
}
}
namespace
{
class PolygonSegments : public ImageProcessing::IPolygonFiller
{
private:
std::vector<int> y_, x1_, x2_;
public:
virtual void Fill(int y,
int x1,
int x2) ORTHANC_OVERRIDE
{
assert(x1 <= x2);
y_.push_back(y);
x1_.push_back(x1);
x2_.push_back(x2);
}
size_t GetSize() const
{
return y_.size();
}
int GetY(size_t i) const
{
return y_[i];
}
int GetX1(size_t i) const
{
return x1_[i];
}
int GetX2(size_t i) const
{
return x2_[i];
}
};
}
static bool LookupSegment(unsigned int& x1,
unsigned int& x2,
const Orthanc::ImageAccessor& image,
unsigned int y)
{
const uint8_t* p = reinterpret_cast<const uint8_t*>(image.GetConstRow(y));
bool allZeros = true;
for (unsigned int i = 0; i < image.GetWidth(); i++)
{
if (p[i] == 255)
{
allZeros = false;
break;
}
else if (p[i] > 0)
{
return false; // error
}
}
if (allZeros)
{
return false;
}
x1 = 0;
while (p[x1] == 0)
{
x1++;
}
x2 = image.GetWidth() - 1;
while (p[x2] == 0)
{
x2--;
}
for (unsigned int i = x1; i <= x2; i++)
{
if (p[i] != 255)
{
return false;
}
}
return true;
}
TEST(ImageProcessing, FillPolygon)
{
{
// Empty
std::vector<ImageProcessing::ImagePoint> polygon;
PolygonSegments segments;
ImageProcessing::FillPolygon(segments, polygon);
ASSERT_EQ(0u, segments.GetSize());
}
{
// One point
std::vector<ImageProcessing::ImagePoint> polygon;
polygon.push_back(ImageProcessing::ImagePoint(288, 208));
PolygonSegments segments;
ImageProcessing::FillPolygon(segments, polygon);
ASSERT_EQ(0u, segments.GetSize());
}
{
// One horizontal segment
std::vector<ImageProcessing::ImagePoint> polygon;
polygon.push_back(ImageProcessing::ImagePoint(10, 100));
polygon.push_back(ImageProcessing::ImagePoint(50, 100));
PolygonSegments segments;
ImageProcessing::FillPolygon(segments, polygon);
ASSERT_EQ(1u, segments.GetSize());
ASSERT_EQ(100, segments.GetY(0));
ASSERT_EQ(10, segments.GetX1(0));
ASSERT_EQ(50, segments.GetX2(0));
}
{
// Set of horizontal segments
std::vector<ImageProcessing::ImagePoint> polygon;
polygon.push_back(ImageProcessing::ImagePoint(10, 100));
polygon.push_back(ImageProcessing::ImagePoint(20, 100));
polygon.push_back(ImageProcessing::ImagePoint(30, 100));
polygon.push_back(ImageProcessing::ImagePoint(50, 100));
PolygonSegments segments;
ImageProcessing::FillPolygon(segments, polygon);
ASSERT_EQ(1u, segments.GetSize());
ASSERT_EQ(100, segments.GetY(0));
ASSERT_EQ(10, segments.GetX1(0));
ASSERT_EQ(50, segments.GetX2(0));
}
{
// Set of vertical segments
std::vector<ImageProcessing::ImagePoint> polygon;
polygon.push_back(ImageProcessing::ImagePoint(10, 100));
polygon.push_back(ImageProcessing::ImagePoint(10, 102));
polygon.push_back(ImageProcessing::ImagePoint(10, 105));
PolygonSegments segments;
ImageProcessing::FillPolygon(segments, polygon);
ASSERT_EQ(6u, segments.GetSize());
for (size_t i = 0; i < segments.GetSize(); i++)
{
ASSERT_EQ(100 + static_cast<int>(i), segments.GetY(i));
ASSERT_EQ(10, segments.GetX1(i));
ASSERT_EQ(10, segments.GetX2(i));
}
}
{
// One diagonal segment
std::vector<ImageProcessing::ImagePoint> polygon;
polygon.push_back(ImageProcessing::ImagePoint(10, 100));
polygon.push_back(ImageProcessing::ImagePoint(11, 101));
polygon.push_back(ImageProcessing::ImagePoint(13, 103));
PolygonSegments segments;
ImageProcessing::FillPolygon(segments, polygon);
ASSERT_EQ(4u, segments.GetSize());
ASSERT_EQ(100, segments.GetY(0));
ASSERT_EQ(10, segments.GetX1(0));
ASSERT_EQ(10, segments.GetX2(0));
ASSERT_EQ(101, segments.GetY(1));
ASSERT_EQ(11, segments.GetX1(1));
ASSERT_EQ(11, segments.GetX2(1));
ASSERT_EQ(102, segments.GetY(2));
ASSERT_EQ(12, segments.GetX1(2));
ASSERT_EQ(12, segments.GetX2(2));
ASSERT_EQ(103, segments.GetY(3));
ASSERT_EQ(13, segments.GetX1(3));
ASSERT_EQ(13, segments.GetX2(3));
}
{
// "M" shape
std::vector<ImageProcessing::ImagePoint> polygon;
polygon.push_back(ImageProcessing::ImagePoint(5, 5));
polygon.push_back(ImageProcessing::ImagePoint(7, 7));
polygon.push_back(ImageProcessing::ImagePoint(9, 5));
polygon.push_back(ImageProcessing::ImagePoint(9, 8));
polygon.push_back(ImageProcessing::ImagePoint(5, 8));
PolygonSegments segments;
ImageProcessing::FillPolygon(segments, polygon);
ASSERT_EQ(6u, segments.GetSize());
ASSERT_EQ(5, segments.GetY(0)); ASSERT_EQ(5, segments.GetX1(0)); ASSERT_EQ(5, segments.GetX2(0));
ASSERT_EQ(5, segments.GetY(1)); ASSERT_EQ(9, segments.GetX1(1)); ASSERT_EQ(9, segments.GetX2(1));
ASSERT_EQ(6, segments.GetY(2)); ASSERT_EQ(5, segments.GetX1(2)); ASSERT_EQ(6, segments.GetX2(2));
ASSERT_EQ(6, segments.GetY(3)); ASSERT_EQ(8, segments.GetX1(3)); ASSERT_EQ(9, segments.GetX2(3));
ASSERT_EQ(7, segments.GetY(4)); ASSERT_EQ(5, segments.GetX1(4)); ASSERT_EQ(9, segments.GetX2(4));
ASSERT_EQ(8, segments.GetY(5)); ASSERT_EQ(5, segments.GetX1(5)); ASSERT_EQ(9, segments.GetX2(5));
}
{
// Rectangle
std::vector<ImageProcessing::ImagePoint> polygon;
polygon.push_back(ImageProcessing::ImagePoint(10, 50));
polygon.push_back(ImageProcessing::ImagePoint(200, 50));
polygon.push_back(ImageProcessing::ImagePoint(200, 100));
polygon.push_back(ImageProcessing::ImagePoint(10, 100));
PolygonSegments segments;
ImageProcessing::FillPolygon(segments, polygon);
ASSERT_EQ(51u, segments.GetSize());
for (size_t i = 0; i < segments.GetSize(); i++)
{
ASSERT_EQ(50 + static_cast<int>(i), segments.GetY(i));
ASSERT_EQ(10, segments.GetX1(i));
ASSERT_EQ(200, segments.GetX2(i));
}
}
{
// Shape that goes outside of the image on the 4 borders
std::vector<ImageProcessing::ImagePoint> polygon;
polygon.push_back(ImageProcessing::ImagePoint(5, -5));
polygon.push_back(ImageProcessing::ImagePoint(40, 15));
polygon.push_back(ImageProcessing::ImagePoint(20, 32));
polygon.push_back(ImageProcessing::ImagePoint(-5, 27));
Image image(PixelFormat_Grayscale8, 30, 30, false);
ImageProcessing::Set(image, 0);
ImageProcessing::FillPolygon(image, polygon, 255);
unsigned int x1, x2;
ASSERT_TRUE(LookupSegment(x1, x2, image, 0)); ASSERT_EQ(3u, x1); ASSERT_EQ(14u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 1)); ASSERT_EQ(3u, x1); ASSERT_EQ(16u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 2)); ASSERT_EQ(2u, x1); ASSERT_EQ(18u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 3)); ASSERT_EQ(2u, x1); ASSERT_EQ(19u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 4)); ASSERT_EQ(2u, x1); ASSERT_EQ(21u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 5)); ASSERT_EQ(1u, x1); ASSERT_EQ(23u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 6)); ASSERT_EQ(1u, x1); ASSERT_EQ(25u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 7)); ASSERT_EQ(1u, x1); ASSERT_EQ(26u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 8)); ASSERT_EQ(0u, x1); ASSERT_EQ(28u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 9)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 10)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 11)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 12)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 13)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 14)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 15)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 16)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 17)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 18)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 19)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 20)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 21)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 22)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 23)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 24)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 25)); ASSERT_EQ(0u, x1); ASSERT_EQ(29u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 26)); ASSERT_EQ(0u, x1); ASSERT_EQ(28u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 27)); ASSERT_EQ(0u, x1); ASSERT_EQ(26u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 28)); ASSERT_EQ(0u, x1); ASSERT_EQ(25u, x2);
ASSERT_TRUE(LookupSegment(x1, x2, image, 29)); ASSERT_EQ(5u, x1); ASSERT_EQ(24u, x2);
}
}
Reference in New Issue View Git Blame Copy Permalink