Merge branch 'develop'

Author: daniel-emotech

CHANGELOG.md

@@ -4,6 +4,8 @@
 ### Added
 
 ### Changed
+- Fixed orientation of sobel filters
+- Fixed remove limit on magnitude in sobel magnitude calculation
 
 ### Removed
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ndarray-vision"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["xd009642 <[email protected]>"]
 description = "A computer vision library built on top of ndarray"
 repository = "https://github.com/xd009642/ndarray-vision"
@@ -26,9 +26,11 @@ noisy_float = { version = "0.2", default-features = false }
 num-traits = { version = "0.2", default-features = false }
 
 [dev-dependencies]
+ndarray = { version = "0.15", features = ["approx"] }
 ndarray-rand = "0.14.0"
 rand = "0.8"
 assert_approx_eq = "1.1.0"
+approx = "0.4"
 noisy_float = "0.2"
 png = "0.16"
 ndarray-linalg = { version = "0.14", features = ["intel-mkl"] }

README.md

@@ -24,5 +24,5 @@ See the examples and tests for basic usage.
 # Performance 
 
 Not a lot of work has been put towards performance yet but a rudimentary
-benchmarking project exists [here](https://github.com/xd009642/ndarray-vision-benchmarking)
+benchmarking project exists [here](https://github.com/rust-cv/ndarray-vision-benchmarking)
 for comparative benchmarks against other image processing libraries in rust.

src/core/colour_models.rs

@@ -867,7 +867,7 @@ impl ColourModel for RGBA {
 mod tests {
     use super::*;
     use ndarray::s;
-    use ndarray_rand::{RandomExt, F32};
+    use ndarray_rand::RandomExt;
     use ndarray_stats::QuantileExt;
     use rand::distributions::Uniform;
 
@@ -920,7 +920,7 @@ mod tests {
     #[test]
     fn basic_xyz_rgb_checks() {
         let mut image = Image::<f32, RGB>::new(100, 100);
-        let new_data = Array3::<f32>::random(image.data.dim(), F32(Uniform::new(0.0, 1.0)));
+        let new_data = Array3::<f32>::random(image.data.dim(), Uniform::new(0.0, 1.0));
         image.data = new_data;
 
         let xyz = Image::<f32, CIEXYZ>::from(image.clone());
@@ -937,7 +937,7 @@ mod tests {
     #[test]
     fn generic3_checks() {
         let mut image = Image::<f32, RGB>::new(100, 100);
-        let new_data = Array3::<f32>::random(image.data.dim(), F32(Uniform::new(0.0, 1.0)));
+        let new_data = Array3::<f32>::random(image.data.dim(), Uniform::new(0.0, 1.0));
         image.data = new_data;
         let gen = Image::<_, Generic3>::from(image.clone());
         // Normally don't check floats with equality but data shouldn't have
@@ -987,7 +987,7 @@ mod tests {
     #[test]
     fn generic_model_expand() {
         let mut image = Image::<f32, Generic1>::new(100, 100);
-        let new_data = Array3::<f32>::random(image.data.dim(), F32(Uniform::new(0.0, 1.0)));
+        let new_data = Array3::<f32>::random(image.data.dim(), Uniform::new(0.0, 1.0));
         image.data = new_data;
 
         let large = Image::<_, Generic5>::from(image.clone());

src/processing/kernels.rs

@@ -220,15 +220,16 @@ where
     /// Build a fixed size kernel with the given parameters
     fn build_with_params(p: Self::Params) -> Result<Array3<T>, Error> {
         let two = T::from_i8(2).ok_or_else(|| Error::NumericError)?;
-
-        let vert_sobel = arr2(&[
-            [-T::one(), T::zero(), T::one()],
-            [-two, T::zero(), two],
-            [-T::one(), T::zero(), T::one()],
+        // Gets the gradient along the horizontal axis
+        #[rustfmt::skip]
+        let horz_sobel = arr2(&[
+            [T::one(),  T::zero(), -T::one()],
+            [two,       T::zero(), -two],
+            [T::one(),  T::zero(), -T::one()],
         ]);
         let sobel = match p {
-            Orientation::Vertical => vert_sobel,
-            Orientation::Horizontal => vert_sobel.t().to_owned(),
+            Orientation::Vertical => horz_sobel.t().to_owned(),
+            Orientation::Horizontal => horz_sobel,
         };
         Ok(sobel.insert_axis(Axis(2)))
     }
@@ -253,25 +254,25 @@ mod tests {
     fn test_sobel_filter() {
         // As sobel works with integer numbers I'm going to ignore the perils of
         // floating point comparisons... for now.
-        let filter: Array3<f32> = SobelFilter::build_with_params(Orientation::Vertical).unwrap();
+        let filter: Array3<f32> = SobelFilter::build_with_params(Orientation::Horizontal).unwrap();
 
         assert_eq!(
             filter,
             arr3(&[
-                [[-1.0f32], [0.0f32], [1.0f32]],
-                [[-2.0f32], [0.0f32], [2.0f32]],
-                [[-1.0f32], [0.0f32], [1.0f32]]
+                [[1.0f32], [0.0f32], [-1.0f32]],
+                [[2.0f32], [0.0f32], [-2.0f32]],
+                [[1.0f32], [0.0f32], [-1.0f32]]
             ])
         );
 
-        let filter: Array3<f32> = SobelFilter::build_with_params(Orientation::Horizontal).unwrap();
+        let filter: Array3<f32> = SobelFilter::build_with_params(Orientation::Vertical).unwrap();
 
         assert_eq!(
             filter,
             arr3(&[
-                [[-1.0f32], [-2.0f32], [-1.0f32]],
+                [[1.0f32], [2.0f32], [1.0f32]],
                 [[0.0f32], [0.0f32], [0.0f32]],
-                [[1.0f32], [2.0f32], [1.0f32]]
+                [[-1.0f32], [-2.0f32], [-1.0f32]]
             ])
         )
     }

src/processing/sobel.rs

@@ -2,7 +2,7 @@ use crate::core::*;
 use crate::processing::*;
 use core::mem::MaybeUninit;
 use core::ops::Neg;
-use ndarray::{prelude::*, s, DataMut, OwnedRepr};
+use ndarray::{prelude::*, s, DataMut, OwnedRepr, Zip};
 use num_traits::{cast::FromPrimitive, real::Real, Num, NumAssignOps};
 use std::marker::Sized;
 
@@ -61,12 +61,9 @@ where
         for r in 0..res_shape.0 {
             for c in 0..res_shape.1 {
                 for channel in 0..res_shape.2 {
-                    let mut temp = (h_deriv[[r, c, channel]].powi(2)
+                    let temp = (h_deriv[[r, c, channel]].powi(2)
                         + v_deriv[[r, c, channel]].powi(2))
                     .sqrt();
-                    if temp > T::one() {
-                        temp = T::one();
-                    }
                     unsafe {
                         *result.uget_mut([r, c, channel]) = MaybeUninit::new(temp);
                     }
@@ -81,10 +78,15 @@ where
 
         let mut magnitude = h_deriv.mapv(|x| x.powi(2)) + v_deriv.mapv(|x| x.powi(2));
         magnitude.mapv_inplace(|x| x.sqrt());
-        magnitude.mapv_inplace(|x| if x > T::one() { T::one() } else { x });
 
-        let mut rotation = v_deriv / h_deriv;
-        rotation.mapv_inplace(|x| x.atan());
+        let dim = h_deriv.dim();
+        let mut rotation = Array3::uninit((dim.0, dim.1, dim.2));
+        Zip::from(&mut rotation)
+            .and(&h_deriv)
+            .and(&v_deriv)
+            .for_each(|r, &h, &v| *r = MaybeUninit::new(h.atan2(v)));
+
+        let rotation = unsafe { rotation.assume_init() };
 
         Ok((magnitude, rotation))
     }
@@ -109,3 +111,54 @@ where
             .map(|(m, r)| (Image::from_data(m), Image::from_data(r)))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::*;
+
+    #[test]
+    fn simple() {
+        let mut image: Image<f64, Gray> = ImageBase::new(11, 11);
+        image.data.slice_mut(s![4..7, 4..7, ..]).fill(1.0);
+        image.data.slice_mut(s![3..8, 5, ..]).fill(1.0);
+        image.data.slice_mut(s![5, 3..8, ..]).fill(1.0);
+
+        let sobel = image.full_sobel().unwrap();
+
+        // Did a calculation of sobel_mag[1..9, 1..9, ..] in a spreadsheet
+        #[rustfmt::skip]
+        let mag = vec![0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+            0.0, 0.0, 0.0, 1.41421356237301, 2.0, 1.41421356237301, 0.0, 0.0, 0.0,
+            0.0, 0.0, 1.41421356237301, 4.24264068711929, 4.0, 4.24264068711929, 1.4142135623731, 0.0, 0.0, 
+            0.0, 1.4142135623731, 4.24264068711929, 4.24264068711929, 2.0, 4.24264068711929, 4.24264068711929, 1.4142135623731, 0.0,
+            0.0, 2.0, 4.0, 2.0, 0.0, 2.0, 4.0, 2.0, 0.0,
+            0.0, 1.4142135623731, 4.24264068711929, 4.24264068711929, 2.0, 4.24264068711929, 4.24264068711929, 1.4142135623731, 0.0,
+            0.0, 0.0, 1.4142135623731, 4.24264068711929, 4.0, 4.24264068711929, 1.4142135623731, 0.0,
+            0.0, 0.0, 0.0, 0.0, 1.4142135623731, 2.0, 1.4142135623731, 0.0, 0.0,
+            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+        ];
+
+        let mag = Array::from_shape_vec((9, 9), mag).unwrap();
+
+        assert_abs_diff_eq!(sobel.0.data.slice(s![1..10, 1..10, 0]), mag, epsilon = 1e-5);
+
+        let only_mag = image.apply_sobel().unwrap();
+        assert_abs_diff_eq!(sobel.0.data, only_mag.data);
+
+        // Did a calculation of sobel_rot[1..9, 1..9, ..] in a spreadsheet
+        #[rustfmt::skip]
+        let rot = vec![0.00000000000000,0.00000000000000,0.00000000000000,0.00000000000000,0.00000000000000,0.00000000000000,0.00000000000000,0.00000000000000,0.00000000000000,
+                       0.00000000000000,0.00000000000000,0.00000000000000,-2.35619449019234,3.14159265358979,2.35619449019234,0.00000000000000,0.00000000000000,0.00000000000000,
+                       0.00000000000000,0.00000000000000,-2.35619449019234,-2.35619449019234,3.14159265358979,2.35619449019234,2.35619449019234,0.00000000000000,0.00000000000000,
+                       0.00000000000000,-2.35619449019234,-2.35619449019234,-2.35619449019234,3.14159265358979,2.35619449019234,2.35619449019234,2.35619449019234,0.00000000000000,
+                       0.00000000000000,-1.57079632679490,-1.57079632679490,-1.57079632679490,0.00000000000000,1.57079632679490,1.57079632679490,1.57079632679490,0.00000000000000,
+                       0.00000000000000,-0.78539816339745,-0.78539816339745,-0.78539816339745,0.00000000000000,0.78539816339745,0.78539816339745,0.78539816339745,0.00000000000000,
+                       0.00000000000000,0.00000000000000,-0.78539816339745,-0.78539816339745,0.00000000000000,0.78539816339745,0.78539816339745,0.00000000000000,0.00000000000000,
+                       0.00000000000000,0.00000000000000,0.00000000000000,-0.78539816339745,0.00000000000000,0.78539816339745,0.00000000000000,0.00000000000000,0.00000000000000,
+                       0.00000000000000,0.00000000000000,0.00000000000000,0.00000000000000,0.00000000000000,0.00000000000000,0.00000000000000,0.00000000000000,0.00000000000000];
+        let rot = Array::from_shape_vec((9, 9), rot).unwrap();
+
+        assert_abs_diff_eq!(sobel.1.data.slice(s![1..10, 1..10, 0]), rot, epsilon = 1e-5);
+    }
+}