From 59c60b1f115e85c21a901979f32e441b6b1a963a Mon Sep 17 00:00:00 2001
From: xd009642 <danielmckenna93@gmail.com>
Date: Tue, 26 Nov 2019 23:08:22 +0000
Subject: [PATCH 1/9] WIP for the grand refactor

Types types types. What type of trouble do I make for myself
---
 src/core/colour_models.rs                 | 232 +++++++++++++++-------
 src/core/image.rs                         |  28 ++-
 src/core/padding.rs                       |   8 +-
 src/enhancement/histogram_equalisation.rs |  10 +-
 src/format/mod.rs                         |  15 +-
 src/format/netpbm.rs                      |  26 ++-
 src/processing/canny.rs                   |  10 +-
 src/processing/conv.rs                    |  25 ++-
 src/processing/filter.rs                  |  19 +-
 src/processing/sobel.rs                   |  39 +++-
 src/processing/threshold.rs               |  35 ++--
 src/transform/mod.rs                      |  14 +-
 12 files changed, 312 insertions(+), 149 deletions(-)

diff --git a/src/core/colour_models.rs b/src/core/colour_models.rs
index 36e795a..5260e51 100644
--- a/src/core/colour_models.rs
+++ b/src/core/colour_models.rs
@@ -1,6 +1,6 @@
 use crate::core::traits::*;
 use crate::core::{normalise_pixel_value, Image};
-use ndarray::{prelude::*, s, Zip};
+use ndarray::{prelude::*, s, Data, OwnedRepr, Zip};
 use num_traits::cast::{FromPrimitive, NumCast};
 use num_traits::{Num, NumAssignOps};
 use std::convert::From;
@@ -182,8 +182,9 @@ where
     (red, green, blue)
 }
 
-impl<T> From<Image<T, RGB>> for Image<T, HSV>
+impl<U, T> From<Image<U, RGB>> for Image<U, HSV>
 where
+    U: Data<Elem = T>,
     T: Copy
         + Clone
         + FromPrimitive
@@ -194,7 +195,7 @@ where
         + Display
         + PixelBound,
 {
-    fn from(image: Image<T, RGB>) -> Self {
+    fn from(image: Image<U, RGB>) -> Self {
         let mut res = Array3::<T>::zeros((image.rows(), image.cols(), HSV::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
@@ -210,8 +211,9 @@ where
     }
 }
 
-impl<T> From<Image<T, HSV>> for Image<T, RGB>
+impl<T, U> From<Image<U, HSV>> for Image<U, RGB>
 where
+    U: Data<Elem = T>,
     T: Copy
         + Clone
         + FromPrimitive
@@ -222,7 +224,7 @@ where
         + Display
         + PixelBound,
 {
-    fn from(image: Image<T, HSV>) -> Self {
+    fn from(image: Image<U, HSV>) -> Self {
         let mut res = Array3::<T>::zeros((image.rows(), image.cols(), RGB::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
@@ -238,8 +240,9 @@ where
     }
 }
 
-impl<T> From<Image<T, RGB>> for Image<T, Gray>
+impl<T, U> From<Image<U, RGB>> for Image<U, Gray>
 where
+    U: Data<Elem = T>,
     T: Copy
         + Clone
         + FromPrimitive
@@ -250,7 +253,7 @@ where
         + Display
         + PixelBound,
 {
-    fn from(image: Image<T, RGB>) -> Self {
+    fn from(image: Image<U, RGB>) -> Self {
         let mut res = Array3::<T>::zeros((image.rows(), image.cols(), Gray::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
@@ -268,8 +271,9 @@ where
     }
 }
 
-impl<T> From<Image<T, Gray>> for Image<T, RGB>
+impl<T, U> From<Image<U, Gray>> for Image<U, RGB>
 where
+    U: Data<Elem = T>,
     T: Copy
         + Clone
         + FromPrimitive
@@ -280,7 +284,7 @@ where
         + Display
         + PixelBound,
 {
-    fn from(image: Image<T, Gray>) -> Self {
+    fn from(image: Image<U, Gray>) -> Self {
         let mut res = Array3::<T>::zeros((image.rows(), image.cols(), RGB::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
@@ -294,8 +298,9 @@ where
     }
 }
 
-impl<T> From<Image<T, RGB>> for Image<T, CIEXYZ>
+impl<T, U> From<Image<U, RGB>> for Image<U, CIEXYZ>
 where
+    U: Data<Elem = T>,
     T: Copy
         + Clone
         + FromPrimitive
@@ -306,7 +311,7 @@ where
         + Display
         + PixelBound,
 {
-    fn from(image: Image<T, RGB>) -> Self {
+    fn from(image: Image<U, RGB>) -> Self {
         let mut res = Array3::<T>::zeros((image.rows(), image.cols(), CIEXYZ::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
@@ -332,8 +337,9 @@ where
     }
 }
 
-impl<T> From<Image<T, CIEXYZ>> for Image<T, RGB>
+impl<T, U> From<Image<U, CIEXYZ>> for Image<U, RGB>
 where
+    U: Data<Elem = T>,
     T: Copy
         + Clone
         + FromPrimitive
@@ -344,7 +350,7 @@ where
         + Display
         + PixelBound,
 {
-    fn from(image: Image<T, CIEXYZ>) -> Self {
+    fn from(image: Image<U, CIEXYZ>) -> Self {
         let mut res = Array3::<T>::zeros((image.rows(), image.cols(), RGB::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
@@ -370,241 +376,312 @@ where
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, RGB> {
+impl<T> From<Image<T, Generic3>> for Image<T, RGB>
+where
+    T: Data,
+{
     fn from(image: Image<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, HSV> {
+impl<T> From<Image<T, Generic3>> for Image<T, HSV>
+where
+    T: Data,
+{
     fn from(image: Image<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, HSI> {
+impl<T> From<Image<T, Generic3>> for Image<T, HSI>
+where
+    T: Data,
+{
     fn from(image: Image<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, HSL> {
+impl<T> From<Image<T, Generic3>> for Image<T, HSL>
+where
+    T: Data,
+{
     fn from(image: Image<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, YCrCb> {
+impl<T> From<Image<T, Generic3>> for Image<T, YCrCb>
+where
+    T: Data,
+{
     fn from(image: Image<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, CIEXYZ> {
+impl<T> From<Image<T, Generic3>> for Image<T, CIEXYZ>
+where
+    T: Data,
+{
     fn from(image: Image<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, CIELAB> {
+impl<T> From<Image<T, Generic3>> for Image<T, CIELAB>
+where
+    T: Data,
+{
     fn from(image: Image<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, CIELUV> {
+impl<T> From<Image<T, Generic3>> for Image<T, CIELUV>
+where
+    T: Data,
+{
     fn from(image: Image<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic1>> for Image<T, Gray> {
+impl<T> From<Image<T, Generic1>> for Image<T, Gray>
+where
+    T: Data,
+{
     fn from(image: Image<T, Generic1>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic4>> for Image<T, RGBA> {
+impl<T> From<Image<T, Generic4>> for Image<T, RGBA>
+where
+    T: Data,
+{
     fn from(image: Image<T, Generic4>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, RGB>> for Image<T, Generic3> {
+impl<T> From<Image<T, RGB>> for Image<T, Generic3>
+where
+    T: Data,
+{
     fn from(image: Image<T, RGB>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, HSV>> for Image<T, Generic3> {
+impl<T> From<Image<T, HSV>> for Image<T, Generic3>
+where
+    T: Data,
+{
     fn from(image: Image<T, HSV>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, HSI>> for Image<T, Generic3> {
+impl<T> From<Image<T, HSI>> for Image<T, Generic3>
+where
+    T: Data,
+{
     fn from(image: Image<T, HSI>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, HSL>> for Image<T, Generic3> {
+impl<T> From<Image<T, HSL>> for Image<T, Generic3>
+where
+    T: Data,
+{
     fn from(image: Image<T, HSL>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, YCrCb>> for Image<T, Generic3> {
+impl<T> From<Image<T, YCrCb>> for Image<T, Generic3>
+where
+    T: Data,
+{
     fn from(image: Image<T, YCrCb>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, CIEXYZ>> for Image<T, Generic3> {
+impl<T> From<Image<T, CIEXYZ>> for Image<T, Generic3>
+where
+    T: Data,
+{
     fn from(image: Image<T, CIEXYZ>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, CIELAB>> for Image<T, Generic3> {
+impl<T> From<Image<T, CIELAB>> for Image<T, Generic3>
+where
+    T: Data,
+{
     fn from(image: Image<T, CIELAB>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, CIELUV>> for Image<T, Generic3> {
+impl<T> From<Image<T, CIELUV>> for Image<T, Generic3>
+where
+    T: Data,
+{
     fn from(image: Image<T, CIELUV>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, RGBA>> for Image<T, Generic4> {
+impl<T> From<Image<T, RGBA>> for Image<T, Generic4>
+where
+    T: Data,
+{
     fn from(image: Image<T, RGBA>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Gray>> for Image<T, Generic1> {
+impl<T> From<Image<T, Gray>> for Image<T, Generic1>
+where
+    T: Data,
+{
     fn from(image: Image<T, Gray>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic5>> for Image<T, Generic4>
+impl<T, U> From<Image<U, Generic5>> for Image<U, Generic4>
 where
+    U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<T, Generic5>) -> Self {
+    fn from(image: Image<U, Generic5>) -> Self {
         let shape = (image.rows(), image.cols(), Generic4::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T> From<Image<T, Generic5>> for Image<T, Generic3>
+impl<T, U> From<Image<U, Generic5>> for Image<U, Generic3>
 where
+    U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<T, Generic5>) -> Self {
+    fn from(image: Image<U, Generic5>) -> Self {
         let shape = (image.rows(), image.cols(), Generic3::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T> From<Image<T, Generic5>> for Image<T, Generic2>
+impl<T, U> From<Image<U, Generic5>> for Image<U, Generic2>
 where
+    U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<T, Generic5>) -> Self {
+    fn from(image: Image<U, Generic5>) -> Self {
         let shape = (image.rows(), image.cols(), Generic2::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T> From<Image<T, Generic5>> for Image<T, Generic1>
+impl<T, U> From<Image<U, Generic5>> for Image<U, Generic1>
 where
+    U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<T, Generic5>) -> Self {
+    fn from(image: Image<U, Generic5>) -> Self {
         let shape = (image.rows(), image.cols(), Generic1::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T> From<Image<T, Generic4>> for Image<T, Generic3>
+impl<T, U> From<Image<U, Generic4>> for Image<U, Generic3>
 where
+    U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<T, Generic4>) -> Self {
+    fn from(image: Image<U, Generic4>) -> Self {
         let shape = (image.rows(), image.cols(), Generic3::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T> From<Image<T, Generic4>> for Image<T, Generic2>
+impl<T, U> From<Image<U, Generic4>> for Image<U, Generic2>
 where
+    U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<T, Generic4>) -> Self {
+    fn from(image: Image<U, Generic4>) -> Self {
         let shape = (image.rows(), image.cols(), Generic2::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T> From<Image<T, Generic4>> for Image<T, Generic1>
+impl<T, U> From<Image<U, Generic4>> for Image<OwnedRepr<T>, Generic1>
 where
+    U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<T, Generic4>) -> Self {
+    fn from(image: Image<U, Generic4>) -> Self {
         let shape = (image.rows(), image.cols(), Generic1::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, Generic2>
+impl<T, U> From<Image<U, Generic3>> for Image<OwnedRepr<T>, Generic2>
 where
+    U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<T, Generic3>) -> Self {
+    fn from(image: Image<U, Generic3>) -> Self {
         let shape = (image.rows(), image.cols(), Generic2::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, Generic1>
+impl<T, U> From<Image<U, Generic3>> for Image<OwnedRepr<T>, Generic1>
 where
+    U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<T, Generic3>) -> Self {
+    fn from(image: Image<U, Generic3>) -> Self {
         let shape = (image.rows(), image.cols(), Generic1::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T> From<Image<T, Generic2>> for Image<T, Generic1>
+impl<T, U> From<Image<U, Generic2>> for Image<OwnedRepr<T>, Generic1>
 where
+    U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<T, Generic2>) -> Self {
+    fn from(image: Image<U, Generic2>) -> Self {
         let shape = (image.rows(), image.cols(), Generic1::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T> From<Image<T, Generic1>> for Image<T, Generic5>
+impl<T, U> From<Image<U, Generic1>> for Image<OwnedRepr<T>, Generic5>
 where
+    U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<T, Generic1>) -> Self {
+    fn from(image: Image<U, Generic1>) -> Self {
         let shape = (image.rows(), image.cols(), Generic5::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic1::channels()])
@@ -613,11 +690,12 @@ where
     }
 }
 
-impl<T> From<Image<T, Generic2>> for Image<T, Generic5>
+impl<T, U> From<Image<U, Generic2>> for Image<OwnedRepr<T>, Generic5>
 where
+    U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<T, Generic2>) -> Self {
+    fn from(image: Image<U, Generic2>) -> Self {
         let shape = (image.rows(), image.cols(), Generic5::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic2::channels()])
@@ -626,11 +704,12 @@ where
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, Generic5>
+impl<T, U> From<Image<U, Generic3>> for Image<U, Generic5>
 where
+    U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<T, Generic3>) -> Self {
+    fn from(image: Image<U, Generic3>) -> Self {
         let shape = (image.rows(), image.cols(), Generic5::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic3::channels()])
@@ -639,11 +718,12 @@ where
     }
 }
 
-impl<T> From<Image<T, Generic4>> for Image<T, Generic5>
+impl<T, U> From<Image<U, Generic4>> for Image<U, Generic5>
 where
+    U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<T, Generic4>) -> Self {
+    fn from(image: Image<U, Generic4>) -> Self {
         let shape = (image.rows(), image.cols(), Generic5::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic4::channels()])
@@ -652,11 +732,12 @@ where
     }
 }
 
-impl<T> From<Image<T, Generic1>> for Image<T, Generic4>
+impl<T, U> From<Image<U, Generic1>> for Image<U, Generic4>
 where
+    U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<T, Generic1>) -> Self {
+    fn from(image: Image<U, Generic1>) -> Self {
         let shape = (image.rows(), image.cols(), Generic4::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic1::channels()])
@@ -665,11 +746,12 @@ where
     }
 }
 
-impl<T> From<Image<T, Generic2>> for Image<T, Generic4>
+impl<T, U> From<Image<U, Generic2>> for Image<U, Generic4>
 where
+    U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<T, Generic2>) -> Self {
+    fn from(image: Image<U, Generic2>) -> Self {
         let shape = (image.rows(), image.cols(), Generic4::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic2::channels()])
@@ -678,11 +760,12 @@ where
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, Generic4>
+impl<T, U> From<Image<U, Generic3>> for Image<U, Generic4>
 where
+    U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<T, Generic3>) -> Self {
+    fn from(image: Image<U, Generic3>) -> Self {
         let shape = (image.rows(), image.cols(), Generic4::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic3::channels()])
@@ -691,11 +774,12 @@ where
     }
 }
 
-impl<T> From<Image<T, Generic1>> for Image<T, Generic3>
+impl<T, U> From<Image<U, Generic1>> for Image<U, Generic3>
 where
+    U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<T, Generic1>) -> Self {
+    fn from(image: Image<U, Generic1>) -> Self {
         let shape = (image.rows(), image.cols(), Generic3::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic1::channels()])
@@ -704,11 +788,12 @@ where
     }
 }
 
-impl<T> From<Image<T, Generic2>> for Image<T, Generic3>
+impl<T, U> From<Image<U, Generic2>> for Image<U, Generic3>
 where
+    U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<T, Generic2>) -> Self {
+    fn from(image: Image<U, Generic2>) -> Self {
         let shape = (image.rows(), image.cols(), Generic3::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic2::channels()])
@@ -717,11 +802,12 @@ where
     }
 }
 
-impl<T> From<Image<T, Generic1>> for Image<T, Generic2>
+impl<T, U> From<Image<U, Generic1>> for Image<U, Generic2>
 where
+    U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<T, Generic1>) -> Self {
+    fn from(image: Image<U, Generic1>) -> Self {
         let shape = (image.rows(), image.cols(), Generic2::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic1::channels()])
diff --git a/src/core/image.rs b/src/core/image.rs
index c01f75d..84f6081 100644
--- a/src/core/image.rs
+++ b/src/core/image.rs
@@ -1,7 +1,7 @@
 use crate::core::colour_models::*;
 use crate::core::traits::PixelBound;
 use ndarray::prelude::*;
-use ndarray::s;
+use ndarray::{s, Data};
 use num_traits::cast::{FromPrimitive, NumCast};
 use num_traits::Num;
 use std::marker::PhantomData;
@@ -11,6 +11,7 @@ use std::marker::PhantomData;
 pub struct Image<T, C>
 where
     C: ColourModel,
+    T: Data,
 {
     /// Images are always going to be 3D to handle rows, columns and colour
     /// channels
@@ -20,19 +21,21 @@ where
     /// number of channels in an image as this may cause other functionality to
     /// perform incorrectly. Use conversions to one of the `Generic` colour models
     /// instead.
-    pub data: Array3<T>,
+    pub data: ArrayBase<T, Ix3>,
     /// Representation of how colour is encoded in the image
     pub(crate) model: PhantomData<C>,
 }
 
-impl<T, C> Image<T, C>
+impl<T, U, C> Image<U, C>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + FromPrimitive + Num + NumCast + PixelBound,
     C: ColourModel,
 {
     /// Converts image into a different type - doesn't scale to new pixel bounds
-    pub fn into_type<T2>(self) -> Image<T2, C>
+    pub fn into_type<T2, U2>(self) -> Image<U2, C>
     where
+        U2: Data<Elem = T2>,
         T2: Copy + Clone + FromPrimitive + Num + NumCast + PixelBound,
     {
         let rescale = |x: &T| {
@@ -43,12 +46,13 @@ where
             T2::from_f64(scaled).unwrap_or_else(T2::zero) + T2::min_pixel()
         };
         let data = self.data.map(rescale);
-        Image::<T2, C>::from_data(data)
+        Image::<U2, C>::from_data(data)
     }
 }
 
-impl<T, C> Image<T, C>
+impl<T, C, U> Image<U, C>
 where
+    U: Data<Elem = T>,
     T: Clone + Num,
     C: ColourModel,
 {
@@ -73,10 +77,22 @@ where
             model: PhantomData,
         }
     }
+
+    /// Create an image given an existing ndarray
+    pub fn from_array<V>(data: ArrayBase<V, Ix3>) -> Self
+    where
+        V: Data<Elem = T>,
+    {
+        Image {
+            data,
+            model: PhantomData,
+        }
+    }
 }
 
 impl<T, C> Image<T, C>
 where
+    T: Data,
     C: ColourModel,
 {
     /// Construct the image from a given Array3
diff --git a/src/core/padding.rs b/src/core/padding.rs
index f9a8e40..257a5f8 100644
--- a/src/core/padding.rs
+++ b/src/core/padding.rs
@@ -1,5 +1,5 @@
 use crate::core::{ColourModel, Image};
-use ndarray::{prelude::*, s};
+use ndarray::{prelude::*, s, Data};
 use num_traits::identities::Zero;
 use std::marker::PhantomData;
 
@@ -80,8 +80,9 @@ pub trait PaddingExt {
     fn pad(&self, padding: (usize, usize), strategy: &dyn PaddingStrategy<Self::Data>) -> Self;
 }
 
-impl<T> PaddingExt for Array3<T>
+impl<T, U> PaddingExt for ArrayBase<U, Ix3>
 where
+    U: Data<Elem = T>,
     T: Copy,
 {
     type Data = T;
@@ -91,8 +92,9 @@ where
     }
 }
 
-impl<T, C> PaddingExt for Image<T, C>
+impl<T, U, C> PaddingExt for Image<U, C>
 where
+    U: Data<Elem = T>,
     T: Copy,
     C: ColourModel,
 {
diff --git a/src/enhancement/histogram_equalisation.rs b/src/enhancement/histogram_equalisation.rs
index e2e172a..fe2d4e8 100644
--- a/src/enhancement/histogram_equalisation.rs
+++ b/src/enhancement/histogram_equalisation.rs
@@ -1,5 +1,5 @@
 use crate::core::*;
-use ndarray::prelude::*;
+use ndarray::{prelude::*, Data};
 use ndarray_stats::{histogram::Grid, HistogramExt};
 use num_traits::cast::{FromPrimitive, ToPrimitive};
 use num_traits::{Num, NumAssignOps};
@@ -19,8 +19,9 @@ where
     fn equalise_hist_inplace(&mut self, grid: Grid<A>);
 }
 
-impl<T> HistogramEqExt<T> for Array3<T>
+impl<T, U> HistogramEqExt<T> for ArrayBase<U, Ix3>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive + PixelBound,
 {
     fn equalise_hist(&self, grid: Grid<T>) -> Self {
@@ -71,9 +72,10 @@ where
     }
 }
 
-impl<T, C> HistogramEqExt<T> for Image<T, C>
+impl<T, U, C> HistogramEqExt<T> for Image<U, C>
 where
-    Image<T, C>: Clone,
+    U: Data<Elem = T>,
+    Image<U, C>: Clone,
     T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive + PixelBound,
     C: ColourModel,
 {
diff --git a/src/format/mod.rs b/src/format/mod.rs
index 55a1dd3..d5dd1fc 100644
--- a/src/format/mod.rs
+++ b/src/format/mod.rs
@@ -1,5 +1,6 @@
 use crate::core::traits::PixelBound;
 use crate::core::*;
+use ndarray::Data;
 use num_traits::cast::{FromPrimitive, NumCast};
 use num_traits::{Num, NumAssignOps};
 use std::fmt::Display;
@@ -8,17 +9,18 @@ use std::io::prelude::*;
 use std::path::Path;
 
 /// Trait for an image encoder
-pub trait Encoder<T, C>
+pub trait Encoder<T, U, C>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps + NumCast + PartialOrd + Display + PixelBound,
     C: ColourModel,
 {
     /// Encode an image into a sequence of bytes for the given format
-    fn encode(&self, image: &Image<T, C>) -> Vec<u8>;
+    fn encode(&self, image: &Image<U, C>) -> Vec<u8>;
 
     /// Encode an image saving it to the file at filename. This function shouldn't
     /// add an extension preferring the user to do that instead.
-    fn encode_file<P: AsRef<Path>>(&self, image: &Image<T, C>, filename: P) -> std::io::Result<()> {
+    fn encode_file<P: AsRef<Path>>(&self, image: &Image<U, C>, filename: P) -> std::io::Result<()> {
         let mut file = File::create(filename)?;
         file.write_all(&self.encode(image))?;
         Ok(())
@@ -26,8 +28,9 @@ where
 }
 
 /// Trait for an image decoder, use this to get an image from a byte stream
-pub trait Decoder<T, C>
+pub trait Decoder<T, U, C>
 where
+    U: Data<Elem = T>,
     T: Copy
         + Clone
         + FromPrimitive
@@ -41,9 +44,9 @@ where
 {
     /// From the bytes decode an image, will perform any scaling or conversions
     /// required to represent elements with type T.
-    fn decode(&self, bytes: &[u8]) -> std::io::Result<Image<T, C>>;
+    fn decode(&self, bytes: &[u8]) -> std::io::Result<Image<U, C>>;
     /// Given a filename decode an image performing any necessary conversions.
-    fn decode_file<P: AsRef<Path>>(&self, filename: P) -> std::io::Result<Image<T, C>> {
+    fn decode_file<P: AsRef<Path>>(&self, filename: P) -> std::io::Result<Image<U, C>> {
         let bytes = read(filename)?;
         self.decode(&bytes)
     }
diff --git a/src/format/netpbm.rs b/src/format/netpbm.rs
index 3f540af..4672e3b 100644
--- a/src/format/netpbm.rs
+++ b/src/format/netpbm.rs
@@ -1,5 +1,6 @@
 use crate::core::{normalise_pixel_value, Image, PixelBound, RGB};
 use crate::format::{Decoder, Encoder};
+use ndarray::Data;
 use num_traits::cast::{FromPrimitive, NumCast};
 use num_traits::{Num, NumAssignOps};
 use std::fmt::Display;
@@ -32,8 +33,9 @@ impl Default for PpmEncoder {
 /// The ColourModel type argument is locked to RGB - this prevents calling
 /// RGB::into::<RGB>() unnecessarily which is unavoidable until trait specialisation is
 /// stabilised.
-impl<T> Encoder<T, RGB> for PpmEncoder
+impl<T, U> Encoder<T, U, RGB> for PpmEncoder
 where
+    U: Data<Elem = T>,
     T: Copy
         + Clone
         + Num
@@ -44,7 +46,7 @@ where
         + PixelBound
         + FromPrimitive,
 {
-    fn encode(&self, image: &Image<T, RGB>) -> Vec<u8> {
+    fn encode(&self, image: &Image<U, RGB>) -> Vec<u8> {
         use EncodingType::*;
         match self.encoding {
             Plaintext => self.encode_plaintext(image),
@@ -71,8 +73,9 @@ impl PpmEncoder {
 
     /// Gets the maximum pixel value in the image across all channels. This is
     /// used in the PPM header
-    fn get_max_value<T>(image: &Image<T, RGB>) -> Option<u8>
+    fn get_max_value<T, U>(image: &Image<U, RGB>) -> Option<u8>
     where
+        U: Data<Elem = T>,
         T: Copy + Clone + Num + NumAssignOps + NumCast + PartialOrd + Display + PixelBound,
     {
         image
@@ -92,8 +95,9 @@ impl PpmEncoder {
     }
 
     /// Encode the image into the binary PPM format (P6) returning the bytes
-    fn encode_binary<T>(self, image: &Image<T, RGB>) -> Vec<u8>
+    fn encode_binary<T, U>(self, image: &Image<U, RGB>) -> Vec<u8>
     where
+        U: Data<Elem = T>,
         T: Copy + Clone + Num + NumAssignOps + NumCast + PartialOrd + Display + PixelBound,
     {
         let max_val = Self::get_max_value(image).unwrap_or_else(|| 255);
@@ -113,8 +117,9 @@ impl PpmEncoder {
 
     /// Encode the image into the plaintext PPM format (P3) returning the text as
     /// an array of bytes
-    fn encode_plaintext<T>(self, image: &Image<T, RGB>) -> Vec<u8>
+    fn encode_plaintext<T, U>(self, image: &Image<U, RGB>) -> Vec<u8>
     where
+        U: Data<Elem = T>,
         T: Copy + Clone + Num + NumAssignOps + NumCast + PartialOrd + Display + PixelBound,
     {
         let max_val = 255;
@@ -150,8 +155,9 @@ impl PpmEncoder {
 /// The ColourModel type argument is locked to RGB - this prevents calling
 /// RGB::into::<RGB>() unnecessarily which is unavoidable until trait specialisation is
 /// stabilised.
-impl<T> Decoder<T, RGB> for PpmDecoder
+impl<T, U> Decoder<T, U, RGB> for PpmDecoder
 where
+    U: Data<Elem = T>,
     T: Copy
         + Clone
         + Num
@@ -162,7 +168,7 @@ where
         + PixelBound
         + FromPrimitive,
 {
-    fn decode(&self, bytes: &[u8]) -> std::io::Result<Image<T, RGB>> {
+    fn decode(&self, bytes: &[u8]) -> std::io::Result<Image<U, RGB>> {
         if bytes.len() < 9 {
             Err(Error::new(
                 ErrorKind::InvalidData,
@@ -220,8 +226,9 @@ impl PpmDecoder {
         }
     }
 
-    fn decode_binary<T>(bytes: &[u8]) -> std::io::Result<Image<T, RGB>>
+    fn decode_binary<T, U>(bytes: &[u8]) -> std::io::Result<Image<U, RGB>>
     where
+        U: Data<Elem = T>,
         T: Copy
             + Clone
             + Num
@@ -273,8 +280,9 @@ impl PpmDecoder {
         }
     }
 
-    fn decode_plaintext<T>(bytes: &[u8]) -> std::io::Result<Image<T, RGB>>
+    fn decode_plaintext<T, U>(bytes: &[u8]) -> std::io::Result<Image<U, RGB>>
     where
+        U: Data<Elem = T>,
         T: Copy
             + Clone
             + Num
diff --git a/src/processing/canny.rs b/src/processing/canny.rs
index 8841a6d..61218c1 100644
--- a/src/processing/canny.rs
+++ b/src/processing/canny.rs
@@ -1,7 +1,7 @@
 use crate::core::{ColourModel, Image};
 use crate::processing::*;
 use ndarray::prelude::*;
-use ndarray::IntoDimension;
+use ndarray::{Data, IntoDimension, OwnedRepr};
 use num_traits::{cast::FromPrimitive, real::Real, Num, NumAssignOps};
 use std::collections::HashSet;
 use std::marker::PhantomData;
@@ -38,12 +38,13 @@ pub struct CannyParameters<T> {
     pub t2: T,
 }
 
-impl<T, C> CannyEdgeDetectorExt<T> for Image<T, C>
+impl<T, U, C> CannyEdgeDetectorExt<T> for Image<U, C>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + FromPrimitive + Real + Num + NumAssignOps,
     C: ColourModel,
 {
-    type Output = Image<bool, C>;
+    type Output = Image<OwnedRepr<bool>, C>;
 
     fn canny_edge_detector(&self, params: CannyParameters<T>) -> Result<Self::Output, Error> {
         let data = self.data.canny_edge_detector(params)?;
@@ -54,8 +55,9 @@ where
     }
 }
 
-impl<T> CannyEdgeDetectorExt<T> for Array3<T>
+impl<T, U> CannyEdgeDetectorExt<T> for ArrayBase<U, Ix3>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + FromPrimitive + Real + Num + NumAssignOps,
 {
     type Output = Array3<bool>;
diff --git a/src/processing/conv.rs b/src/processing/conv.rs
index 18cd90b..32a2a7e 100644
--- a/src/processing/conv.rs
+++ b/src/processing/conv.rs
@@ -2,7 +2,7 @@ use crate::core::padding::*;
 use crate::core::{ColourModel, Image};
 use crate::processing::Error;
 use ndarray::prelude::*;
-use ndarray::{s, Zip};
+use ndarray::{s, Data, OwnedRepr, Zip};
 use num_traits::{Num, NumAssignOps};
 use std::marker::PhantomData;
 use std::marker::Sized;
@@ -14,10 +14,12 @@ where
 {
     /// Underlying data type to perform the convolution on
     type Data;
+    /// Type for the output as data will have to be allocated
+    type Output;
 
     /// Perform a convolution returning the resultant data
     /// applies the default padding of zero padding
-    fn conv2d(&self, kernel: ArrayView3<Self::Data>) -> Result<Self, Error>;
+    fn conv2d(&self, kernel: ArrayView3<Self::Data>) -> Result<Self::Output, Error>;
     /// Performs the convolution inplace mutating the containers data
     /// applies the default padding of zero padding
     fn conv2d_inplace(&mut self, kernel: ArrayView3<Self::Data>) -> Result<(), Error>;
@@ -27,7 +29,7 @@ where
         &self,
         kernel: ArrayView3<Self::Data>,
         strategy: &dyn PaddingStrategy<Self::Data>,
-    ) -> Result<Self, Error>;
+    ) -> Result<Self::Output, Error>;
     /// Performs the convolution inplace mutating the containers data
     /// applies the default padding of zero padding
     fn conv2d_inplace_with_padding(
@@ -43,13 +45,15 @@ fn kernel_centre(rows: usize, cols: usize) -> (usize, usize) {
     (row_offset, col_offset)
 }
 
-impl<T> ConvolutionExt for Array3<T>
+impl<T, U> ConvolutionExt for ArrayBase<U, Ix3>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps,
 {
     type Data = T;
+    type Output = ArrayBase<OwnedRepr<T>, Ix3>;
 
-    fn conv2d(&self, kernel: ArrayView3<Self::Data>) -> Result<Self, Error> {
+    fn conv2d(&self, kernel: ArrayView3<Self::Data>) -> Result<Self::Output, Error> {
         self.conv2d_with_padding(kernel, &ZeroPadding {})
     }
 
@@ -62,7 +66,7 @@ where
         &self,
         kernel: ArrayView3<Self::Data>,
         strategy: &dyn PaddingStrategy<Self::Data>,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self::Output, Error> {
         if self.shape()[2] != kernel.shape()[2] {
             Err(Error::ChannelDimensionMismatch)
         } else {
@@ -73,7 +77,7 @@ where
             let shape = (self.shape()[0], self.shape()[1], self.shape()[2]);
 
             if shape.0 > 0 && shape.1 > 0 {
-                let mut result = Self::zeros(shape);
+                let mut result = Self::Output::zeros(shape);
                 let tmp = self.pad((row_offset, col_offset), strategy);
 
                 Zip::indexed(tmp.windows(kernel.dim())).apply(|(i, j, _), window| {
@@ -98,12 +102,15 @@ where
     }
 }
 
-impl<T, C> ConvolutionExt for Image<T, C>
+impl<T, U, C> ConvolutionExt for Image<U, C>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps,
     C: ColourModel,
 {
     type Data = T;
+    type Output = Image<OwnedRepr<T>, C>;
+
     fn conv2d(&self, kernel: ArrayView3<Self::Data>) -> Result<Self, Error> {
         let data = self.data.conv2d(kernel)?;
         Ok(Self {
@@ -120,7 +127,7 @@ where
         &self,
         kernel: ArrayView3<Self::Data>,
         strategy: &dyn PaddingStrategy<Self::Data>,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self::Output, Error> {
         let data = self.data.conv2d_with_padding(kernel, strategy)?;
         Ok(Self {
             data,
diff --git a/src/processing/filter.rs b/src/processing/filter.rs
index f0a3f40..ab78e90 100644
--- a/src/processing/filter.rs
+++ b/src/processing/filter.rs
@@ -1,6 +1,6 @@
 use crate::core::{ColourModel, Image};
 use ndarray::prelude::*;
-use ndarray::{IntoDimension, Zip};
+use ndarray::{Data, IntoDimension, OwnedRepr, Zip};
 use ndarray_stats::interpolate::*;
 use ndarray_stats::Quantile1dExt;
 use noisy_float::types::n64;
@@ -11,18 +11,22 @@ use std::marker::PhantomData;
 /// Median filter, given a region to move over the image, each pixel is given
 /// the median value of itself and it's neighbours
 pub trait MedianFilterExt {
+    type Output;
     /// Run the median filter given the region. Median is assumed to be calculated
     /// independently for each channel.
-    fn median_filter<E>(&self, region: E) -> Self
+    fn median_filter<E>(&self, region: E) -> Self::Output
     where
         E: IntoDimension<Dim = Ix2>;
 }
 
-impl<T> MedianFilterExt for Array3<T>
+impl<T, U> MedianFilterExt for ArrayBase<U, Ix3>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + FromPrimitive + ToPrimitive + Num + Ord,
 {
-    fn median_filter<E>(&self, region: E) -> Self
+    type Output = ArrayBase<OwnedRepr<T>, Ix3>;
+
+    fn median_filter<E>(&self, region: E) -> Self::Output
     where
         E: IntoDimension<Dim = Ix2>,
     {
@@ -43,12 +47,15 @@ where
     }
 }
 
-impl<T, C> MedianFilterExt for Image<T, C>
+impl<T, U, C> MedianFilterExt for Image<U, C>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + FromPrimitive + ToPrimitive + Num + Ord,
     C: ColourModel,
 {
-    fn median_filter<E>(&self, region: E) -> Self
+    type Output = Image<OwnedRepr<T>, C>;
+
+    fn median_filter<E>(&self, region: E) -> Self::Output
     where
         E: IntoDimension<Dim = Ix2>,
     {
diff --git a/src/processing/sobel.rs b/src/processing/sobel.rs
index a4d6ecf..7b82824 100644
--- a/src/processing/sobel.rs
+++ b/src/processing/sobel.rs
@@ -1,7 +1,7 @@
 use crate::core::*;
 use crate::processing::*;
 use core::ops::Neg;
-use ndarray::prelude::*;
+use ndarray::{prelude::*, Data, OwnedRepr};
 use num_traits::{cast::FromPrimitive, real::Real, Num, NumAssignOps};
 use std::marker::Sized;
 
@@ -13,15 +13,25 @@ where
     /// Type to output
     type Output;
     /// Returns the magnitude output of the sobel - an image of only lines
-    fn apply_sobel(&self) -> Result<Self, Error>;
+    fn apply_sobel(&self) -> Result<Self::Output, Error>;
+}
 
+pub trait FullSobelExt
+where
+    Self: Sized,
+{
+    /// Type to output
+    type Output;
     /// Returns the magntitude and rotation outputs for use in other algorithms
     /// like the Canny edge detector. Rotation is in radians
     fn full_sobel(&self) -> Result<(Self::Output, Self::Output), Error>;
 }
 
-fn get_edge_images<T>(mat: &Array3<T>) -> Result<(Array3<T>, Array3<T>), Error>
+fn get_edge_images<T, U>(
+    mat: &ArrayBase<U, Ix3>,
+) -> Result<(ArrayBase<OwnedRepr<T>, Ix3>, ArrayBase<OwnedRepr<T>, Ix3>), Error>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps + Neg<Output = T> + FromPrimitive + Real,
 {
     let v_temp: Array3<T> = SobelFilter::build_with_params(Orientation::Vertical).unwrap();
@@ -40,9 +50,9 @@ impl<T> SobelExt for Array3<T>
 where
     T: Copy + Clone + Num + NumAssignOps + Neg<Output = T> + FromPrimitive + Real,
 {
-    type Output = Self;
+    type Output = ArrayBase<OwnedRepr<T>, Ix3>;
 
-    fn apply_sobel(&self) -> Result<Self, Error> {
+    fn apply_sobel(&self) -> Result<Self::Output, Error> {
         let (h_deriv, v_deriv) = get_edge_images(self)?;
 
         let h_deriv = h_deriv.mapv(|x| x.powi(2));
@@ -56,7 +66,12 @@ where
 
         Ok(result)
     }
+}
 
+impl<T> FullSobelExt for Array3<T>
+where
+    T: Copy + Clone + Num + NumAssignOps + Neg<Output = T> + FromPrimitive + Real,
+{
     fn full_sobel(&self) -> Result<(Self::Output, Self::Output), Error> {
         let (h_deriv, v_deriv) = get_edge_images(self)?;
 
@@ -71,17 +86,27 @@ where
     }
 }
 
-impl<T, C> SobelExt for Image<T, C>
+impl<T, U, C> SobelExt for Image<U, C>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps + Neg<Output = T> + FromPrimitive + Real,
     C: ColourModel,
 {
-    type Output = Array3<T>;
+    type Output = Image<OwnedRepr<T>, C>;
 
     fn apply_sobel(&self) -> Result<Self, Error> {
         let data = self.data.apply_sobel()?;
         Ok(Image::from_data(data))
     }
+}
+
+impl<T, U, C> FullSobelExt for Image<U, C>
+where
+    U: Data<Elem = T>,
+    T: Copy + Clone + Num + NumAssignOps + Neg<Output = T> + FromPrimitive + Real,
+    C: ColourModel,
+{
+    type Output = ArrayBase<OwnedRepr<T>, Ix3>;
 
     fn full_sobel(&self) -> Result<(Self::Output, Self::Output), Error> {
         self.data.full_sobel()
diff --git a/src/processing/threshold.rs b/src/processing/threshold.rs
index 49304f0..d92b88d 100644
--- a/src/processing/threshold.rs
+++ b/src/processing/threshold.rs
@@ -1,7 +1,7 @@
 use crate::core::PixelBound;
 use crate::core::{ColourModel, Image};
 use crate::processing::*;
-use ndarray::prelude::*;
+use ndarray::{prelude::*, Data, OwnedRepr};
 use ndarray_stats::histogram::{Bins, Edges, Grid};
 use ndarray_stats::HistogramExt;
 use ndarray_stats::QuantileExt;
@@ -41,13 +41,14 @@ pub trait ThresholdMeanExt<T> {
     fn threshold_mean(&self) -> Result<Self::Output, Error>;
 }
 
-impl<T, C> ThresholdOtsuExt<T> for Image<T, C>
+impl<T, U, C> ThresholdOtsuExt<T> for Image<U, C>
 where
-    Image<T, C>: Clone,
+    U: Data<Elem = T>,
+    Image<U, C>: Clone,
     T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive + PixelBound,
     C: ColourModel,
 {
-    type Output = Image<bool, C>;
+    type Output = Image<OwnedRepr<bool>, C>;
 
     fn threshold_otsu(&self) -> Result<Self::Output, Error> {
         let data = self.data.threshold_otsu()?;
@@ -58,8 +59,9 @@ where
     }
 }
 
-impl<T> ThresholdOtsuExt<T> for Array3<T>
+impl<T, U> ThresholdOtsuExt<T> for ArrayBase<U, Ix3>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive,
 {
     type Output = Array3<bool>;
@@ -68,7 +70,7 @@ where
         if self.shape()[2] > 1 {
             Err(Error::ChannelDimensionMismatch)
         } else {
-            let value = calculate_threshold_otsu(&self)?;
+            let value = calculate_threshold_otsu(self)?;
             let mask = apply_threshold(self, value);
             Ok(mask)
         }
@@ -82,8 +84,9 @@ where
 /// i.e. single channel; otherwise we need to output all 3 threshold values).
 /// Todo: Add optional nbins
 ///
-fn calculate_threshold_otsu<T>(mat: &Array3<T>) -> Result<f64, Error>
+fn calculate_threshold_otsu<T, U>(mat: &ArrayBase<U, Ix3>) -> Result<f64, Error>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive,
 {
     let mut threshold = 0.0;
@@ -132,13 +135,14 @@ where
     Ok(threshold)
 }
 
-impl<T, C> ThresholdMeanExt<T> for Image<T, C>
+impl<T, U, C> ThresholdMeanExt<T> for Image<U, C>
 where
-    Image<T, C>: Clone,
+    U: Data<Elem = T>,
+    Image<U, C>: Clone,
     T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive + PixelBound,
     C: ColourModel,
 {
-    type Output = Image<bool, C>;
+    type Output = Image<OwnedRepr<bool>, C>;
 
     fn threshold_mean(&self) -> Result<Self::Output, Error> {
         let data = self.data.threshold_mean()?;
@@ -149,8 +153,9 @@ where
     }
 }
 
-impl<T> ThresholdMeanExt<T> for Array3<T>
+impl<T, U> ThresholdMeanExt<T> for ArrayBase<U, Ix3>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive,
 {
     type Output = Array3<bool>;
@@ -159,22 +164,24 @@ where
         if self.shape()[2] > 1 {
             Err(Error::ChannelDimensionMismatch)
         } else {
-            let value = calculate_threshold_mean(&self)?;
+            let value = calculate_threshold_mean(self)?;
             let mask = apply_threshold(self, value);
             Ok(mask)
         }
     }
 }
 
-fn calculate_threshold_mean<T>(array: &Array3<T>) -> Result<f64, Error>
+fn calculate_threshold_mean<T, U>(array: &ArrayBase<U, Ix3>) -> Result<f64, Error>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps + ToPrimitive + FromPrimitive,
 {
     Ok(array.sum().to_f64().unwrap() / array.len() as f64)
 }
 
-fn apply_threshold<T>(data: &Array3<T>, threshold: f64) -> Array3<bool>
+fn apply_threshold<T, U>(data: &ArrayBase<U, Ix3>, threshold: f64) -> Array3<bool>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps + ToPrimitive + FromPrimitive,
 {
     let result = data.mapv(|x| x.to_f64().unwrap() >= threshold);
diff --git a/src/transform/mod.rs b/src/transform/mod.rs
index 9db811c..a5ac068 100644
--- a/src/transform/mod.rs
+++ b/src/transform/mod.rs
@@ -1,6 +1,6 @@
 use crate::core::{ColourModel, Image};
 use crate::transform::affine::translation;
-use ndarray::{array, prelude::*, s, Data};
+use ndarray::{array, prelude::*, s, Data, OwnedRepr};
 use ndarray_linalg::solve::Inverse;
 use num_traits::{Num, NumAssignOps};
 use std::cmp::{max, min};
@@ -88,7 +88,7 @@ where
     T: Copy + Clone + Num + NumAssignOps,
     U: Data<Elem = T>,
 {
-    type Output = Array3<T>;
+    type Output = ArrayBase<OwnedRepr<T>, Ix3>;
 
     fn transform(
         &self,
@@ -139,12 +139,13 @@ where
     }
 }
 
-impl<T, C> TransformExt for Image<T, C>
+impl<T, U, C> TransformExt for Image<U, C>
 where
+    U: Data<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps,
     C: ColourModel,
 {
-    type Output = Self;
+    type Output = Image<OwnedRepr<T>, C>;
 
     fn transform(
         &self,
@@ -152,10 +153,7 @@ where
         output_size: Option<(usize, usize)>,
     ) -> Result<Self::Output, Error> {
         let data = self.data.transform(transform, output_size)?;
-        Ok(Self {
-            data,
-            model: PhantomData,
-        })
+        Ok(Self::from_array(data))
     }
 }
 

From 0a92f707ebc58b1f145cdf4aa33c3f196a1ba5bf Mon Sep 17 00:00:00 2001
From: xd009642 <danielmckenna93@gmail.com>
Date: Tue, 26 Nov 2019 23:59:17 +0000
Subject: [PATCH 2/9] More progress fixing type errors

---
 src/core/colour_models.rs                 | 56 +++++++++++------------
 src/core/image.rs                         | 15 ++++--
 src/enhancement/histogram_equalisation.rs |  4 +-
 src/processing/conv.rs                    |  2 +-
 src/processing/sobel.rs                   |  8 +++-
 src/transform/mod.rs                      |  1 -
 6 files changed, 49 insertions(+), 37 deletions(-)

diff --git a/src/core/colour_models.rs b/src/core/colour_models.rs
index 5260e51..13fe75d 100644
--- a/src/core/colour_models.rs
+++ b/src/core/colour_models.rs
@@ -182,7 +182,7 @@ where
     (red, green, blue)
 }
 
-impl<U, T> From<Image<U, RGB>> for Image<U, HSV>
+impl<U, T> From<Image<U, RGB>> for Image<OwnedRepr<T>, HSV>
 where
     U: Data<Elem = T>,
     T: Copy
@@ -196,7 +196,7 @@ where
         + PixelBound,
 {
     fn from(image: Image<U, RGB>) -> Self {
-        let mut res = Array3::<T>::zeros((image.rows(), image.cols(), HSV::channels()));
+        let mut res = Array3::<_>::zeros((image.rows(), image.cols(), HSV::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
         Zip::indexed(window).apply(|(i, j, _), pix| {
@@ -211,7 +211,7 @@ where
     }
 }
 
-impl<T, U> From<Image<U, HSV>> for Image<U, RGB>
+impl<T, U> From<Image<U, HSV>> for Image<OwnedRepr<T>, RGB>
 where
     U: Data<Elem = T>,
     T: Copy
@@ -240,7 +240,7 @@ where
     }
 }
 
-impl<T, U> From<Image<U, RGB>> for Image<U, Gray>
+impl<T, U> From<Image<U, RGB>> for Image<OwnedRepr<T>, Gray>
 where
     U: Data<Elem = T>,
     T: Copy
@@ -271,7 +271,7 @@ where
     }
 }
 
-impl<T, U> From<Image<U, Gray>> for Image<U, RGB>
+impl<T, U> From<Image<U, Gray>> for Image<OwnedRepr<T>, RGB>
 where
     U: Data<Elem = T>,
     T: Copy
@@ -298,7 +298,7 @@ where
     }
 }
 
-impl<T, U> From<Image<U, RGB>> for Image<U, CIEXYZ>
+impl<T, U> From<Image<U, RGB>> for Image<OwnedRepr<T>, CIEXYZ>
 where
     U: Data<Elem = T>,
     T: Copy
@@ -337,7 +337,7 @@ where
     }
 }
 
-impl<T, U> From<Image<U, CIEXYZ>> for Image<U, RGB>
+impl<T, U> From<Image<U, CIEXYZ>> for Image<OwnedRepr<T>, RGB>
 where
     U: Data<Elem = T>,
     T: Copy
@@ -376,27 +376,27 @@ where
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, RGB>
+impl<S, T> From<Image<T, Generic3>> for Image<OwnedRepr<S>, RGB>
 where
-    T: Data,
+    T: Data<Elem = S>,
 {
     fn from(image: Image<T, Generic3>) -> Self {
-        Self::from_data(image.data)
+        image.into_type_raw()
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, HSV>
+impl<S, T> From<Image<T, Generic3>> for Image<T, HSV>
 where
-    T: Data,
+    T: Data<Elem = S>,
 {
     fn from(image: Image<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, HSI>
+impl<S, T> From<Image<T, Generic3>> for Image<OwnedRepr<S>, HSI>
 where
-    T: Data,
+    T: Data<Elem = S>,
 {
     fn from(image: Image<T, Generic3>) -> Self {
         Self::from_data(image.data)
@@ -475,63 +475,63 @@ where
     }
 }
 
-impl<T> From<Image<T, HSV>> for Image<T, Generic3>
+impl<S, T> From<Image<T, HSV>> for Image<OwnedRepr<S>, Generic3>
 where
-    T: Data,
+    T: Data<Elem = S>,
 {
     fn from(image: Image<T, HSV>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, HSI>> for Image<T, Generic3>
+impl<S, T> From<Image<T, HSI>> for Image<OwnedRepr<S>, Generic3>
 where
-    T: Data,
+    T: Data<Elem = S>,
 {
     fn from(image: Image<T, HSI>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, HSL>> for Image<T, Generic3>
+impl<S, T> From<Image<T, HSL>> for Image<OwnedRepr<S>, Generic3>
 where
-    T: Data,
+    T: Data<Elem = S>,
 {
     fn from(image: Image<T, HSL>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, YCrCb>> for Image<T, Generic3>
+impl<S, T> From<Image<T, YCrCb>> for Image<OwnedRepr<S>, Generic3>
 where
-    T: Data,
+    T: Data<Elem = S>,
 {
     fn from(image: Image<T, YCrCb>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, CIEXYZ>> for Image<T, Generic3>
+impl<S, T> From<Image<T, CIEXYZ>> for Image<OwnedRepr<S>, Generic3>
 where
-    T: Data,
+    T: Data<Elem = S>,
 {
     fn from(image: Image<T, CIEXYZ>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, CIELAB>> for Image<T, Generic3>
+impl<S, T> From<Image<T, CIELAB>> for Image<OwnedRepr<S>, Generic3>
 where
-    T: Data,
+    T: Data<Elem = S>,
 {
     fn from(image: Image<T, CIELAB>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, CIELUV>> for Image<T, Generic3>
+impl<S, T> From<Image<T, CIELUV>> for Image<OwnedRepr<S>, Generic3>
 where
-    T: Data,
+    T: Data<Elem = S>,
 {
     fn from(image: Image<T, CIELUV>) -> Self {
         Self::from_data(image.data)
diff --git a/src/core/image.rs b/src/core/image.rs
index 84f6081..1cb6734 100644
--- a/src/core/image.rs
+++ b/src/core/image.rs
@@ -90,13 +90,13 @@ where
     }
 }
 
-impl<T, C> Image<T, C>
+impl<T, U, C> Image<T, C>
 where
-    T: Data,
+    T: Data<Elem = U>,
     C: ColourModel,
 {
     /// Construct the image from a given Array3
-    pub fn from_data(data: Array3<T>) -> Self {
+    pub fn from_data(data: ArrayBase<T, Ix3>) -> Self {
         Image {
             data,
             model: PhantomData,
@@ -125,6 +125,15 @@ where
     pub fn pixel_mut(&mut self, row: usize, col: usize) -> ArrayViewMut<T, Ix1> {
         self.data.slice_mut(s![row, col, ..])
     }
+
+    pub fn into_type_raw<U2, C2>(self) -> Image<U2, C>
+    where
+        U2: Data<Elem = U>,
+        C2: ColourModel,
+    {
+        assert_eq!(C2::channels(), C::channels());
+        Image::<U2, C2>::from_data(self.data)
+    }
 }
 
 /// Returns a normalised pixel value or 0 if it can't convert the types.
diff --git a/src/enhancement/histogram_equalisation.rs b/src/enhancement/histogram_equalisation.rs
index fe2d4e8..6e97e78 100644
--- a/src/enhancement/histogram_equalisation.rs
+++ b/src/enhancement/histogram_equalisation.rs
@@ -1,5 +1,5 @@
 use crate::core::*;
-use ndarray::{prelude::*, Data};
+use ndarray::{prelude::*, Data, DataMut};
 use ndarray_stats::{histogram::Grid, HistogramExt};
 use num_traits::cast::{FromPrimitive, ToPrimitive};
 use num_traits::{Num, NumAssignOps};
@@ -21,7 +21,7 @@ where
 
 impl<T, U> HistogramEqExt<T> for ArrayBase<U, Ix3>
 where
-    U: Data<Elem = T>,
+    U: Data<Elem = T> + DataMut<Elem = T>,
     T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive + PixelBound,
 {
     fn equalise_hist(&self, grid: Grid<T>) -> Self {
diff --git a/src/processing/conv.rs b/src/processing/conv.rs
index 32a2a7e..9a4e0ff 100644
--- a/src/processing/conv.rs
+++ b/src/processing/conv.rs
@@ -111,7 +111,7 @@ where
     type Data = T;
     type Output = Image<OwnedRepr<T>, C>;
 
-    fn conv2d(&self, kernel: ArrayView3<Self::Data>) -> Result<Self, Error> {
+    fn conv2d(&self, kernel: ArrayView3<Self::Data>) -> Result<Self::Output, Error> {
         let data = self.data.conv2d(kernel)?;
         Ok(Self {
             data,
diff --git a/src/processing/sobel.rs b/src/processing/sobel.rs
index 7b82824..47d61ef 100644
--- a/src/processing/sobel.rs
+++ b/src/processing/sobel.rs
@@ -46,8 +46,9 @@ where
     Ok((h_deriv, v_deriv))
 }
 
-impl<T> SobelExt for Array3<T>
+impl<T, U> SobelExt for ArrayBase<U, Ix3>
 where
+    U: Data<Elem=T>,
     T: Copy + Clone + Num + NumAssignOps + Neg<Output = T> + FromPrimitive + Real,
 {
     type Output = ArrayBase<OwnedRepr<T>, Ix3>;
@@ -68,10 +69,13 @@ where
     }
 }
 
-impl<T> FullSobelExt for Array3<T>
+impl<T, U> FullSobelExt for ArrayBase<U, Ix3>
 where
+    U: Data<Elem=T>,
     T: Copy + Clone + Num + NumAssignOps + Neg<Output = T> + FromPrimitive + Real,
 {
+    type Output = ArrayBase<OwnedRepr<T>, Ix3>;
+
     fn full_sobel(&self) -> Result<(Self::Output, Self::Output), Error> {
         let (h_deriv, v_deriv) = get_edge_images(self)?;
 
diff --git a/src/transform/mod.rs b/src/transform/mod.rs
index a5ac068..ac0bb48 100644
--- a/src/transform/mod.rs
+++ b/src/transform/mod.rs
@@ -4,7 +4,6 @@ use ndarray::{array, prelude::*, s, Data, OwnedRepr};
 use ndarray_linalg::solve::Inverse;
 use num_traits::{Num, NumAssignOps};
 use std::cmp::{max, min};
-use std::marker::PhantomData;
 
 pub mod affine;
 

From 46a5188a26427d2767d04f846ee5f8ac4c8f32d9 Mon Sep 17 00:00:00 2001
From: xd009642 <danielmckenna93@gmail.com>
Date: Sat, 30 Nov 2019 00:14:37 +0000
Subject: [PATCH 3/9] Move to ImageBase, Image, ImageView

Look familiar? Found it was the most ergonomic way to handle all these types
---
 src/core/colour_models.rs | 208 +++++++++++++++++++-------------------
 src/core/image.rs         |  62 +++++++-----
 src/core/padding.rs       |  50 +++++----
 3 files changed, 172 insertions(+), 148 deletions(-)

diff --git a/src/core/colour_models.rs b/src/core/colour_models.rs
index 13fe75d..13c33b5 100644
--- a/src/core/colour_models.rs
+++ b/src/core/colour_models.rs
@@ -1,6 +1,6 @@
 use crate::core::traits::*;
-use crate::core::{normalise_pixel_value, Image};
-use ndarray::{prelude::*, s, Data, OwnedRepr, Zip};
+use crate::core::*;
+use ndarray::{prelude::*, s, Data, Zip};
 use num_traits::cast::{FromPrimitive, NumCast};
 use num_traits::{Num, NumAssignOps};
 use std::convert::From;
@@ -182,7 +182,7 @@ where
     (red, green, blue)
 }
 
-impl<U, T> From<Image<U, RGB>> for Image<OwnedRepr<T>, HSV>
+impl<U, T> From<ImageBase<U, RGB>> for Image<T, HSV>
 where
     U: Data<Elem = T>,
     T: Copy
@@ -195,7 +195,7 @@ where
         + Display
         + PixelBound,
 {
-    fn from(image: Image<U, RGB>) -> Self {
+    fn from(image: ImageBase<U, RGB>) -> Self {
         let mut res = Array3::<_>::zeros((image.rows(), image.cols(), HSV::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
@@ -211,7 +211,7 @@ where
     }
 }
 
-impl<T, U> From<Image<U, HSV>> for Image<OwnedRepr<T>, RGB>
+impl<T, U> From<ImageBase<U, HSV>> for Image<T, RGB>
 where
     U: Data<Elem = T>,
     T: Copy
@@ -224,7 +224,7 @@ where
         + Display
         + PixelBound,
 {
-    fn from(image: Image<U, HSV>) -> Self {
+    fn from(image: ImageBase<U, HSV>) -> Self {
         let mut res = Array3::<T>::zeros((image.rows(), image.cols(), RGB::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
@@ -240,7 +240,7 @@ where
     }
 }
 
-impl<T, U> From<Image<U, RGB>> for Image<OwnedRepr<T>, Gray>
+impl<T, U> From<ImageBase<U, RGB>> for Image<T, Gray>
 where
     U: Data<Elem = T>,
     T: Copy
@@ -253,7 +253,7 @@ where
         + Display
         + PixelBound,
 {
-    fn from(image: Image<U, RGB>) -> Self {
+    fn from(image: ImageBase<U, RGB>) -> Self {
         let mut res = Array3::<T>::zeros((image.rows(), image.cols(), Gray::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
@@ -271,7 +271,7 @@ where
     }
 }
 
-impl<T, U> From<Image<U, Gray>> for Image<OwnedRepr<T>, RGB>
+impl<T, U> From<ImageBase<U, Gray>> for Image<T, RGB>
 where
     U: Data<Elem = T>,
     T: Copy
@@ -284,7 +284,7 @@ where
         + Display
         + PixelBound,
 {
-    fn from(image: Image<U, Gray>) -> Self {
+    fn from(image: ImageBase<U, Gray>) -> Self {
         let mut res = Array3::<T>::zeros((image.rows(), image.cols(), RGB::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
@@ -298,7 +298,7 @@ where
     }
 }
 
-impl<T, U> From<Image<U, RGB>> for Image<OwnedRepr<T>, CIEXYZ>
+impl<T, U> From<ImageBase<U, RGB>> for Image<T, CIEXYZ>
 where
     U: Data<Elem = T>,
     T: Copy
@@ -311,7 +311,7 @@ where
         + Display
         + PixelBound,
 {
-    fn from(image: Image<U, RGB>) -> Self {
+    fn from(image: ImageBase<U, RGB>) -> Self {
         let mut res = Array3::<T>::zeros((image.rows(), image.cols(), CIEXYZ::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
@@ -337,7 +337,7 @@ where
     }
 }
 
-impl<T, U> From<Image<U, CIEXYZ>> for Image<OwnedRepr<T>, RGB>
+impl<T, U> From<ImageBase<U, CIEXYZ>> for Image<T, RGB>
 where
     U: Data<Elem = T>,
     T: Copy
@@ -350,7 +350,7 @@ where
         + Display
         + PixelBound,
 {
-    fn from(image: Image<U, CIEXYZ>) -> Self {
+    fn from(image: ImageBase<U, CIEXYZ>) -> Self {
         let mut res = Array3::<T>::zeros((image.rows(), image.cols(), RGB::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
@@ -376,312 +376,312 @@ where
     }
 }
 
-impl<S, T> From<Image<T, Generic3>> for Image<OwnedRepr<S>, RGB>
+impl<T> From<ImageBase<T, Generic3>> for ImageBase<T, RGB>
 where
-    T: Data<Elem = S>,
+    T: Data,
 {
-    fn from(image: Image<T, Generic3>) -> Self {
+    fn from(image: ImageBase<T, Generic3>) -> Self {
         image.into_type_raw()
     }
 }
 
-impl<S, T> From<Image<T, Generic3>> for Image<T, HSV>
+impl<T> From<ImageBase<T, Generic3>> for ImageBase<T, HSV>
 where
-    T: Data<Elem = S>,
+    T: Data,
 {
-    fn from(image: Image<T, Generic3>) -> Self {
+    fn from(image: ImageBase<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<S, T> From<Image<T, Generic3>> for Image<OwnedRepr<S>, HSI>
+impl<T> From<ImageBase<T, Generic3>> for ImageBase<T, HSI>
 where
-    T: Data<Elem = S>,
+    T: Data,
 {
-    fn from(image: Image<T, Generic3>) -> Self {
+    fn from(image: ImageBase<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, HSL>
+impl<T> From<ImageBase<T, Generic3>> for ImageBase<T, HSL>
 where
     T: Data,
 {
-    fn from(image: Image<T, Generic3>) -> Self {
+    fn from(image: ImageBase<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, YCrCb>
+impl<T> From<ImageBase<T, Generic3>> for ImageBase<T, YCrCb>
 where
     T: Data,
 {
-    fn from(image: Image<T, Generic3>) -> Self {
+    fn from(image: ImageBase<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, CIEXYZ>
+impl<T> From<ImageBase<T, Generic3>> for ImageBase<T, CIEXYZ>
 where
     T: Data,
 {
-    fn from(image: Image<T, Generic3>) -> Self {
+    fn from(image: ImageBase<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, CIELAB>
+impl<T> From<ImageBase<T, Generic3>> for ImageBase<T, CIELAB>
 where
     T: Data,
 {
-    fn from(image: Image<T, Generic3>) -> Self {
+    fn from(image: ImageBase<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic3>> for Image<T, CIELUV>
+impl<T> From<ImageBase<T, Generic3>> for ImageBase<T, CIELUV>
 where
     T: Data,
 {
-    fn from(image: Image<T, Generic3>) -> Self {
+    fn from(image: ImageBase<T, Generic3>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic1>> for Image<T, Gray>
+impl<T> From<ImageBase<T, Generic1>> for ImageBase<T, Gray>
 where
     T: Data,
 {
-    fn from(image: Image<T, Generic1>) -> Self {
+    fn from(image: ImageBase<T, Generic1>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Generic4>> for Image<T, RGBA>
+impl<T> From<ImageBase<T, Generic4>> for ImageBase<T, RGBA>
 where
     T: Data,
 {
-    fn from(image: Image<T, Generic4>) -> Self {
+    fn from(image: ImageBase<T, Generic4>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, RGB>> for Image<T, Generic3>
+impl<T> From<ImageBase<T, RGB>> for ImageBase<T, Generic3>
 where
     T: Data,
 {
-    fn from(image: Image<T, RGB>) -> Self {
+    fn from(image: ImageBase<T, RGB>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<S, T> From<Image<T, HSV>> for Image<OwnedRepr<S>, Generic3>
+impl<T> From<ImageBase<T, HSV>> for ImageBase<T, Generic3>
 where
-    T: Data<Elem = S>,
+    T: Data,
 {
-    fn from(image: Image<T, HSV>) -> Self {
+    fn from(image: ImageBase<T, HSV>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<S, T> From<Image<T, HSI>> for Image<OwnedRepr<S>, Generic3>
+impl<T> From<ImageBase<T, HSI>> for ImageBase<T, Generic3>
 where
-    T: Data<Elem = S>,
+    T: Data,
 {
-    fn from(image: Image<T, HSI>) -> Self {
+    fn from(image: ImageBase<T, HSI>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<S, T> From<Image<T, HSL>> for Image<OwnedRepr<S>, Generic3>
+impl<T> From<ImageBase<T, HSL>> for ImageBase<T, Generic3>
 where
-    T: Data<Elem = S>,
+    T: Data,
 {
-    fn from(image: Image<T, HSL>) -> Self {
+    fn from(image: ImageBase<T, HSL>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<S, T> From<Image<T, YCrCb>> for Image<OwnedRepr<S>, Generic3>
+impl<T> From<ImageBase<T, YCrCb>> for ImageBase<T, Generic3>
 where
-    T: Data<Elem = S>,
+    T: Data,
 {
-    fn from(image: Image<T, YCrCb>) -> Self {
+    fn from(image: ImageBase<T, YCrCb>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<S, T> From<Image<T, CIEXYZ>> for Image<OwnedRepr<S>, Generic3>
+impl<T> From<ImageBase<T, CIEXYZ>> for ImageBase<T, Generic3>
 where
-    T: Data<Elem = S>,
+    T: Data,
 {
-    fn from(image: Image<T, CIEXYZ>) -> Self {
+    fn from(image: ImageBase<T, CIEXYZ>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<S, T> From<Image<T, CIELAB>> for Image<OwnedRepr<S>, Generic3>
+impl<T> From<ImageBase<T, CIELAB>> for ImageBase<T, Generic3>
 where
-    T: Data<Elem = S>,
+    T: Data,
 {
-    fn from(image: Image<T, CIELAB>) -> Self {
+    fn from(image: ImageBase<T, CIELAB>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<S, T> From<Image<T, CIELUV>> for Image<OwnedRepr<S>, Generic3>
+impl<T> From<ImageBase<T, CIELUV>> for ImageBase<T, Generic3>
 where
-    T: Data<Elem = S>,
+    T: Data,
 {
-    fn from(image: Image<T, CIELUV>) -> Self {
+    fn from(image: ImageBase<T, CIELUV>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, RGBA>> for Image<T, Generic4>
+impl<T> From<ImageBase<T, RGBA>> for ImageBase<T, Generic4>
 where
     T: Data,
 {
-    fn from(image: Image<T, RGBA>) -> Self {
+    fn from(image: ImageBase<T, RGBA>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T> From<Image<T, Gray>> for Image<T, Generic1>
+impl<T> From<ImageBase<T, Gray>> for ImageBase<T, Generic1>
 where
     T: Data,
 {
-    fn from(image: Image<T, Gray>) -> Self {
+    fn from(image: ImageBase<T, Gray>) -> Self {
         Self::from_data(image.data)
     }
 }
 
-impl<T, U> From<Image<U, Generic5>> for Image<U, Generic4>
+impl<T, U> From<ImageBase<U, Generic5>> for Image<T, Generic4>
 where
     U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<U, Generic5>) -> Self {
+    fn from(image: ImageBase<U, Generic5>) -> Self {
         let shape = (image.rows(), image.cols(), Generic4::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T, U> From<Image<U, Generic5>> for Image<U, Generic3>
+impl<T, U> From<ImageBase<U, Generic5>> for Image<T, Generic3>
 where
     U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<U, Generic5>) -> Self {
+    fn from(image: ImageBase<U, Generic5>) -> Self {
         let shape = (image.rows(), image.cols(), Generic3::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T, U> From<Image<U, Generic5>> for Image<U, Generic2>
+impl<T, U> From<ImageBase<U, Generic5>> for Image<T, Generic2>
 where
     U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<U, Generic5>) -> Self {
+    fn from(image: ImageBase<U, Generic5>) -> Self {
         let shape = (image.rows(), image.cols(), Generic2::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T, U> From<Image<U, Generic5>> for Image<U, Generic1>
+impl<T, U> From<ImageBase<U, Generic5>> for Image<T, Generic1>
 where
     U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<U, Generic5>) -> Self {
+    fn from(image: ImageBase<U, Generic5>) -> Self {
         let shape = (image.rows(), image.cols(), Generic1::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T, U> From<Image<U, Generic4>> for Image<U, Generic3>
+impl<T, U> From<ImageBase<U, Generic4>> for Image<T, Generic3>
 where
     U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<U, Generic4>) -> Self {
+    fn from(image: ImageBase<U, Generic4>) -> Self {
         let shape = (image.rows(), image.cols(), Generic3::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T, U> From<Image<U, Generic4>> for Image<U, Generic2>
+impl<T, U> From<ImageBase<U, Generic4>> for Image<T, Generic2>
 where
     U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<U, Generic4>) -> Self {
+    fn from(image: ImageBase<U, Generic4>) -> Self {
         let shape = (image.rows(), image.cols(), Generic2::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T, U> From<Image<U, Generic4>> for Image<OwnedRepr<T>, Generic1>
+impl<T, U> From<ImageBase<U, Generic4>> for Image<T, Generic1>
 where
     U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<U, Generic4>) -> Self {
+    fn from(image: ImageBase<U, Generic4>) -> Self {
         let shape = (image.rows(), image.cols(), Generic1::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T, U> From<Image<U, Generic3>> for Image<OwnedRepr<T>, Generic2>
+impl<T, U> From<ImageBase<U, Generic3>> for Image<T, Generic2>
 where
     U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<U, Generic3>) -> Self {
+    fn from(image: ImageBase<U, Generic3>) -> Self {
         let shape = (image.rows(), image.cols(), Generic2::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T, U> From<Image<U, Generic3>> for Image<OwnedRepr<T>, Generic1>
+impl<T, U> From<ImageBase<U, Generic3>> for Image<T, Generic1>
 where
     U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<U, Generic3>) -> Self {
+    fn from(image: ImageBase<U, Generic3>) -> Self {
         let shape = (image.rows(), image.cols(), Generic1::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T, U> From<Image<U, Generic2>> for Image<OwnedRepr<T>, Generic1>
+impl<T, U> From<ImageBase<U, Generic2>> for Image<T, Generic1>
 where
     U: Data<Elem = T>,
     T: Copy,
 {
-    fn from(image: Image<U, Generic2>) -> Self {
+    fn from(image: ImageBase<U, Generic2>) -> Self {
         let shape = (image.rows(), image.cols(), Generic1::channels());
         let data = Array3::from_shape_fn(shape, |(i, j, k)| image.data[[i, j, k]]);
         Self::from_data(data)
     }
 }
 
-impl<T, U> From<Image<U, Generic1>> for Image<OwnedRepr<T>, Generic5>
+impl<T, U> From<ImageBase<U, Generic1>> for Image<T, Generic5>
 where
     U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<U, Generic1>) -> Self {
+    fn from(image: ImageBase<U, Generic1>) -> Self {
         let shape = (image.rows(), image.cols(), Generic5::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic1::channels()])
@@ -690,12 +690,12 @@ where
     }
 }
 
-impl<T, U> From<Image<U, Generic2>> for Image<OwnedRepr<T>, Generic5>
+impl<T, U> From<ImageBase<U, Generic2>> for Image<T, Generic5>
 where
     U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<U, Generic2>) -> Self {
+    fn from(image: ImageBase<U, Generic2>) -> Self {
         let shape = (image.rows(), image.cols(), Generic5::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic2::channels()])
@@ -704,12 +704,12 @@ where
     }
 }
 
-impl<T, U> From<Image<U, Generic3>> for Image<U, Generic5>
+impl<T, U> From<ImageBase<U, Generic3>> for Image<T, Generic5>
 where
     U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<U, Generic3>) -> Self {
+    fn from(image: ImageBase<U, Generic3>) -> Self {
         let shape = (image.rows(), image.cols(), Generic5::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic3::channels()])
@@ -718,12 +718,12 @@ where
     }
 }
 
-impl<T, U> From<Image<U, Generic4>> for Image<U, Generic5>
+impl<T, U> From<ImageBase<U, Generic4>> for Image<T, Generic5>
 where
     U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<U, Generic4>) -> Self {
+    fn from(image: ImageBase<U, Generic4>) -> Self {
         let shape = (image.rows(), image.cols(), Generic5::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic4::channels()])
@@ -732,12 +732,12 @@ where
     }
 }
 
-impl<T, U> From<Image<U, Generic1>> for Image<U, Generic4>
+impl<T, U> From<ImageBase<U, Generic1>> for Image<T, Generic4>
 where
     U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<U, Generic1>) -> Self {
+    fn from(image: ImageBase<U, Generic1>) -> Self {
         let shape = (image.rows(), image.cols(), Generic4::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic1::channels()])
@@ -746,12 +746,12 @@ where
     }
 }
 
-impl<T, U> From<Image<U, Generic2>> for Image<U, Generic4>
+impl<T, U> From<ImageBase<U, Generic2>> for Image<T, Generic4>
 where
     U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<U, Generic2>) -> Self {
+    fn from(image: ImageBase<U, Generic2>) -> Self {
         let shape = (image.rows(), image.cols(), Generic4::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic2::channels()])
@@ -760,12 +760,12 @@ where
     }
 }
 
-impl<T, U> From<Image<U, Generic3>> for Image<U, Generic4>
+impl<T, U> From<ImageBase<U, Generic3>> for Image<T, Generic4>
 where
     U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<U, Generic3>) -> Self {
+    fn from(image: ImageBase<U, Generic3>) -> Self {
         let shape = (image.rows(), image.cols(), Generic4::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic3::channels()])
@@ -774,12 +774,12 @@ where
     }
 }
 
-impl<T, U> From<Image<U, Generic1>> for Image<U, Generic3>
+impl<T, U> From<ImageBase<U, Generic1>> for Image<T, Generic3>
 where
     U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<U, Generic1>) -> Self {
+    fn from(image: ImageBase<U, Generic1>) -> Self {
         let shape = (image.rows(), image.cols(), Generic3::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic1::channels()])
@@ -788,12 +788,12 @@ where
     }
 }
 
-impl<T, U> From<Image<U, Generic2>> for Image<U, Generic3>
+impl<T, U> From<ImageBase<U, Generic2>> for Image<T, Generic3>
 where
     U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<U, Generic2>) -> Self {
+    fn from(image: ImageBase<U, Generic2>) -> Self {
         let shape = (image.rows(), image.cols(), Generic3::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic2::channels()])
@@ -802,12 +802,12 @@ where
     }
 }
 
-impl<T, U> From<Image<U, Generic1>> for Image<U, Generic2>
+impl<T, U> From<ImageBase<U, Generic1>> for Image<T, Generic2>
 where
     U: Data<Elem = T>,
     T: Copy + Num,
 {
-    fn from(image: Image<U, Generic1>) -> Self {
+    fn from(image: ImageBase<U, Generic1>) -> Self {
         let shape = (image.rows(), image.cols(), Generic2::channels());
         let mut data = Array3::zeros(shape);
         data.slice_mut(s![.., .., 0..Generic1::channels()])
diff --git a/src/core/image.rs b/src/core/image.rs
index 1cb6734..0642673 100644
--- a/src/core/image.rs
+++ b/src/core/image.rs
@@ -1,14 +1,16 @@
 use crate::core::colour_models::*;
 use crate::core::traits::PixelBound;
 use ndarray::prelude::*;
-use ndarray::{s, Data};
+use ndarray::{s, Data, DataMut, OwnedRepr, ViewRepr};
 use num_traits::cast::{FromPrimitive, NumCast};
 use num_traits::Num;
 use std::marker::PhantomData;
 
+pub type Image<T, C> = ImageBase<OwnedRepr<T>, C>;
+pub type ImageView<'a, T, C> = ImageBase<ViewRepr<&'a T>, C>;
+
 /// Basic structure containing an image.
-#[derive(Clone, Eq, PartialEq, Hash, Debug)]
-pub struct Image<T, C>
+pub struct ImageBase<T, C>
 where
     C: ColourModel,
     T: Data,
@@ -26,16 +28,15 @@ where
     pub(crate) model: PhantomData<C>,
 }
 
-impl<T, U, C> Image<U, C>
+impl<T, U, C> ImageBase<U, C>
 where
     U: Data<Elem = T>,
     T: Copy + Clone + FromPrimitive + Num + NumCast + PixelBound,
     C: ColourModel,
 {
     /// Converts image into a different type - doesn't scale to new pixel bounds
-    pub fn into_type<T2, U2>(self) -> Image<U2, C>
+    pub fn into_type<T2>(self) -> Image<T2, C>
     where
-        U2: Data<Elem = T2>,
         T2: Copy + Clone + FromPrimitive + Num + NumCast + PixelBound,
     {
         let rescale = |x: &T| {
@@ -46,13 +47,12 @@ where
             T2::from_f64(scaled).unwrap_or_else(T2::zero) + T2::min_pixel()
         };
         let data = self.data.map(rescale);
-        Image::<U2, C>::from_data(data)
+        Image::<_, C>::from_data(data)
     }
 }
 
-impl<T, C, U> Image<U, C>
+impl<T, C> Image<T, C>
 where
-    U: Data<Elem = T>,
     T: Clone + Num,
     C: ColourModel,
 {
@@ -60,7 +60,7 @@ where
     /// a colour model
     pub fn new(rows: usize, columns: usize) -> Self {
         Image {
-            data: Array3::<T>::zeros((rows, columns, C::channels())),
+            data: Array3::zeros((rows, columns, C::channels())),
             model: PhantomData,
         }
     }
@@ -69,7 +69,7 @@ where
     /// 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 {
-        let data = Array3::<T>::from_shape_vec((rows, cols, C::channels()), data)
+        let data = Array3::from_shape_vec((rows, cols, C::channels()), data)
             .unwrap_or_else(|_| Array3::<T>::zeros((rows, cols, C::channels())));
 
         Image {
@@ -77,27 +77,30 @@ where
             model: PhantomData,
         }
     }
+}
 
+impl<T, C> ImageBase<T, C>
+where
+    T: Data,
+    C: ColourModel,
+{
     /// Create an image given an existing ndarray
-    pub fn from_array<V>(data: ArrayBase<V, Ix3>) -> Self
-    where
-        V: Data<Elem = T>,
-    {
-        Image {
+    pub fn from_array(data: ArrayBase<T, Ix3>) -> Self {
+        Self {
             data,
             model: PhantomData,
         }
     }
 }
 
-impl<T, U, C> Image<T, C>
+impl<T, U, C> ImageBase<T, C>
 where
     T: Data<Elem = U>,
     C: ColourModel,
 {
     /// Construct the image from a given Array3
     pub fn from_data(data: ArrayBase<T, Ix3>) -> Self {
-        Image {
+        Self {
             data,
             model: PhantomData,
         }
@@ -117,22 +120,27 @@ where
     }
 
     /// Get a view of all colour channels at a pixels location
-    pub fn pixel(&self, row: usize, col: usize) -> ArrayView<T, Ix1> {
+    pub fn pixel(&self, row: usize, col: usize) -> ArrayView<U, Ix1> {
         self.data.slice(s![row, col, ..])
     }
 
-    /// Get a mutable view of a pixels colour channels given a location
-    pub fn pixel_mut(&mut self, row: usize, col: usize) -> ArrayViewMut<T, Ix1> {
-        self.data.slice_mut(s![row, col, ..])
-    }
-
-    pub fn into_type_raw<U2, C2>(self) -> Image<U2, C>
+    pub fn into_type_raw<C2>(self) -> ImageBase<T, C2>
     where
-        U2: Data<Elem = U>,
         C2: ColourModel,
     {
         assert_eq!(C2::channels(), C::channels());
-        Image::<U2, C2>::from_data(self.data)
+        ImageBase::<T, C2>::from_data(self.data)
+    }
+}
+
+impl<T, U, C> ImageBase<T, C>
+where
+    T: DataMut<Elem = U>,
+    C: ColourModel,
+{
+    /// Get a mutable view of a pixels colour channels given a location
+    pub fn pixel_mut(&mut self, row: usize, col: usize) -> ArrayViewMut<U, Ix1> {
+        self.data.slice_mut(s![row, col, ..])
     }
 }
 
diff --git a/src/core/padding.rs b/src/core/padding.rs
index 257a5f8..28c8350 100644
--- a/src/core/padding.rs
+++ b/src/core/padding.rs
@@ -1,5 +1,5 @@
-use crate::core::{ColourModel, Image};
-use ndarray::{prelude::*, s, Data};
+use crate::core::{ColourModel, Image, ImageBase};
+use ndarray::{prelude::*, s, Data, OwnedRepr};
 use num_traits::identities::Zero;
 use std::marker::PhantomData;
 
@@ -11,7 +11,11 @@ where
 {
     /// 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>;
+    fn pad(
+        &self,
+        image: ArrayView<T, Ix3>,
+        padding: (usize, usize),
+    ) -> ArrayBase<OwnedRepr<T>, Ix3>;
 }
 
 /// Doesn't apply any padding to the image returning it unaltered regardless
@@ -33,7 +37,11 @@ impl<T> PaddingStrategy<T> for NoPadding
 where
     T: Copy,
 {
-    fn pad(&self, image: ArrayView3<T>, _padding: (usize, usize)) -> Array3<T> {
+    fn pad(
+        &self,
+        image: ArrayView<T, Ix3>,
+        _padding: (usize, usize),
+    ) -> ArrayBase<OwnedRepr<T>, Ix3> {
         image.to_owned()
     }
 }
@@ -42,7 +50,11 @@ impl<T> PaddingStrategy<T> for ConstantPadding<T>
 where
     T: Copy,
 {
-    fn pad(&self, image: ArrayView3<T>, padding: (usize, usize)) -> Array3<T> {
+    fn pad(
+        &self,
+        image: ArrayView<T, Ix3>,
+        padding: (usize, usize),
+    ) -> ArrayBase<OwnedRepr<T>, Ix3> {
         let shape = (
             image.shape()[0] + padding.0 * 2,
             image.shape()[1] + padding.1 * 2,
@@ -66,42 +78,46 @@ impl<T> PaddingStrategy<T> for ZeroPadding
 where
     T: Copy + Zero,
 {
-    fn pad(&self, image: ArrayView3<T>, padding: (usize, usize)) -> Array3<T> {
+    fn pad(
+        &self,
+        image: ArrayView<T, Ix3>,
+        padding: (usize, usize),
+    ) -> ArrayBase<OwnedRepr<T>, Ix3> {
         let padder = ConstantPadding(T::zero());
         padder.pad(image, padding)
     }
 }
 
 /// Padding extension for images
-pub trait PaddingExt {
-    /// Data type for container
-    type Data;
+pub trait PaddingExt<T> {
+    /// Type of the output image
+    type Output;
     /// Pad the object with the given padding and strategy
-    fn pad(&self, padding: (usize, usize), strategy: &dyn PaddingStrategy<Self::Data>) -> Self;
+    fn pad(&self, padding: (usize, usize), strategy: &dyn PaddingStrategy<T>) -> Self::Output;
 }
 
-impl<T, U> PaddingExt for ArrayBase<U, Ix3>
+impl<T, U> PaddingExt<T> for ArrayBase<U, Ix3>
 where
     U: Data<Elem = T>,
     T: Copy,
 {
-    type Data = T;
+    type Output = ArrayBase<OwnedRepr<T>, Ix3>;
 
-    fn pad(&self, padding: (usize, usize), strategy: &dyn PaddingStrategy<Self::Data>) -> Self {
+    fn pad(&self, padding: (usize, usize), strategy: &dyn PaddingStrategy<T>) -> Self::Output {
         strategy.pad(self.view(), padding)
     }
 }
 
-impl<T, U, C> PaddingExt for Image<U, C>
+impl<T, U, C> PaddingExt<T> for ImageBase<U, C>
 where
     U: Data<Elem = T>,
     T: Copy,
     C: ColourModel,
 {
-    type Data = T;
+    type Output = Image<T, C>;
 
-    fn pad(&self, padding: (usize, usize), strategy: &dyn PaddingStrategy<Self::Data>) -> Self {
-        Self {
+    fn pad(&self, padding: (usize, usize), strategy: &dyn PaddingStrategy<T>) -> Self::Output {
+        Self::Output {
             data: strategy.pad(self.data.view(), padding),
             model: PhantomData,
         }

From 3f0ff8d1c81fca4290a8e0a5ffcbb0d180c16796 Mon Sep 17 00:00:00 2001
From: xd009642 <danielmckenna93@gmail.com>
Date: Sat, 30 Nov 2019 12:20:39 +0000
Subject: [PATCH 4/9] Got histogram eq working with new traits

---
 src/core/image.rs                         | 14 ++++++++++++++
 src/enhancement/histogram_equalisation.rs | 20 ++++++++++++--------
 2 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/src/core/image.rs b/src/core/image.rs
index 0642673..16b5ea3 100644
--- a/src/core/image.rs
+++ b/src/core/image.rs
@@ -51,6 +51,20 @@ where
     }
 }
 
+impl<S, T, C> ImageBase<S, C>
+where
+    S: Data<Elem = T>,
+    T: Clone,
+    C: ColourModel,
+{
+    pub fn to_owned(&self) -> Image<T, C> {
+        Image {
+            data: self.data.to_owned(),
+            model: PhantomData,
+        }
+    }
+}
+
 impl<T, C> Image<T, C>
 where
     T: Clone + Num,
diff --git a/src/enhancement/histogram_equalisation.rs b/src/enhancement/histogram_equalisation.rs
index 6e97e78..d1e454e 100644
--- a/src/enhancement/histogram_equalisation.rs
+++ b/src/enhancement/histogram_equalisation.rs
@@ -10,9 +10,10 @@ pub trait HistogramEqExt<A>
 where
     A: Ord,
 {
+    type Output;
     /// 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;
+    fn equalise_hist(&self, grid: Grid<A>) -> Self::Output;
 
     /// Equalises an image histogram inplace
     /// Grids should be for a 1xN image as the image is flattened during processing
@@ -24,8 +25,10 @@ where
     U: Data<Elem = T> + DataMut<Elem = T>,
     T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive + PixelBound,
 {
-    fn equalise_hist(&self, grid: Grid<T>) -> Self {
-        let mut result = self.clone();
+    type Output = Array<T, Ix3>;
+
+    fn equalise_hist(&self, grid: Grid<T>) -> Self::Output {
+        let mut result = self.to_owned();
         result.equalise_hist_inplace(grid);
         result
     }
@@ -72,15 +75,16 @@ where
     }
 }
 
-impl<T, U, C> HistogramEqExt<T> for Image<U, C>
+impl<T, U, C> HistogramEqExt<T> for ImageBase<U, C>
 where
-    U: Data<Elem = T>,
-    Image<U, C>: Clone,
+    U: Data<Elem = T> + DataMut<Elem = T>,
     T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive + PixelBound,
     C: ColourModel,
 {
-    fn equalise_hist(&self, grid: Grid<T>) -> Self {
-        let mut result = self.clone();
+    type Output = Image<T, C>;
+
+    fn equalise_hist(&self, grid: Grid<T>) -> Self::Output {
+        let mut result = self.to_owned();
         result.equalise_hist_inplace(grid);
         result
     }

From 03cfadf34bd49b860dc0a6972738d6d81be9115a Mon Sep 17 00:00:00 2001
From: xd009642 <danielmckenna93@gmail.com>
Date: Sat, 30 Nov 2019 15:59:50 +0000
Subject: [PATCH 5/9] Update processing module

---
 src/processing/canny.rs     | 12 +++++------
 src/processing/conv.rs      | 22 +++++++++----------
 src/processing/filter.rs    |  6 +++---
 src/processing/sobel.rs     | 42 +++++++++----------------------------
 src/processing/threshold.rs | 12 +++++------
 5 files changed, 36 insertions(+), 58 deletions(-)

diff --git a/src/processing/canny.rs b/src/processing/canny.rs
index 61218c1..a2d5a45 100644
--- a/src/processing/canny.rs
+++ b/src/processing/canny.rs
@@ -1,7 +1,7 @@
-use crate::core::{ColourModel, Image};
+use crate::core::{ColourModel, Image, ImageBase};
 use crate::processing::*;
 use ndarray::prelude::*;
-use ndarray::{Data, IntoDimension, OwnedRepr};
+use ndarray::{Data, DataMut, IntoDimension};
 use num_traits::{cast::FromPrimitive, real::Real, Num, NumAssignOps};
 use std::collections::HashSet;
 use std::marker::PhantomData;
@@ -38,13 +38,13 @@ pub struct CannyParameters<T> {
     pub t2: T,
 }
 
-impl<T, U, C> CannyEdgeDetectorExt<T> for Image<U, C>
+impl<T, U, C> CannyEdgeDetectorExt<T> for ImageBase<U, C>
 where
-    U: Data<Elem = T>,
+    U: Data<Elem = T> + DataMut<Elem = T>,
     T: Copy + Clone + FromPrimitive + Real + Num + NumAssignOps,
     C: ColourModel,
 {
-    type Output = Image<OwnedRepr<bool>, C>;
+    type Output = Image<bool, C>;
 
     fn canny_edge_detector(&self, params: CannyParameters<T>) -> Result<Self::Output, Error> {
         let data = self.data.canny_edge_detector(params)?;
@@ -57,7 +57,7 @@ where
 
 impl<T, U> CannyEdgeDetectorExt<T> for ArrayBase<U, Ix3>
 where
-    U: Data<Elem = T>,
+    U: Data<Elem = T> + DataMut<Elem = T>,
     T: Copy + Clone + FromPrimitive + Real + Num + NumAssignOps,
 {
     type Output = Array3<bool>;
diff --git a/src/processing/conv.rs b/src/processing/conv.rs
index 9a4e0ff..4794127 100644
--- a/src/processing/conv.rs
+++ b/src/processing/conv.rs
@@ -1,8 +1,8 @@
 use crate::core::padding::*;
-use crate::core::{ColourModel, Image};
+use crate::core::{ColourModel, Image, ImageBase};
 use crate::processing::Error;
 use ndarray::prelude::*;
-use ndarray::{s, Data, OwnedRepr, Zip};
+use ndarray::{s, Data, DataMut, Zip};
 use num_traits::{Num, NumAssignOps};
 use std::marker::PhantomData;
 use std::marker::Sized;
@@ -47,18 +47,18 @@ fn kernel_centre(rows: usize, cols: usize) -> (usize, usize) {
 
 impl<T, U> ConvolutionExt for ArrayBase<U, Ix3>
 where
-    U: Data<Elem = T>,
+    U: Data<Elem = T> + DataMut<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps,
 {
     type Data = T;
-    type Output = ArrayBase<OwnedRepr<T>, Ix3>;
+    type Output = Array<T, Ix3>;
 
     fn conv2d(&self, kernel: ArrayView3<Self::Data>) -> Result<Self::Output, Error> {
         self.conv2d_with_padding(kernel, &ZeroPadding {})
     }
 
     fn conv2d_inplace(&mut self, kernel: ArrayView3<Self::Data>) -> Result<(), Error> {
-        *self = self.conv2d_with_padding(kernel, &ZeroPadding {})?;
+        self.assign(&self.conv2d_with_padding(kernel, &ZeroPadding {})?);
         Ok(())
     }
 
@@ -97,23 +97,23 @@ where
         kernel: ArrayView3<Self::Data>,
         strategy: &dyn PaddingStrategy<Self::Data>,
     ) -> Result<(), Error> {
-        *self = self.conv2d_with_padding(kernel, strategy)?;
+        self.assign(&self.conv2d_with_padding(kernel, strategy)?);
         Ok(())
     }
 }
 
-impl<T, U, C> ConvolutionExt for Image<U, C>
+impl<T, U, C> ConvolutionExt for ImageBase<U, C>
 where
-    U: Data<Elem = T>,
+    U: Data<Elem = T> + DataMut<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps,
     C: ColourModel,
 {
     type Data = T;
-    type Output = Image<OwnedRepr<T>, C>;
+    type Output = Image<T, C>;
 
     fn conv2d(&self, kernel: ArrayView3<Self::Data>) -> Result<Self::Output, Error> {
         let data = self.data.conv2d(kernel)?;
-        Ok(Self {
+        Ok(Self::Output {
             data,
             model: PhantomData,
         })
@@ -129,7 +129,7 @@ where
         strategy: &dyn PaddingStrategy<Self::Data>,
     ) -> Result<Self::Output, Error> {
         let data = self.data.conv2d_with_padding(kernel, strategy)?;
-        Ok(Self {
+        Ok(Self::Output {
             data,
             model: PhantomData,
         })
diff --git a/src/processing/filter.rs b/src/processing/filter.rs
index ab78e90..3c97ec6 100644
--- a/src/processing/filter.rs
+++ b/src/processing/filter.rs
@@ -1,4 +1,4 @@
-use crate::core::{ColourModel, Image};
+use crate::core::{ColourModel, Image, ImageBase};
 use ndarray::prelude::*;
 use ndarray::{Data, IntoDimension, OwnedRepr, Zip};
 use ndarray_stats::interpolate::*;
@@ -47,13 +47,13 @@ where
     }
 }
 
-impl<T, U, C> MedianFilterExt for Image<U, C>
+impl<T, U, C> MedianFilterExt for ImageBase<U, C>
 where
     U: Data<Elem = T>,
     T: Copy + Clone + FromPrimitive + ToPrimitive + Num + Ord,
     C: ColourModel,
 {
-    type Output = Image<OwnedRepr<T>, C>;
+    type Output = Image<T, C>;
 
     fn median_filter<E>(&self, region: E) -> Self::Output
     where
diff --git a/src/processing/sobel.rs b/src/processing/sobel.rs
index 47d61ef..812756b 100644
--- a/src/processing/sobel.rs
+++ b/src/processing/sobel.rs
@@ -1,7 +1,7 @@
 use crate::core::*;
 use crate::processing::*;
 use core::ops::Neg;
-use ndarray::{prelude::*, Data, OwnedRepr};
+use ndarray::{prelude::*, Data, DataMut, OwnedRepr};
 use num_traits::{cast::FromPrimitive, real::Real, Num, NumAssignOps};
 use std::marker::Sized;
 
@@ -14,14 +14,7 @@ where
     type Output;
     /// Returns the magnitude output of the sobel - an image of only lines
     fn apply_sobel(&self) -> Result<Self::Output, Error>;
-}
 
-pub trait FullSobelExt
-where
-    Self: Sized,
-{
-    /// Type to output
-    type Output;
     /// Returns the magntitude and rotation outputs for use in other algorithms
     /// like the Canny edge detector. Rotation is in radians
     fn full_sobel(&self) -> Result<(Self::Output, Self::Output), Error>;
@@ -31,7 +24,7 @@ fn get_edge_images<T, U>(
     mat: &ArrayBase<U, Ix3>,
 ) -> Result<(ArrayBase<OwnedRepr<T>, Ix3>, ArrayBase<OwnedRepr<T>, Ix3>), Error>
 where
-    U: Data<Elem = T>,
+    U: Data<Elem = T> + DataMut<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps + Neg<Output = T> + FromPrimitive + Real,
 {
     let v_temp: Array3<T> = SobelFilter::build_with_params(Orientation::Vertical).unwrap();
@@ -48,7 +41,7 @@ where
 
 impl<T, U> SobelExt for ArrayBase<U, Ix3>
 where
-    U: Data<Elem=T>,
+    U: Data<Elem = T> + DataMut<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps + Neg<Output = T> + FromPrimitive + Real,
 {
     type Output = ArrayBase<OwnedRepr<T>, Ix3>;
@@ -67,14 +60,6 @@ where
 
         Ok(result)
     }
-}
-
-impl<T, U> FullSobelExt for ArrayBase<U, Ix3>
-where
-    U: Data<Elem=T>,
-    T: Copy + Clone + Num + NumAssignOps + Neg<Output = T> + FromPrimitive + Real,
-{
-    type Output = ArrayBase<OwnedRepr<T>, Ix3>;
 
     fn full_sobel(&self) -> Result<(Self::Output, Self::Output), Error> {
         let (h_deriv, v_deriv) = get_edge_images(self)?;
@@ -90,29 +75,22 @@ where
     }
 }
 
-impl<T, U, C> SobelExt for Image<U, C>
+impl<T, U, C> SobelExt for ImageBase<U, C>
 where
-    U: Data<Elem = T>,
+    U: Data<Elem = T> + DataMut<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps + Neg<Output = T> + FromPrimitive + Real,
     C: ColourModel,
 {
-    type Output = Image<OwnedRepr<T>, C>;
+    type Output = Image<T, C>;
 
-    fn apply_sobel(&self) -> Result<Self, Error> {
+    fn apply_sobel(&self) -> Result<Self::Output, Error> {
         let data = self.data.apply_sobel()?;
         Ok(Image::from_data(data))
     }
-}
-
-impl<T, U, C> FullSobelExt for Image<U, C>
-where
-    U: Data<Elem = T>,
-    T: Copy + Clone + Num + NumAssignOps + Neg<Output = T> + FromPrimitive + Real,
-    C: ColourModel,
-{
-    type Output = ArrayBase<OwnedRepr<T>, Ix3>;
 
     fn full_sobel(&self) -> Result<(Self::Output, Self::Output), Error> {
-        self.data.full_sobel()
+        self.data
+            .full_sobel()
+            .map(|(m, r)| (Image::from_data(m), Image::from_data(r)))
     }
 }
diff --git a/src/processing/threshold.rs b/src/processing/threshold.rs
index d92b88d..f4ea498 100644
--- a/src/processing/threshold.rs
+++ b/src/processing/threshold.rs
@@ -1,7 +1,7 @@
 use crate::core::PixelBound;
-use crate::core::{ColourModel, Image};
+use crate::core::{ColourModel, Image, ImageBase};
 use crate::processing::*;
-use ndarray::{prelude::*, Data, OwnedRepr};
+use ndarray::{prelude::*, Data};
 use ndarray_stats::histogram::{Bins, Edges, Grid};
 use ndarray_stats::HistogramExt;
 use ndarray_stats::QuantileExt;
@@ -41,14 +41,14 @@ pub trait ThresholdMeanExt<T> {
     fn threshold_mean(&self) -> Result<Self::Output, Error>;
 }
 
-impl<T, U, C> ThresholdOtsuExt<T> for Image<U, C>
+impl<T, U, C> ThresholdOtsuExt<T> for ImageBase<U, C>
 where
     U: Data<Elem = T>,
     Image<U, C>: Clone,
     T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive + PixelBound,
     C: ColourModel,
 {
-    type Output = Image<OwnedRepr<bool>, C>;
+    type Output = Image<bool, C>;
 
     fn threshold_otsu(&self) -> Result<Self::Output, Error> {
         let data = self.data.threshold_otsu()?;
@@ -135,14 +135,14 @@ where
     Ok(threshold)
 }
 
-impl<T, U, C> ThresholdMeanExt<T> for Image<U, C>
+impl<T, U, C> ThresholdMeanExt<T> for ImageBase<U, C>
 where
     U: Data<Elem = T>,
     Image<U, C>: Clone,
     T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive + PixelBound,
     C: ColourModel,
 {
-    type Output = Image<OwnedRepr<bool>, C>;
+    type Output = Image<bool, C>;
 
     fn threshold_mean(&self) -> Result<Self::Output, Error> {
         let data = self.data.threshold_mean()?;

From 08caed1d32fe52c75f3b9d206831cabf04e303e3 Mon Sep 17 00:00:00 2001
From: xd009642 <danielmckenna93@gmail.com>
Date: Sat, 30 Nov 2019 16:12:55 +0000
Subject: [PATCH 6/9] Update rest of the library code

Now just to refactor the tests and the new types will be ready for review
---
 src/format/mod.rs    | 13 ++++++++-----
 src/format/netpbm.rs | 18 ++++++++----------
 src/transform/mod.rs | 13 +++++++------
 3 files changed, 23 insertions(+), 21 deletions(-)

diff --git a/src/format/mod.rs b/src/format/mod.rs
index d5dd1fc..c496ec4 100644
--- a/src/format/mod.rs
+++ b/src/format/mod.rs
@@ -16,11 +16,15 @@ where
     C: ColourModel,
 {
     /// Encode an image into a sequence of bytes for the given format
-    fn encode(&self, image: &Image<U, C>) -> Vec<u8>;
+    fn encode(&self, image: &ImageBase<U, C>) -> Vec<u8>;
 
     /// Encode an image saving it to the file at filename. This function shouldn't
     /// add an extension preferring the user to do that instead.
-    fn encode_file<P: AsRef<Path>>(&self, image: &Image<U, C>, filename: P) -> std::io::Result<()> {
+    fn encode_file<P: AsRef<Path>>(
+        &self,
+        image: &ImageBase<U, C>,
+        filename: P,
+    ) -> std::io::Result<()> {
         let mut file = File::create(filename)?;
         file.write_all(&self.encode(image))?;
         Ok(())
@@ -30,7 +34,6 @@ where
 /// Trait for an image decoder, use this to get an image from a byte stream
 pub trait Decoder<T, U, C>
 where
-    U: Data<Elem = T>,
     T: Copy
         + Clone
         + FromPrimitive
@@ -44,9 +47,9 @@ where
 {
     /// From the bytes decode an image, will perform any scaling or conversions
     /// required to represent elements with type T.
-    fn decode(&self, bytes: &[u8]) -> std::io::Result<Image<U, C>>;
+    fn decode(&self, bytes: &[u8]) -> std::io::Result<Image<T, C>>;
     /// Given a filename decode an image performing any necessary conversions.
-    fn decode_file<P: AsRef<Path>>(&self, filename: P) -> std::io::Result<Image<U, C>> {
+    fn decode_file<P: AsRef<Path>>(&self, filename: P) -> std::io::Result<Image<T, C>> {
         let bytes = read(filename)?;
         self.decode(&bytes)
     }
diff --git a/src/format/netpbm.rs b/src/format/netpbm.rs
index 4672e3b..1da8bea 100644
--- a/src/format/netpbm.rs
+++ b/src/format/netpbm.rs
@@ -1,4 +1,4 @@
-use crate::core::{normalise_pixel_value, Image, PixelBound, RGB};
+use crate::core::{normalise_pixel_value, Image, ImageBase, PixelBound, RGB};
 use crate::format::{Decoder, Encoder};
 use ndarray::Data;
 use num_traits::cast::{FromPrimitive, NumCast};
@@ -46,7 +46,7 @@ where
         + PixelBound
         + FromPrimitive,
 {
-    fn encode(&self, image: &Image<U, RGB>) -> Vec<u8> {
+    fn encode(&self, image: &ImageBase<U, RGB>) -> Vec<u8> {
         use EncodingType::*;
         match self.encoding {
             Plaintext => self.encode_plaintext(image),
@@ -73,7 +73,7 @@ impl PpmEncoder {
 
     /// Gets the maximum pixel value in the image across all channels. This is
     /// used in the PPM header
-    fn get_max_value<T, U>(image: &Image<U, RGB>) -> Option<u8>
+    fn get_max_value<T, U>(image: &ImageBase<U, RGB>) -> Option<u8>
     where
         U: Data<Elem = T>,
         T: Copy + Clone + Num + NumAssignOps + NumCast + PartialOrd + Display + PixelBound,
@@ -95,7 +95,7 @@ impl PpmEncoder {
     }
 
     /// Encode the image into the binary PPM format (P6) returning the bytes
-    fn encode_binary<T, U>(self, image: &Image<U, RGB>) -> Vec<u8>
+    fn encode_binary<T, U>(self, image: &ImageBase<U, RGB>) -> Vec<u8>
     where
         U: Data<Elem = T>,
         T: Copy + Clone + Num + NumAssignOps + NumCast + PartialOrd + Display + PixelBound,
@@ -117,7 +117,7 @@ impl PpmEncoder {
 
     /// Encode the image into the plaintext PPM format (P3) returning the text as
     /// an array of bytes
-    fn encode_plaintext<T, U>(self, image: &Image<U, RGB>) -> Vec<u8>
+    fn encode_plaintext<T, U>(self, image: &ImageBase<U, RGB>) -> Vec<u8>
     where
         U: Data<Elem = T>,
         T: Copy + Clone + Num + NumAssignOps + NumCast + PartialOrd + Display + PixelBound,
@@ -168,7 +168,7 @@ where
         + PixelBound
         + FromPrimitive,
 {
-    fn decode(&self, bytes: &[u8]) -> std::io::Result<Image<U, RGB>> {
+    fn decode(&self, bytes: &[u8]) -> std::io::Result<Image<T, RGB>> {
         if bytes.len() < 9 {
             Err(Error::new(
                 ErrorKind::InvalidData,
@@ -226,9 +226,8 @@ impl PpmDecoder {
         }
     }
 
-    fn decode_binary<T, U>(bytes: &[u8]) -> std::io::Result<Image<U, RGB>>
+    fn decode_binary<T>(bytes: &[u8]) -> std::io::Result<Image<T, RGB>>
     where
-        U: Data<Elem = T>,
         T: Copy
             + Clone
             + Num
@@ -280,9 +279,8 @@ impl PpmDecoder {
         }
     }
 
-    fn decode_plaintext<T, U>(bytes: &[u8]) -> std::io::Result<Image<U, RGB>>
+    fn decode_plaintext<T>(bytes: &[u8]) -> std::io::Result<Image<T, RGB>>
     where
-        U: Data<Elem = T>,
         T: Copy
             + Clone
             + Num
diff --git a/src/transform/mod.rs b/src/transform/mod.rs
index ac0bb48..c97789d 100644
--- a/src/transform/mod.rs
+++ b/src/transform/mod.rs
@@ -1,6 +1,6 @@
-use crate::core::{ColourModel, Image};
+use crate::core::{ColourModel, Image, ImageBase};
 use crate::transform::affine::translation;
-use ndarray::{array, prelude::*, s, Data, OwnedRepr};
+use ndarray::{array, prelude::*, s, Data};
 use ndarray_linalg::solve::Inverse;
 use num_traits::{Num, NumAssignOps};
 use std::cmp::{max, min};
@@ -87,7 +87,7 @@ where
     T: Copy + Clone + Num + NumAssignOps,
     U: Data<Elem = T>,
 {
-    type Output = ArrayBase<OwnedRepr<T>, Ix3>;
+    type Output = Array<T, Ix3>;
 
     fn transform(
         &self,
@@ -138,13 +138,13 @@ where
     }
 }
 
-impl<T, U, C> TransformExt for Image<U, C>
+impl<T, U, C> TransformExt for ImageBase<U, C>
 where
     U: Data<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps,
     C: ColourModel,
 {
-    type Output = Image<OwnedRepr<T>, C>;
+    type Output = Image<T, C>;
 
     fn transform(
         &self,
@@ -152,7 +152,8 @@ where
         output_size: Option<(usize, usize)>,
     ) -> Result<Self::Output, Error> {
         let data = self.data.transform(transform, output_size)?;
-        Ok(Self::from_array(data))
+        let result = Self::Output::from_array(data).to_owned();
+        Ok(result)
     }
 }
 

From 2c3961a9f214245c6b3ef96a51be9a94a878b973 Mon Sep 17 00:00:00 2001
From: xd009642 <danielmckenna93@gmail.com>
Date: Sat, 30 Nov 2019 16:36:00 +0000
Subject: [PATCH 7/9] Update traits for tests

---
 src/core/image.rs         | 56 +++++++++++++++++++++++++++++++++++++--
 src/format/mod.rs         |  2 +-
 src/format/netpbm.rs      |  3 +--
 src/processing/kernels.rs |  6 ++---
 4 files changed, 59 insertions(+), 8 deletions(-)

diff --git a/src/core/image.rs b/src/core/image.rs
index 16b5ea3..3c9c4f2 100644
--- a/src/core/image.rs
+++ b/src/core/image.rs
@@ -1,10 +1,10 @@
 use crate::core::colour_models::*;
 use crate::core::traits::PixelBound;
 use ndarray::prelude::*;
-use ndarray::{s, Data, DataMut, OwnedRepr, ViewRepr};
+use ndarray::{s, Data, DataMut, OwnedRepr, RawDataClone, ViewRepr};
 use num_traits::cast::{FromPrimitive, NumCast};
 use num_traits::Num;
-use std::marker::PhantomData;
+use std::{fmt, hash, marker::PhantomData};
 
 pub type Image<T, C> = ImageBase<OwnedRepr<T>, C>;
 pub type ImageView<'a, T, C> = ImageBase<ViewRepr<&'a T>, C>;
@@ -158,6 +158,58 @@ where
     }
 }
 
+impl<T, U, C> fmt::Debug for ImageBase<U, C>
+where
+    U: Data<Elem = T>,
+    T: fmt::Debug,
+    C: ColourModel,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "ColourModel={:?} Data={:?}", self.model, self.data)?;
+        Ok(())
+    }
+}
+
+impl<T, U, C> PartialEq<ImageBase<U, C>> for ImageBase<U, C>
+where
+    U: Data<Elem = T>,
+    T: PartialEq,
+    C: ColourModel,
+{
+    fn eq(&self, other: &Self) -> bool {
+        self.model == other.model && self.data == other.data
+    }
+}
+
+impl<S, C> Clone for ImageBase<S, C>
+where
+    S: RawDataClone + Data,
+    C: ColourModel,
+{
+    fn clone(&self) -> Self {
+        Self {
+            data: self.data.clone(),
+            model: PhantomData,
+        }
+    }
+
+    fn clone_from(&mut self, other: &Self) {
+        self.data.clone_from(&other.data)
+    }
+}
+
+impl<'a, S, C> hash::Hash for ImageBase<S, C>
+where
+    S: Data,
+    S::Elem: hash::Hash,
+    C: ColourModel,
+{
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        self.model.hash(state);
+        self.data.hash(state);
+    }
+}
+
 /// Returns a normalised pixel value or 0 if it can't convert the types.
 /// This should never fail if your types are good.
 pub fn normalise_pixel_value<T>(t: T) -> f64
diff --git a/src/format/mod.rs b/src/format/mod.rs
index c496ec4..f3c5c8a 100644
--- a/src/format/mod.rs
+++ b/src/format/mod.rs
@@ -32,7 +32,7 @@ where
 }
 
 /// Trait for an image decoder, use this to get an image from a byte stream
-pub trait Decoder<T, U, C>
+pub trait Decoder<T, C>
 where
     T: Copy
         + Clone
diff --git a/src/format/netpbm.rs b/src/format/netpbm.rs
index 1da8bea..a87e6f5 100644
--- a/src/format/netpbm.rs
+++ b/src/format/netpbm.rs
@@ -155,9 +155,8 @@ impl PpmEncoder {
 /// The ColourModel type argument is locked to RGB - this prevents calling
 /// RGB::into::<RGB>() unnecessarily which is unavoidable until trait specialisation is
 /// stabilised.
-impl<T, U> Decoder<T, U, RGB> for PpmDecoder
+impl<T> Decoder<T, RGB> for PpmDecoder
 where
-    U: Data<Elem = T>,
     T: Copy
         + Clone
         + Num
diff --git a/src/processing/kernels.rs b/src/processing/kernels.rs
index 19d9faf..f7ccf63 100644
--- a/src/processing/kernels.rs
+++ b/src/processing/kernels.rs
@@ -44,7 +44,7 @@ pub struct LaplaceFilter;
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
 pub enum LaplaceType {
     /// Standard filter and the default parameter choice, for a 3x3x1 matrix it is:
-    /// ```ignore
+    /// ```text
     /// [0, -1, 0]
     /// [-1, 4, -1]
     /// [0, -1, 0]
@@ -52,7 +52,7 @@ pub enum LaplaceType {
     Standard,
     /// The diagonal filter also contains derivatives for diagonal lines and
     /// for a 3x3x1 matrix is given by:
-    /// ```ignore
+    /// ```text
     /// [-1, -1, -1]
     /// [-1, 8, -1]
     /// [-1, -1, -1]
@@ -102,7 +102,7 @@ where
 {
     /// The parameter for the Gaussian filter is the horizontal and vertical
     /// covariances to form the covariance matrix.
-    /// ```ignore
+    /// ```text
     /// [ Params[0], 0]
     /// [ 0, Params[1]]
     /// ```

From 65c268c8558f958e0177ecf18d1509037555d66c Mon Sep 17 00:00:00 2001
From: xd009642 <danielmckenna93@gmail.com>
Date: Sat, 30 Nov 2019 16:38:26 +0000
Subject: [PATCH 8/9] Update changelog

---
 CHANGELOG.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 92048cd..7a4c7ab 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,11 +6,14 @@
 * Padding strategies (`NoPadding`, `ConstantPadding`, `ZeroPadding`)
 * Threshold module with Otsu and Mean threshold algorithms
 * Image transformations and functions to create affine transform matrices
+* Type alias `Image` for `ImageBase<OwnedRepr<T>, _>` replicated old `Image` type
+* Type alias `ImageView` for `ImageBase<ViewRepr<&'a T>, _>`
 
 ### 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
+* Renamed `Image` to `ImageBase` which can take any implementor of the ndaray `Data` trait
 
 ### Removed 
 

From 52b7fb8992485eab3c7b27e588b8236f3c1fb9d9 Mon Sep 17 00:00:00 2001
From: xd009642 <danielmckenna93@gmail.com>
Date: Sat, 7 Dec 2019 11:02:53 +0000
Subject: [PATCH 9/9] Remove unnecessary Data

Also changed some types to be more idiomatic
---
 src/enhancement/histogram_equalisation.rs |  6 +++---
 src/processing/canny.rs                   |  6 +++---
 src/processing/conv.rs                    |  6 +++---
 src/processing/sobel.rs                   | 12 +++++-------
 4 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/src/enhancement/histogram_equalisation.rs b/src/enhancement/histogram_equalisation.rs
index d1e454e..dae2bdf 100644
--- a/src/enhancement/histogram_equalisation.rs
+++ b/src/enhancement/histogram_equalisation.rs
@@ -1,5 +1,5 @@
 use crate::core::*;
-use ndarray::{prelude::*, Data, DataMut};
+use ndarray::{prelude::*, DataMut};
 use ndarray_stats::{histogram::Grid, HistogramExt};
 use num_traits::cast::{FromPrimitive, ToPrimitive};
 use num_traits::{Num, NumAssignOps};
@@ -22,7 +22,7 @@ where
 
 impl<T, U> HistogramEqExt<T> for ArrayBase<U, Ix3>
 where
-    U: Data<Elem = T> + DataMut<Elem = T>,
+    U: DataMut<Elem = T>,
     T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive + PixelBound,
 {
     type Output = Array<T, Ix3>;
@@ -77,7 +77,7 @@ where
 
 impl<T, U, C> HistogramEqExt<T> for ImageBase<U, C>
 where
-    U: Data<Elem = T> + DataMut<Elem = T>,
+    U: DataMut<Elem = T>,
     T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive + PixelBound,
     C: ColourModel,
 {
diff --git a/src/processing/canny.rs b/src/processing/canny.rs
index a2d5a45..bf56327 100644
--- a/src/processing/canny.rs
+++ b/src/processing/canny.rs
@@ -1,7 +1,7 @@
 use crate::core::{ColourModel, Image, ImageBase};
 use crate::processing::*;
 use ndarray::prelude::*;
-use ndarray::{Data, DataMut, IntoDimension};
+use ndarray::{DataMut, IntoDimension};
 use num_traits::{cast::FromPrimitive, real::Real, Num, NumAssignOps};
 use std::collections::HashSet;
 use std::marker::PhantomData;
@@ -40,7 +40,7 @@ pub struct CannyParameters<T> {
 
 impl<T, U, C> CannyEdgeDetectorExt<T> for ImageBase<U, C>
 where
-    U: Data<Elem = T> + DataMut<Elem = T>,
+    U: DataMut<Elem = T>,
     T: Copy + Clone + FromPrimitive + Real + Num + NumAssignOps,
     C: ColourModel,
 {
@@ -57,7 +57,7 @@ where
 
 impl<T, U> CannyEdgeDetectorExt<T> for ArrayBase<U, Ix3>
 where
-    U: Data<Elem = T> + DataMut<Elem = T>,
+    U: DataMut<Elem = T>,
     T: Copy + Clone + FromPrimitive + Real + Num + NumAssignOps,
 {
     type Output = Array3<bool>;
diff --git a/src/processing/conv.rs b/src/processing/conv.rs
index 4794127..14f53dd 100644
--- a/src/processing/conv.rs
+++ b/src/processing/conv.rs
@@ -2,7 +2,7 @@ use crate::core::padding::*;
 use crate::core::{ColourModel, Image, ImageBase};
 use crate::processing::Error;
 use ndarray::prelude::*;
-use ndarray::{s, Data, DataMut, Zip};
+use ndarray::{s, DataMut, Zip};
 use num_traits::{Num, NumAssignOps};
 use std::marker::PhantomData;
 use std::marker::Sized;
@@ -47,7 +47,7 @@ fn kernel_centre(rows: usize, cols: usize) -> (usize, usize) {
 
 impl<T, U> ConvolutionExt for ArrayBase<U, Ix3>
 where
-    U: Data<Elem = T> + DataMut<Elem = T>,
+    U: DataMut<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps,
 {
     type Data = T;
@@ -104,7 +104,7 @@ where
 
 impl<T, U, C> ConvolutionExt for ImageBase<U, C>
 where
-    U: Data<Elem = T> + DataMut<Elem = T>,
+    U: DataMut<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps,
     C: ColourModel,
 {
diff --git a/src/processing/sobel.rs b/src/processing/sobel.rs
index 812756b..0842fc4 100644
--- a/src/processing/sobel.rs
+++ b/src/processing/sobel.rs
@@ -1,7 +1,7 @@
 use crate::core::*;
 use crate::processing::*;
 use core::ops::Neg;
-use ndarray::{prelude::*, Data, DataMut, OwnedRepr};
+use ndarray::{prelude::*, DataMut, OwnedRepr};
 use num_traits::{cast::FromPrimitive, real::Real, Num, NumAssignOps};
 use std::marker::Sized;
 
@@ -20,11 +20,9 @@ where
     fn full_sobel(&self) -> Result<(Self::Output, Self::Output), Error>;
 }
 
-fn get_edge_images<T, U>(
-    mat: &ArrayBase<U, Ix3>,
-) -> Result<(ArrayBase<OwnedRepr<T>, Ix3>, ArrayBase<OwnedRepr<T>, Ix3>), Error>
+fn get_edge_images<T, U>(mat: &ArrayBase<U, Ix3>) -> Result<(Array3<T>, Array3<T>), Error>
 where
-    U: Data<Elem = T> + DataMut<Elem = T>,
+    U: DataMut<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps + Neg<Output = T> + FromPrimitive + Real,
 {
     let v_temp: Array3<T> = SobelFilter::build_with_params(Orientation::Vertical).unwrap();
@@ -41,7 +39,7 @@ where
 
 impl<T, U> SobelExt for ArrayBase<U, Ix3>
 where
-    U: Data<Elem = T> + DataMut<Elem = T>,
+    U: DataMut<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps + Neg<Output = T> + FromPrimitive + Real,
 {
     type Output = ArrayBase<OwnedRepr<T>, Ix3>;
@@ -77,7 +75,7 @@ where
 
 impl<T, U, C> SobelExt for ImageBase<U, C>
 where
-    U: Data<Elem = T> + DataMut<Elem = T>,
+    U: DataMut<Elem = T>,
     T: Copy + Clone + Num + NumAssignOps + Neg<Output = T> + FromPrimitive + Real,
     C: ColourModel,
 {