Get custom filters working (?)

Author: jnickg

src/lib.rs

@@ -97,7 +97,7 @@
 
 #![deny(
   nonstandard_style,
-  unused,
+  // unused,
   unsafe_code,
   future_incompatible,
   rust_2018_idioms,
@@ -106,8 +106,10 @@
   clippy::pedantic
 )]
 
+use std::fmt::Debug;
+
 use image::{DynamicImage, GenericImage, GenericImageView, Pixel};
-use num_traits::{Num, NumCast};
+use num_traits::{clamp, Num, NumCast};
 use thiserror::Error;
 
 /// An enumeration of the errors that may be emitted from the `image_pyramid`
@@ -181,24 +183,24 @@ fn accumulate<P, K>(acc: &mut [K], pixel: &P, weight: K)
 where
   P: Pixel,
   <P as Pixel>::Subpixel: Into<K>,
-  K: Num + Copy,
+  K: Num + Copy + Debug,
 {
   acc
     .iter_mut()
-    .enumerate()
-    .take(P::CHANNEL_COUNT as usize)
-    .for_each(|(i, a)| {
-      *a = *a + pixel.channels()[i].into() * weight;
+    .zip(pixel.channels().iter())
+    .for_each(|(a, c)| {
+      let new_val = <<P as Pixel>::Subpixel as Into<K>>::into(*c) * weight;
+      *a = *a + new_val;
     });
 }
 
-pub struct Kernel<K> {
+struct Kernel<K> {
   data:   Vec<K>,
   width:  u32,
   height: u32,
 }
 
-impl<K: Num + Copy> Kernel<K> {
+impl<K: Num + Copy + Debug> Kernel<K> {
   /// Construct a kernel from a slice and its dimensions. The input slice is
   /// in row-major form. For example, a 3x3 matrix with data
   /// `[0,1,0,1,2,1,0,1,0`] describes the following matrix:
@@ -261,6 +263,10 @@ impl<K: Num + Copy> Kernel<K> {
   /// | 0 1 0 |
   /// └       ┘
   /// ```
+  /// ...where `6` is computed dynamically by summing the elements of the
+  /// kernel. In other words, all the weights in a normalized kernel sum to
+  /// 1.0. This is useful, as many filters have this property
+  ///
   /// # Errors
   ///
   /// - If `width == 0 || height == 0`, [`ImagePyramidError::Internal`] is
@@ -272,28 +278,30 @@ impl<K: Num + Copy> Kernel<K> {
   ///
   /// In debug builds, this factory panics under the conditions that [`Err`] is
   /// returned for release builds.
-  pub fn new_normalized(data: &[K], width: u32, height: u32) -> Result<Self, ImagePyramidError> {
+  pub fn new_normalized(data: &[K], width: u32, height: u32) -> Result<Kernel<f32>, ImagePyramidError>
+    where K: Into<f32>
+  {
     let mut sum = K::zero();
     for i in data {
       sum = sum + *i;
     }
-    let data_norm: Vec<K> = data.iter().map(|x| *x / sum).collect();
-    Self::new(&data_norm, width, height)
+    let data_norm: Vec<f32> = data.iter().map(|x| <K as Into<f32>>::into(*x) / <K as Into<f32>>::into(sum)).collect();
+    Kernel::<f32>::new(&data_norm, width, height)
   }
 
   /// Returns 2d correlation of an image. Intermediate calculations are
   /// performed at type K, and the results converted to pixel Q via f. Pads by
   /// continuity.
   #[allow(unsafe_code)]
-  pub fn filter<I, F>(&self, image: &I, mut f: F) -> I
+  #[allow(unused)]
+  pub fn filter_in_place<I, F>(&self, image: &mut I, mut f: F)
   where
     I: GenericImage + Clone,
     <<I as GenericImageView>::Pixel as Pixel>::Subpixel: Into<K>,
     F: FnMut(&mut <<I as GenericImageView>::Pixel as Pixel>::Subpixel, K),
   {
     use core::cmp::{max, min};
     let (width, height) = image.dimensions();
-    let mut out: I = image.clone();
     let num_channels = <<I as GenericImageView>::Pixel as Pixel>::CHANNEL_COUNT as usize;
     let zero = K::zero();
     let mut acc = vec![zero; num_channels];
@@ -313,11 +321,11 @@ impl<K: Num + Copy> Kernel<K> {
         for k_y in 0..k_height {
           #[allow(clippy::cast_possible_truncation)]
           #[allow(clippy::cast_sign_loss)]
-          let y_p = min(height - 1, max(0, y + k_y - k_height / 2)) as u32;
+          let y_p = clamp(y + k_y - k_height / 2, 0, height - 1) as u32;
           for k_x in 0..k_width {
             #[allow(clippy::cast_possible_truncation)]
             #[allow(clippy::cast_sign_loss)]
-            let x_p = min(width - 1, max(0, x + k_x - k_width / 2)) as u32;
+            let x_p = clamp(x + k_x - k_width / 2, 0, width - 1) as u32;
             #[allow(clippy::cast_possible_truncation)]
             #[allow(clippy::cast_sign_loss)]
             let k_idx = (k_y * k_width + k_x) as usize;
@@ -329,17 +337,15 @@ impl<K: Num + Copy> Kernel<K> {
             );
           }
         }
-        let mut out_pel = out.get_pixel(x_u32, y_u32);
+        let mut out_pel = image.get_pixel(x_u32, y_u32);
         let out_channels = out_pel.channels_mut();
         for (a, c) in acc.iter_mut().zip(out_channels.iter_mut()) {
           f(c, *a);
           *a = zero;
         }
-        out.put_pixel(x_u32, y_u32, out_pel);
+        image.put_pixel(x_u32, y_u32, out_pel);
       }
     }
-
-    out
   }
 }
 
@@ -494,20 +500,20 @@ impl<'a> CanComputePyramid for ImageToProcess<'a> {
     ) -> Result<Vec<DynamicImage>, ImagePyramidError> {
       let mut levels = vec![image.clone()];
       let kernel = match params.smoothing_type {
-        SmoothingType::Gaussian => Kernel::new_normalized(&[1, 2, 3, 2, 4, 2, 1, 2, 1], 3, 3)?,
-        SmoothingType::Box => Kernel::new_normalized(&[1, 1, 1, 1, 1, 1, 1, 1, 1], 3, 3)?,
-        SmoothingType::Triangle => Kernel::new_normalized(&[1, 2, 1, 2, 4, 2, 1, 2, 1], 3, 3)?,
+        SmoothingType::Gaussian => Kernel::new_normalized(&[1u8, 2, 3, 2, 4, 2, 1, 2, 1], 3, 3)?,
+        SmoothingType::Box => Kernel::new_normalized(&[1u8, 1, 1, 1, 1, 1, 1, 1, 1], 3, 3)?,
+        SmoothingType::Triangle => Kernel::new_normalized(&[1u8, 2, 1, 2, 4, 2, 1, 2, 1], 3, 3)?,
       };
       let mut current_level = image.clone();
       #[allow(clippy::cast_possible_truncation)]
       #[allow(clippy::cast_precision_loss)]
       #[allow(clippy::cast_sign_loss)]
       while current_level.width() > 1 && current_level.height() > 1 {
-        current_level = kernel.filter(&current_level, |c, a| *c = num_traits::clamp(a, 0, 255));
+        kernel.filter_in_place(&mut current_level, |c, a| *c = a as u8);
         current_level = current_level.resize_exact(
           (current_level.width() as f32 * params.scale_factor.get()) as u32,
           (current_level.height() as f32 * params.scale_factor.get()) as u32,
-          image::imageops::FilterType::Nearest,
+          image::imageops::FilterType::Gaussian,
         );
         levels.push(current_level.clone());
       }
@@ -591,6 +597,28 @@ mod tests {
 
   use super::*;
 
+  #[test]
+  fn kernel_filter_in_place() {
+    let mut image = DynamicImage::new_rgb8(3, 3);
+    let mut other = DynamicImage::new_rgb8(3, 3);
+    let mut i = 0;
+    for y in 0..3 {
+      for x in 0..3 {
+        let mut pel = image.get_pixel(x, y);
+        pel.apply_without_alpha(|_| i);
+        image.put_pixel(x, y, pel);
+
+        let mut pel = other.get_pixel(x, y);
+        pel.apply_without_alpha(|_| i + 1);
+        other.put_pixel(x, y, pel);
+        i += 1;
+      }
+    }
+    let kernel = Kernel::new_normalized(&[1u8, 2, 1, 2, 4, 2, 1, 2, 1], 3, 3).unwrap();
+    kernel.filter_in_place(&mut image, |c, a| *c = a as u8);
+    assert_eq!(image.get_pixel(1, 1), image::Rgba::<u8>([4, 4, 4, 255]));
+  }
+
   #[test]
   fn compute_image_pyramid_imagepyramidtype_steerable_unimplemented() {
     let image = DynamicImage::new_rgb8(640, 480);