Merge branch 'affine' into develop

Author: xd009642

.travis.yml

@@ -5,6 +5,7 @@ addons:
     apt:
         packages:
             - libssl-dev
+            - gfortran
 cache: cargo
 rust:
   - stable
@@ -14,18 +15,21 @@ matrix:
   allow_failures:
     - rust: nightly
 
-before_cache: |
-  if [[ "$TRAVIS_RUST_VERSION" == nightly ]]; then
-    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install cargo-tarpaulin
-  fi
+before_install: 
+  - curl https://blas-lapack-rs.github.io/travis/fortran.sh | bash
+
+#before_cache: |
+# if [[ "$TRAVIS_RUST_VERSION" == nightly ]]; then
+#   cargo install cargo-tarpaulin
+# fi
 
 script:
 - cargo clean
 - cargo build
 - cargo test
 
-after_success: |
-  if [[ "$TRAVIS_RUST_VERSION" == nightly ]]; then
+# after_success: |
+# if [[ "$TRAVIS_RUST_VERSION" == nightly ]]; then
     # Uncomment the following line for coveralls.io
-    cargo tarpaulin --ciserver travis-ci --coveralls $TRAVIS_JOB_ID
-  fi
+    # cargo tarpaulin --ciserver travis-ci --coveralls $TRAVIS_JOB_ID
+# fi

CHANGELOG.md

@@ -5,10 +5,12 @@
 ### Added
 * Padding strategies (`NoPadding`, `ConstantPadding`, `ZeroPadding`)
 * Threshold module with Otsu and Mean threshold algorithms
+* Image transformations and functions to create affine transform matrices
 
 ### Changed
 * Integrated Padding strategies into convolutions
 * Updated `ndarray-stats` to 0.2.0 adding `noisy_float` for median change
+* [INTERNAL] Disabled code coverage due to issues with tarpaulin and native libraries
 
 ### Removed 
 

Cargo.toml

@@ -13,6 +13,7 @@ edition = "2018"
 [dependencies]
 ndarray = "0.13"
 ndarray-stats = "0.3"
+ndarray-linalg = "0.12"
 noisy_float = "0.1"
 num-traits = "0.2"
 
@@ -21,3 +22,5 @@ ndarray-rand = "0.11.0"
 rand = "0.7"
 assert_approx_eq = "1.1.0"
 noisy_float = "0.1.11"
+openblas-src = "0.7"
+png = "0.15"

examples/transforms.rs

@@ -0,0 +1,66 @@
+extern crate openblas_src;
+
+use ndarray_vision::core::*;
+use ndarray_vision::format::netpbm::*;
+use ndarray_vision::format::*;
+use ndarray_vision::transform::affine::*;
+use ndarray_vision::transform::*;
+use std::env::current_exe;
+use std::f64::consts::FRAC_PI_4;
+use std::fs::File;
+use std::io::BufWriter;
+use std::path::{Path, PathBuf};
+
+fn get_lena() -> Option<Image<u8, RGB>> {
+    if let Ok(mut root) = current_exe() {
+        root.pop();
+        root.pop();
+        root.pop();
+        root.pop();
+        let mut lena = PathBuf::from(&root);
+        lena.push("images/lena.ppm");
+
+        let decoder = PpmDecoder::default();
+        let image: Image<u8, _> = decoder.decode_file(lena).expect("Couldn't open Lena.ppm");
+        Some(image)
+    } else {
+        None
+    }
+}
+
+fn main() {
+    let lena = get_lena().expect("Couldn't load lena");
+
+    // Create transformation matrix
+    let x = 0.5 * (lena.cols() as f64) - 0.5;
+    let y = 0.5 * (lena.rows() as f64) - 0.5;
+    let trans = rotate_around_centre(FRAC_PI_4, (x, y)).dot(&scale(0.7, 0.7));
+
+    let transformed = lena
+        .transform(trans.view(), None)
+        .expect("Transform failed");
+
+    // save
+    let path = Path::new("transformed_lena.png");
+    let file = File::create(path).expect("Couldn't create output file");
+    let ref mut w = BufWriter::new(file);
+
+    let mut encoder = png::Encoder::new(w, transformed.cols() as u32, transformed.rows() as u32);
+    encoder.set_color(png::ColorType::RGB);
+    encoder.set_depth(png::BitDepth::Eight);
+
+    println!(
+        "Writing image with resolution {}x{}",
+        transformed.cols(),
+        transformed.rows()
+    );
+
+    let mut writer = encoder.write_header().expect("Failed to write file header");
+    if let Some(data) = transformed.data.view().to_slice() {
+        writer
+            .write_image_data(data)
+            .expect("Failed to write image data");
+    } else {
+        println!("Failed to get image slice");
+    }
+}

src/lib.rs

@@ -33,3 +33,5 @@ pub mod enhancement;
 pub mod format;
 /// Image processing intrinsics and common filters/algorithms.
 pub mod processing;
+/// Image transforms and warping
+pub mod transform;

src/transform/affine.rs

@@ -0,0 +1,42 @@
+use ndarray::{array, prelude::*};
+
+pub enum Axes {
+    X,
+    Y,
+    Z,
+}
+
+pub fn rotate_around_centre(radians: f64, centre: (f64, f64)) -> Array2<f64> {
+    translation(centre.0, centre.1)
+        .dot(&rotation_3d(radians, Axes::Z))
+        .dot(&translation(-centre.0, -centre.1))
+}
+
+pub fn rotation_2d(radians: f64) -> Array2<f64> {
+    let s = radians.sin();
+    let c = radians.cos();
+    array![[c, -s], [s, c]]
+}
+
+pub fn rotation_3d(radians: f64, ax: Axes) -> Array2<f64> {
+    let s = radians.sin();
+    let c = radians.cos();
+
+    match ax {
+        Axes::X => array![[1.0, 0.0, 0.0], [0.0, c, -s], [0.0, s, c]],
+        Axes::Y => array![[c, 0.0, s], [0.0, 1.0, 0.0], [-s, 0.0, c]],
+        Axes::Z => array![[c, -s, 0.0], [s, c, 0.0], [0.0, 0.0, 1.0]],
+    }
+}
+
+pub fn translation(x: f64, y: f64) -> Array2<f64> {
+    array![[1.0, 0.0, x], [0.0, 1.0, y], [0.0, 0.0, 1.0]]
+}
+
+pub fn scale(x: f64, y: f64) -> Array2<f64> {
+    array![[x, 0.0, 0.0], [0.0, y, 0.0], [0.0, 0.0, 1.0]]
+}
+
+pub fn shear(x: f64, y: f64) -> Array2<f64> {
+    array![[1.0, x, 0.0], [y, 1.0, 0.0], [0.0, 0.0, 1.0]]
+}

src/transform/mod.rs

@@ -0,0 +1,216 @@
+use crate::core::{ColourModel, Image};
+use crate::transform::affine::translation;
+use ndarray::{array, prelude::*, s, Data};
+use ndarray_linalg::solve::Inverse;
+use num_traits::{Num, NumAssignOps};
+use std::cmp::{max, min};
+use std::marker::PhantomData;
+
+pub mod affine;
+
+#[derive(Clone, Copy, Eq, PartialEq, Debug, Hash)]
+pub enum Error {
+    InvalidTransformation,
+    NonInvertibleTransformation,
+}
+
+pub trait TransformExt
+where
+    Self: Sized,
+{
+    /// Output type for the operation
+    type Output;
+
+    /// Transforms an image given the transformation matrix and output size.
+    /// Assume nearest-neighbour interpolation
+    fn transform(
+        &self,
+        transform: ArrayView2<f64>,
+        output_size: Option<(usize, usize)>,
+    ) -> Result<Self::Output, Error>;
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+struct Rect {
+    x: isize,
+    y: isize,
+    w: usize,
+    h: usize,
+}
+
+fn source_coordinate(p: (f64, f64), trans: ArrayView2<f64>) -> (f64, f64) {
+    let p = match trans.shape()[0] {
+        2 => array![[p.0], [p.1]],
+        3 => array![[p.0], [p.1], [1.0]],
+        _ => unreachable!(),
+    };
+
+    let result = trans.dot(&p);
+    let x = result[[0, 0]];
+    let y = result[[1, 0]];
+    let w = match trans.shape()[0] {
+        2 => 1.0,
+        3 => result[[2, 0]],
+        _ => unreachable!(),
+    };
+    if (w - 1.0).abs() > std::f64::EPSILON {
+        (x / w, y / w)
+    } else {
+        (x, y)
+    }
+}
+
+fn bounding_box(dims: (f64, f64), transform: ArrayView2<f64>) -> Rect {
+    let tl = source_coordinate((0.0, 0.0), transform);
+    let tr = source_coordinate((0.0, dims.1), transform);
+    let br = source_coordinate(dims, transform);
+    let bl = source_coordinate((dims.0, 0.0), transform);
+
+    let tl = (tl.0.round() as isize, tl.1.round() as isize);
+    let tr = (tr.0.round() as isize, tr.1.round() as isize);
+    let br = (br.0.round() as isize, br.1.round() as isize);
+    let bl = (bl.0.round() as isize, bl.1.round() as isize);
+
+    let leftmost = min(min(tl.0, tr.0), min(br.0, bl.0));
+    let topmost = min(min(tl.1, tr.1), min(br.1, bl.1));
+    let rightmost = max(max(tl.0, tr.0), max(br.0, bl.0));
+    let bottommost = max(max(tl.1, tr.1), max(br.1, bl.1));
+    Rect {
+        x: leftmost,
+        y: topmost,
+        w: (rightmost - leftmost) as usize,
+        h: (bottommost - topmost) as usize,
+    }
+}
+
+impl<T, U> TransformExt for ArrayBase<U, Ix3>
+where
+    T: Copy + Clone + Num + NumAssignOps,
+    U: Data<Elem = T>,
+{
+    type Output = Array3<T>;
+
+    fn transform(
+        &self,
+        transform: ArrayView2<f64>,
+        output_size: Option<(usize, usize)>,
+    ) -> Result<Self::Output, Error> {
+        let shape = transform.shape();
+        if !(shape[0] == 3 || shape[0] == 2) {
+            Err(Error::InvalidTransformation)
+        } else {
+            let (mut result, new_transform) = match output_size {
+                Some((r, c)) => (
+                    Self::Output::zeros((r, c, self.shape()[2])),
+                    transform.into_owned(),
+                ),
+                None => {
+                    let dims = (self.shape()[0] as f64, self.shape()[1] as f64);
+                    let bounds = bounding_box(dims, transform.view());
+                    let new_trans = translation(bounds.x as f64, -bounds.y as f64).dot(&transform);
+                    (
+                        Self::Output::zeros((bounds.h, bounds.w, self.shape()[2])),
+                        new_trans,
+                    )
+                }
+            };
+
+            let transform = new_transform
+                .inv()
+                .map_err(|_| Error::NonInvertibleTransformation)?;
+            for r in 0..result.shape()[0] {
+                for c in 0..result.shape()[1] {
+                    let (x, y) = source_coordinate((c as f64, r as f64), transform.view());
+                    let x = x.round() as isize;
+                    let y = y.round() as isize;
+                    if x >= 0
+                        && y >= 0
+                        && (x as usize) < self.shape()[1]
+                        && (y as usize) < self.shape()[0]
+                    {
+                        result
+                            .slice_mut(s![r, c, ..])
+                            .assign(&self.slice(s![y, x, ..]));
+                    }
+                }
+            }
+            Ok(result)
+        }
+    }
+}
+
+impl<T, C> TransformExt for Image<T, C>
+where
+    T: Copy + Clone + Num + NumAssignOps,
+    C: ColourModel,
+{
+    type Output = Self;
+
+    fn transform(
+        &self,
+        transform: ArrayView2<f64>,
+        output_size: Option<(usize, usize)>,
+    ) -> Result<Self::Output, Error> {
+        let data = self.data.transform(transform, output_size)?;
+        Ok(Self {
+            data,
+            model: PhantomData,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    extern crate openblas_src;
+
+    use super::affine;
+    use super::*;
+    use crate::core::colour_models::Gray;
+    use std::f64::consts::PI;
+
+    #[test]
+    fn translation() {
+        let src_data = vec![2.0, 0.0, 1.0, 0.0, 5.0, 0.0, 1.0, 2.0, 3.0];
+        let src = Image::<f64, Gray>::from_shape_data(3, 3, src_data);
+
+        let trans = affine::translation(2.0, 1.0);
+
+        let res = src.transform(trans.view(), Some((3, 3)));
+        assert!(res.is_ok());
+        let res = res.unwrap();
+
+        let expected = vec![0.0, 0.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0];
+        let expected = Image::<f64, Gray>::from_shape_data(3, 3, expected);
+
+        assert_eq!(expected, res)
+    }
+
+    #[test]
+    fn rotate() {
+        let src = Image::<u8, Gray>::from_shape_data(5, 5, (0..25).collect());
+        let trans = affine::rotate_around_centre(PI, (2.0, 2.0));
+        let upside_down = src.transform(trans.view(), Some((5, 5))).unwrap();
+
+        let res = upside_down.transform(trans.view(), Some((5, 5))).unwrap();
+
+        assert_eq!(src, res);
+
+        let trans_2 = affine::rotate_around_centre(PI / 2.0, (2.0, 2.0));
+        let trans_3 = affine::rotate_around_centre(-PI / 2.0, (2.0, 2.0));
+
+        let upside_down_sideways = upside_down.transform(trans_2.view(), Some((5, 5))).unwrap();
+        let src_sideways = src.transform(trans_3.view(), Some((5, 5))).unwrap();
+
+        assert_eq!(upside_down_sideways, src_sideways);
+    }
+
+    #[test]
+    fn scale() {
+        let src = Image::<u8, Gray>::from_shape_data(4, 4, (0..16).collect());
+        let trans = affine::scale(0.5, 2.0);
+        let res = src.transform(trans.view(), None).unwrap();
+
+        assert_eq!(res.rows(), 8);
+        assert_eq!(res.cols(), 2);
+    }
+}