Merge branch 'better_padding' into develop

Author: xd009642

CHANGELOG.md

@@ -0,0 +1,35 @@
+# Change Log
+
+## Develop Branch (Unreleased)
+
+### Added
+* Padding strategies (`NoPadding`, `ConstantPadding`, `ZeroPadding`)
+
+### Changed
+* Integrated Padding strategies into convolutions
+
+### Removed 
+
+## 0.1.1
+
+### Added
+
+### Changed
+* Applied zero padding by default in convolutions
+
+### Removed 
+
+## 0.1.0 (First release)
+
+### Added
+* Image type
+* Colour Models (RGB, Gray, HSV, CIEXYZ, Channel-less)
+* Histogram equalisation
+* Image convolutions
+* `PixelBound` type to aid in rescaling images
+* Canny edge detector
+* `KernelBuilder` and `FixedDimensionKernelBuilder` to create kernels
+* Builder implementations for Sobel, Gaussian, Box Linear filter, Laplace
+* Median filter
+* Sobel Operator
+* PPM encoding and decoding for images

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/mod.rs

@@ -1,12 +1,14 @@
-
-/// This module deals with different colour models and conversions between 
+/// This module deals with different colour models and conversions between
 /// colour models.
 pub mod colour_models;
 /// Core image type and simple operations on it
 pub mod image;
+/// Image padding operations to increase the image size
+pub mod padding;
 /// Essential traits for the functionality of `ndarray-vision`
 pub mod traits;
 
 pub use colour_models::*;
 pub use image::*;
+pub use padding::*;
 pub use traits::*;

src/core/padding.rs

@@ -0,0 +1,164 @@
+use crate::core::{ColourModel, Image};
+use ndarray::{prelude::*, s};
+use num_traits::identities::Zero;
+use std::marker::PhantomData;
+
+/// Defines a method for padding the data of an image applied directly to the
+/// ndarray type internally. Padding is symmetric
+pub trait PaddingStrategy<T>
+where
+    T: Copy,
+{
+    /// Taking in the image data and the margin to apply to rows and columns
+    /// returns a padded image
+    fn pad(&self, image: ArrayView3<T>, padding: (usize, usize)) -> Array3<T>;
+}
+
+/// Doesn't apply any padding to the image returning it unaltered regardless
+/// of padding value
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
+pub struct NoPadding;
+
+/// Pad the image with a constant value
+#[derive(Clone, Eq, PartialEq, Hash, Debug)]
+pub struct ConstantPadding<T>(T)
+where
+    T: Copy;
+
+/// Pad the image with zeros. Uses ConstantPadding internally
+#[derive(Clone, Eq, PartialEq, Hash, Debug)]
+pub struct ZeroPadding;
+
+impl<T> PaddingStrategy<T> for NoPadding
+where
+    T: Copy,
+{
+    fn pad(&self, image: ArrayView3<T>, _padding: (usize, usize)) -> Array3<T> {
+        image.to_owned()
+    }
+}
+
+impl<T> PaddingStrategy<T> for ConstantPadding<T>
+where
+    T: Copy,
+{
+    fn pad(&self, image: ArrayView3<T>, padding: (usize, usize)) -> Array3<T> {
+        let shape = (
+            image.shape()[0] + padding.0 * 2,
+            image.shape()[1] + padding.1 * 2,
+            image.shape()[2],
+        );
+
+        let mut result = Array::from_elem(shape, self.0);
+        result
+            .slice_mut(s![
+                padding.0..shape.0 - padding.0,
+                padding.1..shape.1 - padding.1,
+                ..
+            ])
+            .assign(&image);
+
+        result
+    }
+}
+
+impl<T> PaddingStrategy<T> for ZeroPadding
+where
+    T: Copy + Zero,
+{
+    fn pad(&self, image: ArrayView3<T>, padding: (usize, usize)) -> Array3<T> {
+        let padder = ConstantPadding(T::zero());
+        padder.pad(image, padding)
+    }
+}
+
+/// Padding extension for images
+pub trait PaddingExt {
+    /// Data type for container
+    type Data;
+    /// Pad the object with the given padding and strategy
+    fn pad(&self, padding: (usize, usize), strategy: &dyn PaddingStrategy<Self::Data>) -> Self;
+}
+
+impl<T> PaddingExt for Array3<T>
+where
+    T: Copy,
+{
+    type Data = T;
+
+    fn pad(&self, padding: (usize, usize), strategy: &dyn PaddingStrategy<Self::Data>) -> Self {
+        strategy.pad(self.view(), padding)
+    }
+}
+
+impl<T, C> PaddingExt for Image<T, C>
+where
+    T: Copy,
+    C: ColourModel,
+{
+    type Data = T;
+
+    fn pad(&self, padding: (usize, usize), strategy: &dyn PaddingStrategy<Self::Data>) -> Self {
+        Self {
+            data: strategy.pad(self.data.view(), padding),
+            model: PhantomData,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::core::colour_models::{Gray, RGB};
+
+    #[test]
+    fn constant_padding() {
+        let i = Image::<u8, Gray>::from_shape_data(3, 3, vec![1, 2, 3, 4, 5, 6, 7, 8, 9]);
+
+        let p = i.pad((1, 1), &ConstantPadding(0));
+
+        let exp = Image::<u8, Gray>::from_shape_data(
+            5,
+            5,
+            vec![
+                0, 0, 0, 0, 0, 0, 1, 2, 3, 0, 0, 4, 5, 6, 0, 0, 7, 8, 9, 0, 0, 0, 0, 0, 0,
+            ],
+        );
+        assert_eq!(p, exp);
+
+        let p = i.pad((1, 1), &ConstantPadding(2));
+
+        let exp = Image::<u8, Gray>::from_shape_data(
+            5,
+            5,
+            vec![
+                2, 2, 2, 2, 2, 2, 1, 2, 3, 2, 2, 4, 5, 6, 2, 2, 7, 8, 9, 2, 2, 2, 2, 2, 2,
+            ],
+        );
+        assert_eq!(p, exp);
+
+        let p = i.pad((2, 0), &ConstantPadding(0));
+        let z = i.pad((2, 0), &ZeroPadding {});
+        assert_eq!(p, z);
+
+        let exp = Image::<u8, Gray>::from_shape_data(
+            7,
+            3,
+            vec![
+                0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0,
+            ],
+        );
+        assert_eq!(p, exp);
+    }
+
+    #[test]
+    fn no_padding() {
+        let i = Image::<u8, RGB>::new(5, 5);
+        let p = i.pad((10, 10), &NoPadding {});
+
+        assert_eq!(i, p);
+
+        let p = i.pad((0, 0), &NoPadding {});
+        assert_eq!(i, p);
+    }
+}

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>;
 }