mirror of
https://github.com/boostorg/gil.git
synced 2026-01-29 19:42:11 +00:00
85 lines
3.2 KiB
C++
85 lines
3.2 KiB
C++
// Boost.GIL (Generic Image Library) - tests
|
|
//
|
|
// Copyright 2020 Olzhas Zhumabek <anonymous.from.applecity@gmail.com>
|
|
//
|
|
// Use, modification and distribution are subject to the Boost Software License,
|
|
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
#include <boost/core/lightweight_test.hpp>
|
|
|
|
#include <boost/gil/image.hpp>
|
|
#include <boost/gil/extension/image_processing/hough_transform.hpp>
|
|
#include <boost/gil/image_view.hpp>
|
|
#include <boost/gil/typedefs.hpp>
|
|
|
|
#include <cstddef>
|
|
#include <iostream>
|
|
#include <limits>
|
|
#include <vector>
|
|
|
|
namespace gil = boost::gil;
|
|
|
|
template <typename Rasterizer>
|
|
void exact_fit_test(std::ptrdiff_t radius, gil::point_t offset, Rasterizer rasterizer)
|
|
{
|
|
std::vector<gil::point_t> circle_points(rasterizer.point_count());
|
|
rasterizer(circle_points.begin());
|
|
// const std::ptrdiff_t diameter = radius * 2 - 1;
|
|
const std::ptrdiff_t width = offset.x + radius + 1;
|
|
const std::ptrdiff_t height = offset.y + radius + 1;
|
|
gil::gray8_image_t image(width, height);
|
|
auto input = gil::view(image);
|
|
|
|
for (const auto& point : circle_points)
|
|
{
|
|
input(point) = std::numeric_limits<gil::uint8_t>::max();
|
|
}
|
|
|
|
using param_t = gil::hough_parameter<std::ptrdiff_t>;
|
|
const auto radius_parameter = param_t{radius, 0, 1};
|
|
// const auto x_parameter = param_t::from_step_count(offset.x, neighborhood, half_step_count);
|
|
// const auto y_parameter = param_t::from_step_count(offset.y, neighborhood, half_step_count);
|
|
const auto x_parameter = param_t{offset.x, 0, 1};
|
|
const auto y_parameter = param_t{offset.y, 0, 1};
|
|
|
|
std::vector<gil::gray16_image_t> output_images(
|
|
radius_parameter.step_count,
|
|
gil::gray16_image_t(x_parameter.step_count, y_parameter.step_count));
|
|
std::vector<gil::gray16_view_t> output_views(radius_parameter.step_count);
|
|
std::transform(output_images.begin(), output_images.end(), output_views.begin(),
|
|
[](gil::gray16_image_t& img)
|
|
{
|
|
return gil::view(img);
|
|
});
|
|
gil::hough_circle_transform_brute(input, radius_parameter, x_parameter, y_parameter,
|
|
output_views.begin(), rasterizer);
|
|
if (output_views[0](0, 0) != rasterizer.point_count())
|
|
{
|
|
std::cout << "accumulated value: " << static_cast<int>(output_views[0](0, 0))
|
|
<< " expected value: " << rasterizer.point_count() << "\n\n";
|
|
}
|
|
BOOST_TEST(output_views[0](0, 0) == rasterizer.point_count());
|
|
}
|
|
|
|
int main()
|
|
{
|
|
const int test_dim_length = 20;
|
|
for (std::ptrdiff_t radius = 5; radius < test_dim_length; ++radius)
|
|
{
|
|
for (std::ptrdiff_t x_offset = radius; x_offset < radius + test_dim_length; ++x_offset)
|
|
{
|
|
for (std::ptrdiff_t y_offset = radius; y_offset < radius + test_dim_length; ++y_offset)
|
|
{
|
|
|
|
exact_fit_test(radius, {x_offset, y_offset},
|
|
gil::midpoint_circle_rasterizer{{x_offset, y_offset}, radius});
|
|
exact_fit_test(radius, {x_offset, y_offset},
|
|
gil::trigonometric_circle_rasterizer{{x_offset, y_offset}, radius});
|
|
}
|
|
}
|
|
}
|
|
|
|
return boost::report_errors();
|
|
}
|