A Rust implementation of image-blurring using disc-shaped kernels to produce a 'Bokeh' lens-effect.
Draws heavily on the work done here by Mike Pound.
The disc-shaped kernels are approximated by a sum of complex Gaussian kernels. As a Gaussian blur is separable, instead of applying a single 2-D kernel during convolution, a 1-D kernel on each axis can be applied. To form a Bokeh blur effect, a disc-shaped kernel is used. This kernel is created by summing multiple complex Gaussian kernels, with the number of components improving the quality of the approximation. These relative weights of these components are found by attempting to minimise the deviation from a perfectly shaped kernel. See more here and here.
To view the shapes of the kernels for different numbers of compoents and for different kernel radii, see here. As can be see from this after 4/5 components there are very much diminishing returns in using more. Each additional component used increases the number of convolutions carried out on the image, i.e. using 8 components is 2 times slower than using 4.
Currently only images with 4 channels are supported.
Seperate APIs are available which allow a mask to be passed. This mask
allows pixels of the original image to be retained. This should be
a iterable of [bool]'s, where true's correspond to the convolved image
and false's corresponsed to the original.
Using the image library (requires the default image feature):
```rust
use bokeh::{params::KERNEL9PARAMSET, Blur};
use image::{io::Reader as ImageReader, ImageError};
// read the image
let mut img = ImageReader::open("myimage.jpg")?.decode()?;
// as the bokeh::Blur trait is imported
img.bokehblur(1.0, &KERNEL9PARAM_SET, 3.0);
// save the image
img.save("output.png")?;
```
Using functions directly: ```rust use bokeh::{bokehblur, params::KERNEL9PARAM_SET};
// create simple 'image' let mut pixels = vec![[0., 0., 0., 0.]; 9]; pixels[4] = [255., 255., 255., 255.];
// blur the image using 9 components bokehblur(&mut pixels, 3, 3, 1.0, &KERNEL9PARAM_SET, 3.0);
// pixels now blurred
assert_eq!(
vec![
1.6428886692061846,
14.80242203513296,
1.6428886692061846,
14.802422035132915,
254.93338630375473,
14.802422035132915,
1.6428886692061846,
14.80242203513296,
1.6428886692061846
]
.iter()
.map(|&i| [i, i, i, i])
.collect::
A utility struct [Image] is also provided:
```rust
use bokeh::{Blur, Image, params::KERNEL9PARAMSET};
let mut pixels = vec![[0., 0., 0., 0.]; 9]; pixels[4] = [255., 255., 255., 255.]; // same as above but using the struct let mut img = Image::new(&mut pixels, 3, 3);
img.bokehblur(1.0, &KERNEL9PARAM_SET, 3.0);
assert_eq!(
vec![
1.6428886692061846,
14.80242203513296,
1.6428886692061846,
14.802422035132915,
254.93338630375473,
14.802422035132915,
1.6428886692061846,
14.80242203513296,
1.6428886692061846
]
.iter()
.map(|&i| [i, i, i, i])
.collect::
Providing a mask: ```rust use bokeh::{Blur, Image, params::KERNEL9PARAMSET};
let mut pixels = vec![[0., 0., 0., 0.]; 9]; pixels[4] = [255., 255., 255., 255.]; // creating a mask let mask = vec![false, true, false, true, false, true, false, true, false]; let mut img = Image::new(&mut pixels, 3, 3);
img.bokehblurwithmask(&mask, 1.0, &KERNEL9PARAM_SET, 3.0);
assert_eq!(
vec![
0.,
14.80242203513296,
0.,
14.802422035132915,
255.,
14.802422035132915,
0.,
14.80242203513296,
0.
]
.iter()
.map(|&i| [i, i, i, i])
.collect::
In theassert!` statement above, comparing it to the previous example, it
can be seen that the original pixel values are retained.
License: MIT
