Run Cargo fmt

Author: xd009642

src/core/colour_models.rs

@@ -26,15 +26,15 @@ pub struct HSI;
 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
 pub struct HSL;
 /// YCrCb represents an image as luma, red-difference chroma and blue-difference
-/// chroma. 
+/// chroma.
 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
 pub struct YCrCb;
 /// CIE XYZ standard - assuming a D50 reference white
 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
 pub struct CIEXYZ;
 /// CIE LAB (also known as CIE L*a*b* or Lab) a colour model that represents
 /// colour as lightness, and a* and b* as the green-red and blue-yellow colour
-/// differences respectively. It is designed to be representative of human 
+/// differences respectively. It is designed to be representative of human
 /// perception of colour
 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
 pub struct CIELAB;
@@ -917,5 +917,4 @@ mod tests {
             assert_eq!(large.data.slice(s![.., .., i]), zeros);
         }
     }
-
 }

src/core/image.rs

@@ -15,7 +15,7 @@ where
     /// Images are always going to be 3D to handle rows, columns and colour
     /// channels
     ///
-    /// This should allow for max compatibility with maths ops in ndarray. 
+    /// This should allow for max compatibility with maths ops in ndarray.
     /// Caution should be taken if performing any operations that change the
     /// number of channels in an image as this may cause other functionality to
     /// perform incorrectly. Use conversions to one of the `Generic` colour models
@@ -61,7 +61,7 @@ where
         }
     }
 
-    /// Given the shape of the image and a data vector create an image. If 
+    /// Given the shape of the image and a data vector create an image. If
     /// the data sizes don't match a zero filled image will be returned instead
     /// of panicking
     pub fn from_shape_data(rows: usize, cols: usize, data: Vec<T>) -> Self {
@@ -151,5 +151,4 @@ mod tests {
             arr1(&[u16::max_value(), 0, u16::max_value() / 3])
         );
     }
-
 }

src/core/traits.rs

@@ -22,13 +22,13 @@
 /// corresponding methods in `u8`
 /// ```
 pub trait PixelBound {
-    /// The minimum value a pixel can take 
+    /// The minimum value a pixel can take
     fn min_pixel() -> Self;
     /// The maximum value a pixel can take
     fn max_pixel() -> Self;
 
-    /// Returns the number of discrete levels. This is an option because it's 
-    /// deemed meaningless for types like floats which suffer from rounding 
+    /// Returns the number of discrete levels. This is an option because it's
+    /// deemed meaningless for types like floats which suffer from rounding
     /// issues
     fn discrete_levels() -> Option<usize>;
 }

src/enhancement/histogram_equalisation.rs

@@ -1,11 +1,14 @@
 use crate::core::*;
 use ndarray::prelude::*;
-use ndarray_stats::{HistogramExt, histogram::Grid};
-use num_traits::{Num, NumAssignOps};
+use ndarray_stats::{histogram::Grid, HistogramExt};
 use num_traits::cast::{FromPrimitive, ToPrimitive};
+use num_traits::{Num, NumAssignOps};
 
 /// Extension trait to implement histogram equalisation on other types
-pub trait HistogramEqExt<A> where A: Ord {
+pub trait HistogramEqExt<A>
+where
+    A: Ord,
+{
     /// Equalises an image histogram returning a new image.
     /// Grids should be for a 1xN image as the image is flattened during processing
     fn equalise_hist(&self, grid: Grid<A>) -> Self;
@@ -15,10 +18,9 @@ pub trait HistogramEqExt<A> where A: Ord {
     fn equalise_hist_inplace(&mut self, grid: Grid<A>);
 }
 
-
 impl<T> HistogramEqExt<T> for Array3<T>
 where
-    T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive + PixelBound
+    T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive + PixelBound,
 {
     fn equalise_hist(&self, grid: Grid<T>) -> Self {
         let mut result = self.clone();
@@ -29,11 +31,9 @@ where
     fn equalise_hist_inplace(&mut self, grid: Grid<T>) {
         for mut c in self.axis_iter_mut(Axis(2)) {
             // get the histogram
-            let flat = Array::from_iter(c.iter())
-                .mapv(|x| *x)
-                .insert_axis(Axis(1));
+            let flat = Array::from_iter(c.iter()).mapv(|x| *x).insert_axis(Axis(1));
             let hist = flat.histogram(grid.clone());
-            // get cdf 
+            // get cdf
             let mut running_total = 0;
             let mut min = 0.0;
             let cdf = hist.counts().mapv(|x| {
@@ -43,9 +43,11 @@ where
                 }
                 running_total as f32
             });
-             
+
             // Rescale cdf writing back new values
-            let scale = (T::max_pixel() - T::min_pixel()).to_f32().unwrap_or_default();
+            let scale = (T::max_pixel() - T::min_pixel())
+                .to_f32()
+                .unwrap_or_default();
             let denominator = flat.len() as f32 - min;
             c.mapv_inplace(|x| {
                 let index = match grid.index_of(&arr1(&[x])) {
@@ -55,10 +57,10 @@ where
                         } else {
                             i[0]
                         }
-                    },
+                    }
                     None => 0,
                 };
-                let mut f_res = ((cdf[index] - min)/denominator)*scale;
+                let mut f_res = ((cdf[index] - min) / denominator) * scale;
                 if T::discrete_levels().is_some() {
                     f_res = f_res.round();
                 }
@@ -68,9 +70,8 @@ where
     }
 }
 
-
-impl<T, C> HistogramEqExt<T> for Image<T, C> 
-where 
+impl<T, C> HistogramEqExt<T> for Image<T, C>
+where
     Image<T, C>: Clone,
     T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive + PixelBound,
     C: ColourModel,
@@ -86,38 +87,33 @@ where
     }
 }
 
-
 #[cfg(test)]
 mod tests {
+    use super::*;
     use crate::core::Gray;
     use ndarray_stats::histogram::{Bins, Edges};
-    use super::*;
 
     #[test]
     fn hist_eq_test() {
         // test data from wikipedia
-        let input_pixels = vec![52, 55, 61, 59, 70, 61, 76, 61, 
-                                62, 59, 55, 104, 94, 85, 59, 71,
-                                63, 65, 66, 113, 144, 104, 63, 72,
-                                64, 70, 70, 126, 154, 109, 71, 69,
-                                67, 73, 68, 106, 122, 88, 68, 68,
-                                68, 79, 60, 79, 77, 66, 58, 75,
-                                69, 85, 64, 58, 55, 61, 65, 83,
-                                70, 87, 69, 68, 65, 73, 78, 90,];
+        let input_pixels = vec![
+            52, 55, 61, 59, 70, 61, 76, 61, 62, 59, 55, 104, 94, 85, 59, 71, 63, 65, 66, 113, 144,
+            104, 63, 72, 64, 70, 70, 126, 154, 109, 71, 69, 67, 73, 68, 106, 122, 88, 68, 68, 68,
+            79, 60, 79, 77, 66, 58, 75, 69, 85, 64, 58, 55, 61, 65, 83, 70, 87, 69, 68, 65, 73, 78,
+            90,
+        ];
 
-        let output_pixels = vec![0, 12, 53, 32, 146, 53, 174, 53,
-                                 57, 32, 12, 227, 219, 202, 32, 154,
-                                 65, 85, 93, 239, 251, 227, 65, 158,
-                                 73, 146, 146, 247, 255, 235, 154, 130,
-                                 97, 166, 117, 231, 243, 210, 117, 117,
-                                 117, 190, 36, 190, 178, 93, 20, 170,
-                                 130, 202, 73, 20, 12, 53, 85, 194,
-                                 146, 206, 130, 117, 85, 166, 182, 215];
+        let output_pixels = vec![
+            0, 12, 53, 32, 146, 53, 174, 53, 57, 32, 12, 227, 219, 202, 32, 154, 65, 85, 93, 239,
+            251, 227, 65, 158, 73, 146, 146, 247, 255, 235, 154, 130, 97, 166, 117, 231, 243, 210,
+            117, 117, 117, 190, 36, 190, 178, 93, 20, 170, 130, 202, 73, 20, 12, 53, 85, 194, 146,
+            206, 130, 117, 85, 166, 182, 215,
+        ];
 
         let input = Image::<u8, Gray>::from_shape_data(8, 8, input_pixels);
-        
+
         let expected = Image::<u8, Gray>::from_shape_data(8, 8, output_pixels);
-    
+
         let edges_vec: Vec<u8> = (0..255).collect();
         let grid = Grid::from(vec![Bins::new(Edges::from(edges_vec))]);
 

src/enhancement/mod.rs

@@ -1,4 +1,3 @@
-
 /// Implementation of histogram equalisation for images
 pub mod histogram_equalisation;
 

src/lib.rs

@@ -27,9 +27,9 @@
 
 /// The core of `ndarray-vision` contains the `Image` type and colour models
 pub mod core;
+/// Image enhancement intrinsics and algorithms
+pub mod enhancement;
 /// Image formats - encoding and decoding images from bytes for saving and loading
 pub mod format;
 /// Image processing intrinsics and common filters/algorithms.
 pub mod processing;
-/// Image enhancement intrinsics and algorithms
-pub mod enhancement;

src/processing/canny.rs

@@ -320,5 +320,4 @@ mod tests {
 
         assert_eq!(result, expected);
     }
-
 }

src/processing/conv.rs

@@ -6,29 +6,12 @@ use num_traits::{Num, NumAssignOps};
 use std::marker::PhantomData;
 use std::marker::Sized;
 
-pub struct NoPadding;
-pub struct ZeroPadding;
-pub struct ExtendPadding;
-
-pub trait ImagePadder where Self: Sized + Copy {
-    type Data;
-
-    fn pad(&self, pad_size: (usize, usize)) -> Self;
-}
-
-
-impl<T> ImagePadder<T> for NoPadding {
-    fn pad(&self, pad_size: (usize, usize)) -> Self {
-        *self
-    }
-}
-
 /// Perform image convolutions
 pub trait ConvolutionExt
 where
     Self: Sized,
 {
-    /// Underlying data type to perform the colution on
+    /// Underlying data type to perform the convolution on
     type Data;
 
     /// Perform a convolution returning the resultant data

src/processing/kernels.rs

@@ -36,7 +36,7 @@ pub trait FixedDimensionKernelBuilder<T> {
 }
 
 /// Create a Laplacian filter, this provides the 2nd spatial derivative of an
-/// image. 
+/// image.
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 pub struct LaplaceFilter;
 
@@ -101,7 +101,7 @@ where
     T: Copy + Clone + FromPrimitive + Num,
 {
     /// The parameter for the Gaussian filter is the horizontal and vertical
-    /// covariances to form the covariance matrix. 
+    /// covariances to form the covariance matrix.
     /// ```ignore
     /// [ Params[0], 0]
     /// [ 0, Params[1]]

src/processing/mod.rs

@@ -1,4 +1,3 @@
-
 /// Implementation of a Canny Edge Detector and associated types
 pub mod canny;
 /// Image convolutions in 2D
@@ -26,7 +25,7 @@ pub enum Error {
     /// Invalid dimensions to an algorithm - this includes rows and columns and
     /// relationships between the two
     InvalidDimensions,
-    /// An invalid parameter has been supplied to an algorithm. 
+    /// An invalid parameter has been supplied to an algorithm.
     InvalidParameter,
     /// Numeric error such as an invalid conversion or issues in floating point
     /// math. As `ndarray` and `ndarray-vision` rely on `num_traits` for a lot