8 #ifndef BOOST_GIL_IMAGE_PROCESSING_NUMERIC_HPP     9 #define BOOST_GIL_IMAGE_PROCESSING_NUMERIC_HPP    11 #include <boost/gil/extension/numeric/kernel.hpp>    12 #include <boost/gil/extension/numeric/convolve.hpp>    13 #include <boost/gil/image_view.hpp>    14 #include <boost/gil/typedefs.hpp>    15 #include <boost/gil/detail/math.hpp>    20 namespace boost { 
namespace gil {
    33 inline double normalized_sinc(
double x)
    35     return std::sin(x * boost::gil::pi) / (x * boost::gil::pi);
    45 inline double lanczos(
double x, std::ptrdiff_t a)
    52         return normalized_sinc(x) / normalized_sinc(x / static_cast<double>(a));
    57 inline void compute_tensor_entries(
    58     boost::gil::gray16s_view_t dx,
    59     boost::gil::gray16s_view_t dy,
    60     boost::gil::gray32f_view_t m11,
    61     boost::gil::gray32f_view_t m12_21,
    62     boost::gil::gray32f_view_t m22)
    64     for (std::ptrdiff_t y = 0; y < dx.height(); ++y) {
    65         for (std::ptrdiff_t x = 0; x < dx.width(); ++x) {
    66             auto dx_value = dx(x, y);
    67             auto dy_value = dy(x, y);
    68             m11(x, y) = dx_value * dx_value;
    69             m12_21(x, y) = dx_value * dy_value;
    70             m22(x, y) = dy_value * dy_value;
    81 template <
typename T = 
float, 
typename Allocator = std::allocator<T>>
    84     if (side_length % 2 != 1)
    85         throw std::invalid_argument(
"kernel dimensions should be odd and equal");
    86     const float entry = 1.0f / static_cast<float>(side_length * side_length);
    88     detail::kernel_2d<T, Allocator> result(side_length, side_length / 2, side_length / 2);
    89     for (
auto& cell: result) {
   100 template <
typename T = 
float, 
typename Allocator = std::allocator<T>>
   103     if (side_length % 2 != 1)
   104         throw std::invalid_argument(
"kernel dimensions should be odd and equal");
   106     detail::kernel_2d<T, Allocator> result(side_length, side_length / 2, side_length / 2);
   107     for (
auto& cell: result) {
   119 template <
typename T = 
float, 
typename Allocator = std::allocator<T>>
   122     if (side_length % 2 != 1)
   123         throw std::invalid_argument(
"kernel dimensions should be odd and equal");
   126     const double denominator = 2 * boost::gil::pi * sigma * sigma;
   127     auto middle = side_length / 2;
   128     std::vector<T, Allocator> values(side_length * side_length);
   129     for (std::size_t y = 0; y < side_length; ++y)
   131         for (std::size_t x = 0; x < side_length; ++x)
   133             const auto delta_x = middle > x ? middle - x : x - middle;
   134             const auto delta_y = middle > y ? middle - y : y - middle;
   135             const double power = (delta_x * delta_x +  delta_y * delta_y) / (2 * sigma * sigma);
   136             const double nominator = std::exp(-power);
   137             const float value = static_cast<float>(nominator / denominator);
   138             values[y * side_length + x] = value;
   142     return detail::kernel_2d<T, Allocator>(values.begin(), values.size(), middle, middle);
   152 template <
typename T = 
float, 
typename Allocator = std::allocator<T>>
   159             return get_identity_kernel<T, Allocator>();
   163             detail::kernel_2d<T, Allocator> result(3, 1, 1);
   164             std::copy(dx_sobel.begin(), dx_sobel.end(), result.begin());
   168             throw std::logic_error(
"not supported yet");
   172     throw std::runtime_error(
"unreachable statement");
   182 template <
typename T = 
float, 
typename Allocator = std::allocator<T>>
   189             return get_identity_kernel<T, Allocator>();
   193             detail::kernel_2d<T, Allocator> result(3, 1, 1);
   194             std::copy(dx_scharr.begin(), dx_scharr.end(), result.begin());
   198             throw std::logic_error(
"not supported yet");
   202     throw std::runtime_error(
"unreachable statement");
   212 template <
typename T = 
float, 
typename Allocator = std::allocator<T>>
   219             return get_identity_kernel<T, Allocator>();
   223             detail::kernel_2d<T, Allocator> result(3, 1, 1);
   224             std::copy(dy_sobel.begin(), dy_sobel.end(), result.begin());
   228             throw std::logic_error(
"not supported yet");
   232     throw std::runtime_error(
"unreachable statement");
   242 template <
typename T = 
float, 
typename Allocator = std::allocator<T>>
   249             return get_identity_kernel<T, Allocator>();
   253             detail::kernel_2d<T, Allocator> result(3, 1, 1);
   254             std::copy(dy_scharr.begin(), dy_scharr.end(), result.begin());
   258             throw std::logic_error(
"not supported yet");
   262     throw std::runtime_error(
"unreachable statement");
   274 template <
typename GradientView, 
typename OutputView>
   284     detail::convolve_2d(dx, sobel_x, ddxx);
   285     detail::convolve_2d(dx, sobel_y, dxdy);
   286     detail::convolve_2d(dy, sobel_y, ddyy);
 detail::kernel_2d< T, Allocator > generate_dy_sobel(unsigned int degree=1)
Generates Sobel operator in vertical directionGenerates a kernel which will represent Sobel operator ...
Definition: numeric.hpp:213
void compute_hessian_entries(GradientView dx, GradientView dy, OutputView ddxx, OutputView dxdy, OutputView ddyy)
Compute xy gradient, and second order x and y gradientsHessian matrix is defined as a matrix of parti...
Definition: numeric.hpp:275
double lanczos(double x, std::ptrdiff_t a)
Lanczos response at point xLanczos response is defined as: x == 0: 1 -a < x && x < a: 0 otherwise: no...
Definition: numeric.hpp:45
BOOST_FORCEINLINE auto copy(boost::gil::pixel< T, CS > *first, boost::gil::pixel< T, CS > *last, boost::gil::pixel< T, CS > *dst) -> boost::gil::pixel< T, CS > *
Copy when both src and dst are interleaved and of the same type can be just memmove.
Definition: algorithm.hpp:139
detail::kernel_2d< T, Allocator > generate_dx_scharr(unsigned int degree=1)
Generate Scharr operator in horizontal directionGenerates a kernel which will represent Scharr operat...
Definition: numeric.hpp:183
detail::kernel_2d< T, Allocator > generate_dx_sobel(unsigned int degree=1)
Generates Sobel operator in horizontal directionGenerates a kernel which will represent Sobel operato...
Definition: numeric.hpp:153
detail::kernel_2d< T, Allocator > generate_unnormalized_mean(std::size_t side_length)
Generate kernel with all 1sFills supplied view with 1s (ones)
Definition: numeric.hpp:101
detail::kernel_2d< T, Allocator > generate_dy_scharr(unsigned int degree=1)
Generate Scharr operator in vertical directionGenerates a kernel which will represent Scharr operator...
Definition: numeric.hpp:243
detail::kernel_2d< T, Allocator > generate_gaussian_kernel(std::size_t side_length, double sigma)
Generate Gaussian kernelFills supplied view with values taken from Gaussian distribution....
Definition: numeric.hpp:120
detail::kernel_2d< T, Allocator > generate_normalized_mean(std::size_t side_length)
Generate mean kernelFills supplied view with normalized mean in which all entries will be equal to.
Definition: numeric.hpp:82