Skip to content

Commit

Permalink
added tests for signed integer and floating point channel types for t…
Browse files Browse the repository at this point in the history 
…hreshold algorithms
  • Loading branch information
@marco-langer
marco-langer committed Jun 28, 2022
1 parent ac587f9 commit f37758d
Show file tree
Hide file tree
Showing 2 changed files with 304 additions and 276 deletions.
259 changes: 159 additions & 100 deletions test/core/image_processing/threshold_binary.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,124 +14,183 @@

namespace gil = boost::gil;

int height = 4;
int width = 4;
namespace {

gil::gray8_image_t original_gray(width, height), threshold_gray(width, height),
expected_gray(width, height);

gil::rgb8_image_t original_rgb(width, height), threshold_rgb(width, height),
expected_rgb(width, height);


void fill_original_gray()
template <typename View, typename Pixel>
void fill_upper_and_lower_half(
View const& view, Pixel const& upper_half_pixel, Pixel const& lower_half_pixel)
{
//filling original_gray view's upper half part with gray pixels of value 50
//filling original_gray view's lower half part with gray pixels of value 150
gil::fill_pixels(gil::subimage_view(gil::view(original_gray), 0, 0, original_gray.width(),
original_gray.height() / 2), gil::gray8_pixel_t(50));
gil::fill_pixels(gil::subimage_view(gil::view(original_gray), 0, original_gray.height() / 2,
original_gray.width(), original_gray.height() / 2), gil::gray8_pixel_t(150));
fill_pixels(
subimage_view(view, 0, 0, view.width(), view.height() / 2),
upper_half_pixel);
fill_pixels(
subimage_view(view, 0, view.height() / 2, view.width(), view.height() / 2),
lower_half_pixel);
}

void fill_original_rgb()
template <typename Image, typename Pixel, typename ChannelValue>
void test_threshold(
gil::threshold_direction direction,
ChannelValue threshold_value,
ChannelValue max_value,
bool set_max_value,
Pixel const& upper_half_pixel,
Pixel const& lower_half_pixel,
Pixel const& expected_upper_half_pixel,
Pixel const& expected_lower_half_pixel)
{
//filling original_rgb view's upper half part with rgb pixels of value 50, 155, 115
//filling original_rgb view's lower half part with rgb pixels of value 203, 9, 60
gil::fill_pixels(gil::subimage_view(gil::view(original_rgb), 0, 0, original_rgb.width(),
original_rgb.height() / 2), gil::rgb8_pixel_t(50, 155, 115));
gil::fill_pixels(gil::subimage_view(gil::view(original_rgb), 0, original_rgb.height() / 2,
original_rgb.width(), original_rgb.height() / 2), gil::rgb8_pixel_t(203, 9, 60));
int const height = 4;
int const width = 4;

Image original_img(width, height);
Image threshold_img(width, height);
Image expected_img(width, height);

auto original_view = gil::view(original_img);
auto threshold_view = gil::view(threshold_img);
auto expected_view = gil::view(expected_img);

fill_upper_and_lower_half(
original_view, upper_half_pixel, lower_half_pixel);
fill_upper_and_lower_half(
expected_view, expected_upper_half_pixel, expected_lower_half_pixel);

if (set_max_value)
{
threshold_binary(
original_view, threshold_view,
threshold_value, max_value, direction);
}
else
{
threshold_binary(original_view, threshold_view, threshold_value, direction);
}

BOOST_TEST(equal_pixels(threshold_view, expected_view));
}

void binary_gray_to_gray()
{
//expected_gray view after thresholding of the original_gray view with threshold_gray value of 100
//filling expected_gray view's upper half part with gray pixels of value 0
//filling expected_gray view's lower half part with gray pixels of value 255
gil::fill_pixels(gil::subimage_view(gil::view(expected_gray), 0, 0, original_gray.width(),
original_gray.height() / 2), gil::gray8_pixel_t(0));
gil::fill_pixels(gil::subimage_view(gil::view(expected_gray), 0, original_gray.height() / 2,
original_gray.width(), original_gray.height() / 2), gil::gray8_pixel_t(255));

gil::threshold_binary(gil::view(original_gray), gil::view(threshold_gray), 100);

//comparing threshold_gray view generated by the function with the expected_gray view
BOOST_TEST(gil::equal_pixels(gil::view(threshold_gray), gil::view(expected_gray)));
}
} // namespace

void binary_inverse_gray_to_gray()
void test_threshold_binary()
{
//expected_gray view after thresholding of the original_gray view with threshold_gray value of 100
//filling expected_gray view's upper half part with gray pixels of value 200
//filling expected_gray view's lower half part with gray pixels of value 0
gil::fill_pixels(gil::subimage_view(gil::view(expected_gray), 0, 0, original_gray.width(),
original_gray.height() / 2), gil::gray8_pixel_t(200));
gil::fill_pixels(gil::subimage_view(gil::view(expected_gray), 0, original_gray.height() / 2,
original_gray.width(), original_gray.height() / 2), gil::gray8_pixel_t(0));

gil::threshold_binary
(
gil::view(original_gray),
gil::view(threshold_gray),
// threshold binary should set all pixels below the threshold to channel min
// and above the threshold to the given max value or the channel max if no
// max is supplied
test_threshold<gil::gray8_image_t>(
gil::threshold_direction::regular,
100,
200,
gil::threshold_direction::inverse
);

//comparing threshold_gray view generated by the function with the expected_gray view
BOOST_TEST(gil::equal_pixels(gil::view(threshold_gray), gil::view(expected_gray)));
}

void binary_rgb_to_rgb()
{
//expected_rgb view after thresholding of the original_rgb view with threshold value of 100
//filling expected_rgb view's upper half part with rgb pixels of value 0, 165, 165
//filling expected_rgb view's lower half part with rgb pixels of value 165, 0, 0
gil::fill_pixels(gil::subimage_view(gil::view(expected_rgb), 0, 0, original_rgb.width(),
original_rgb.height() / 2), gil::rgb8_pixel_t(0, 165, 165));
gil::fill_pixels(gil::subimage_view(gil::view(expected_rgb), 0, original_rgb.height() / 2,
original_rgb.width(), original_rgb.height() / 2), gil::rgb8_pixel_t(165, 0, 0));

gil::threshold_binary(gil::view(original_rgb), gil::view(threshold_rgb), 100, 165);

//comparing threshold_rgb view generated by the function with the expected_rgb view
BOOST_TEST(gil::equal_pixels(gil::view(threshold_rgb), gil::view(expected_rgb)));
150, true,
gil::gray8_pixel_t{50}, gil::gray8_pixel_t{170},
gil::gray8_pixel_t{0}, gil::gray8_pixel_t{150});
test_threshold<gil::gray8_image_t>(
gil::threshold_direction::regular,
100,
150, false,
gil::gray8_pixel_t{50}, gil::gray8_pixel_t{170},
gil::gray8_pixel_t{0}, gil::gray8_pixel_t{255});

test_threshold<gil::gray8s_image_t>(
gil::threshold_direction::regular,
50,
100, true,
gil::gray8s_pixel_t{50}, gil::gray8s_pixel_t{110},
gil::gray8s_pixel_t{-128}, gil::gray8s_pixel_t{100});
test_threshold<gil::gray8s_image_t>(
gil::threshold_direction::regular,
50,
100, false,
gil::gray8s_pixel_t{50}, gil::gray8s_pixel_t{110},
gil::gray8s_pixel_t{-128}, gil::gray8s_pixel_t{127});

test_threshold<gil::gray32f_image_t>(
gil::threshold_direction::regular,
0.5f,
0.6f, true,
gil::gray32f_pixel_t{0.3f}, gil::gray32f_pixel_t{0.7f},
gil::gray32f_pixel_t{0.0f}, gil::gray32f_pixel_t{0.6f});
test_threshold<gil::gray32f_image_t>(
gil::threshold_direction::regular,
0.5f,
0.6f, false,
gil::gray32f_pixel_t{0.3f}, gil::gray32f_pixel_t{0.7f},
gil::gray32f_pixel_t{0.0f}, gil::gray32f_pixel_t{1.0f});

test_threshold<gil::rgb8_image_t>(
gil::threshold_direction::regular,
100,
165, true,
gil::rgb8_pixel_t{50, 155, 115}, gil::rgb8_pixel_t{203, 9, 60},
gil::rgb8_pixel_t{0, 165, 165}, gil::rgb8_pixel_t{165, 0, 0});
test_threshold<gil::rgb8_image_t>(
gil::threshold_direction::regular,
100,
165, false,
gil::rgb8_pixel_t{50, 155, 115}, gil::rgb8_pixel_t{203, 9, 60},
gil::rgb8_pixel_t{0, 255, 255}, gil::rgb8_pixel_t{255, 0, 0});
}

void binary_inverse_rgb_to_rgb()
void test_threshold_binary_inverse()
{
//expected_rgb view after thresholding of the original_rgb view with threshold value of 100
//filling expected_rgb view's upper half part with rgb pixels of value 90, 0, 0
//filling expected_rgb view's lower half part with rgb pixels of value 0, 90, 90
gil::fill_pixels(gil::subimage_view(gil::view(expected_rgb), 0, 0, original_rgb.width(),
original_rgb.height() / 2), gil::rgb8_pixel_t(90, 0, 0));
gil::fill_pixels(gil::subimage_view(gil::view(expected_rgb), 0, original_rgb.height() / 2,
original_rgb.width(), original_rgb.height() / 2), gil::rgb8_pixel_t(0, 90, 90));

gil::threshold_binary
(
gil::view(original_rgb),
gil::view(threshold_rgb),
// inverse threshold binary should set all pixels above the threshold to channel min
// and below the threshold to the given max value or the channel max if no
// max is supplied
test_threshold<gil::gray8_image_t>(
gil::threshold_direction::inverse,
100,
90,
gil::threshold_direction::inverse
);

//comparing threshold_rgb view generated by the function with the expected_rgb view
BOOST_TEST(gil::equal_pixels(gil::view(threshold_rgb), gil::view(expected_rgb)));
150, true,
gil::gray8_pixel_t{50}, gil::gray8_pixel_t{170},
gil::gray8_pixel_t{150}, gil::gray8_pixel_t{0});
test_threshold<gil::gray8_image_t>(
gil::threshold_direction::inverse,
100,
150, false,
gil::gray8_pixel_t{50}, gil::gray8_pixel_t{170},
gil::gray8_pixel_t{255}, gil::gray8_pixel_t{0});

test_threshold<gil::gray8s_image_t>(
gil::threshold_direction::inverse,
50,
100, true,
gil::gray8s_pixel_t{50}, gil::gray8s_pixel_t{110},
gil::gray8s_pixel_t{100}, gil::gray8s_pixel_t{-128});
test_threshold<gil::gray8s_image_t>(
gil::threshold_direction::inverse,
50,
100, false,
gil::gray8s_pixel_t{50}, gil::gray8s_pixel_t{110},
gil::gray8s_pixel_t{127}, gil::gray8s_pixel_t{-128});

test_threshold<gil::gray32f_image_t>(
gil::threshold_direction::inverse,
0.5f,
0.6f, true,
gil::gray32f_pixel_t{0.3f}, gil::gray32f_pixel_t{0.7f},
gil::gray32f_pixel_t{0.6f}, gil::gray32f_pixel_t{0.0f});
test_threshold<gil::gray32f_image_t>(
gil::threshold_direction::inverse,
0.5f,
0.6f, false,
gil::gray32f_pixel_t{0.3f}, gil::gray32f_pixel_t{0.7f},
gil::gray32f_pixel_t{1.0f}, gil::gray32f_pixel_t{0.0f});

test_threshold<gil::rgb8_image_t>(
gil::threshold_direction::inverse,
100,
165, true,
gil::rgb8_pixel_t{50, 155, 115}, gil::rgb8_pixel_t{203, 9, 60},
gil::rgb8_pixel_t{165, 0, 0}, gil::rgb8_pixel_t{0, 165, 165});
test_threshold<gil::rgb8_image_t>(
gil::threshold_direction::inverse,
100,
165, false,
gil::rgb8_pixel_t{50, 155, 115}, gil::rgb8_pixel_t{203, 9, 60},
gil::rgb8_pixel_t{255, 0, 0}, gil::rgb8_pixel_t{0, 255, 255});
}


int main()
{
fill_original_gray();
fill_original_rgb();

binary_gray_to_gray();
binary_inverse_gray_to_gray();
binary_rgb_to_rgb();
binary_inverse_rgb_to_rgb();
test_threshold_binary();
test_threshold_binary_inverse();

return boost::report_errors();
}
Loading

0 comments on commit f37758d

Please sign in to comment.