pub fn sobel_gradient_map<P, F, Q>(image: &Image<P>, f: F) -> Image<Q>
where
    P: Pixel<Subpixel = u8> + WithChannel<u16> + WithChannel<i16>,
    Q: Pixel,
    ChannelMap<P, u16>: HasBlack,
    F: Fn(ChannelMap<P, u16>) -> Q,
{
    gradients(
        image,
        kernel::SOBEL_HORIZONTAL_3X3,
        kernel::SOBEL_VERTICAL_3X3,
        f,
    )
}
Computes per-channel gradients using Sobel filters and calls `f`
to compute each output pixel.

# Examples
```
# extern crate image;
# #[macro_use]
# extern crate imageproc;
# fn main() {
use imageproc::gradients::{sobel_gradient_map};
use image::Luma;
use std::cmp;

// A shallow horizontal gradient in the red
// channel, a steeper vertical gradient in the
// blue channel, constant in the green channel.
let input = rgb_image!(
[0, 5, 0], [1, 5, 0], [2, 5, 0];
[0, 5, 2], [1, 5, 2], [2, 5, 2];
[0, 5, 4], [1, 5, 4], [2, 5, 4]
);

// Computing independent per-channel gradients.
let channel_gradient = rgb_image!(type: u16,
[ 4,  0,  8], [ 8,  0,  8], [ 4,  0,  8];
[ 4,  0, 16], [ 8,  0, 16], [ 4,  0, 16];
[ 4,  0,  8], [ 8,  0,  8], [ 4,  0,  8]
);

assert_pixels_eq!(
sobel_gradient_map(&input, |p| p),
channel_gradient
);

// Defining the gradient of an RGB image to be the
// mean of its per-channel gradients.
let mean_gradient = gray_image!(type: u16,
4, 5, 4;
6, 8, 6;
4, 5, 4
);

assert_pixels_eq!(
sobel_gradient_map(&input, |p| {
let mean = (p[0] + p[1] + p[2]) / 3;
Luma([mean])
}),
mean_gradient
);

// Defining the gradient of an RGB image to be the pixelwise
// maximum of its per-channel gradients.
let max_gradient = gray_image!(type: u16,
8,  8,  8;
16, 16, 16;
8,  8,  8
);

assert_pixels_eq!(
sobel_gradient_map(&input, |p| {
let max = cmp::max(cmp::max(p[0], p[1]), p[2]);
Luma([max])
}),
max_gradient
);
# }
src/gradients.rs