Merge pull request #16 from stefan-k/ndarray_0.13

update of ndarray, ndarray-stats, ndarray-rand and rand

Author: xd009642

Cargo.toml

@@ -11,13 +11,13 @@ categories = ["Science", "Multimedia"]
 edition = "2018"
 
 [dependencies]
-ndarray = "0.12"
-ndarray-stats = "0.2"
+ndarray = "0.13"
+ndarray-stats = "0.3"
 noisy_float = "0.1"
 num-traits = "0.2"
 
 [dev-dependencies]
-ndarray-rand = "0.9.0"
-rand = "0.6.5"
+ndarray-rand = "0.11.0"
+rand = "0.7"
 assert_approx_eq = "1.1.0"
 noisy_float = "0.1.11"

src/enhancement/histogram_equalisation.rs

@@ -3,6 +3,7 @@ use ndarray::prelude::*;
 use ndarray_stats::{histogram::Grid, HistogramExt};
 use num_traits::cast::{FromPrimitive, ToPrimitive};
 use num_traits::{Num, NumAssignOps};
+use std::iter::FromIterator;
 
 /// Extension trait to implement histogram equalisation on other types
 pub trait HistogramEqExt<A>

src/processing/filter.rs

@@ -5,6 +5,7 @@ use ndarray_stats::interpolate::*;
 use ndarray_stats::Quantile1dExt;
 use noisy_float::types::n64;
 use num_traits::{FromPrimitive, Num, ToPrimitive};
+use std::iter::FromIterator;
 use std::marker::PhantomData;
 
 /// Median filter, given a region to move over the image, each pixel is given
@@ -32,7 +33,7 @@ where
         let mut result = Array3::<T>::zeros(self.dim());
         Zip::indexed(self.windows(region)).apply(|(i, j, k), window| {
             let mut flat_window = Array::from_iter(window.iter()).mapv(|x| *x);
-            if let Ok(v) = flat_window.quantile_mut(n64(0.5f64), &Linear{}) {
+            if let Ok(v) = flat_window.quantile_mut(n64(0.5f64), &Linear {}) {
                 result
                     .get_mut([i + r_offset, j + c_offset, k])
                     .map(|r| *r = v);

src/processing/kernels.rs

@@ -304,13 +304,14 @@ mod tests {
 
     #[test]
     fn test_laplace_filters() {
-        let standard = LaplaceFilter::build().unwrap();
+        let standard: Array3<i64> = LaplaceFilter::build().unwrap();
         assert_eq!(
             standard,
             arr3(&[[[0], [-1], [0]], [[-1], [4], [-1]], [[0], [-1], [0]]])
         );
 
-        let standard = LaplaceFilter::build_with_params(LaplaceType::Diagonal).unwrap();
+        let standard: Array3<i64> =
+            LaplaceFilter::build_with_params(LaplaceType::Diagonal).unwrap();
         assert_eq!(
             standard,
             arr3(&[[[-1], [-1], [-1]], [[-1], [8], [-1]], [[-1], [-1], [-1]]])

src/processing/threshold.rs

@@ -1,13 +1,14 @@
+use crate::core::PixelBound;
 use crate::core::{ColourModel, Image};
-use crate::core::{PixelBound};
 use crate::processing::*;
 use ndarray::prelude::*;
-use num_traits::cast::{FromPrimitive};
-use num_traits::cast::{ToPrimitive};
-use ndarray_stats::QuantileExt;
+use ndarray_stats::histogram::{Bins, Edges, Grid};
 use ndarray_stats::HistogramExt;
-use ndarray_stats::histogram::{Grid, Bins, Edges};
+use ndarray_stats::QuantileExt;
+use num_traits::cast::FromPrimitive;
+use num_traits::cast::ToPrimitive;
 use num_traits::{Num, NumAssignOps};
+use std::iter::FromIterator;
 use std::marker::PhantomData;
 
 // Development
@@ -16,14 +17,13 @@ use assert_approx_eq::assert_approx_eq;
 #[cfg(test)]
 use noisy_float::types::n64;
 
-
 /// Runs the Otsu Thresholding algorithm on a type T
 pub trait ThresholdOtsuExt<T> {
     /// Output type, this is different as Otsu outputs a binary image
     type Output;
 
-    /// Run the Otsu threshold detection algorithm with the 
-    /// given parameters. Due to Otsu being specified as working 
+    /// Run the Otsu threshold detection algorithm with the
+    /// given parameters. Due to Otsu being specified as working
     /// on greyscale images all current implementations
     /// assume a single channel image returning an error otherwise.
     fn threshold_otsu(&self) -> Result<Self::Output, Error>;
@@ -34,8 +34,8 @@ pub trait ThresholdMeanExt<T> {
     /// Output type, this is different as Otsu outputs a binary image
     type Output;
 
-    /// Run the Otsu threshold detection algorithm with the 
-    /// given parameters. Due to Otsu being specified as working 
+    /// Run the Otsu threshold detection algorithm with the
+    /// given parameters. Due to Otsu being specified as working
     /// on greyscale images all current implementations
     /// assume a single channel image returning an error otherwise.
     fn threshold_mean(&self) -> Result<Self::Output, Error>;
@@ -60,7 +60,7 @@ where
 
 impl<T> ThresholdOtsuExt<T> for Array3<T>
 where
-    T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive 
+    T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive,
 {
     type Output = Array3<bool>;
 
@@ -76,60 +76,58 @@ where
 }
 
 ///
-/// Calculates Otsu's threshold 
-/// Works per channel, but currently 
+/// Calculates Otsu's threshold
+/// Works per channel, but currently
 /// assumes grayscale (see the error above if number of channels is > 1
-/// i.e. single channel; otherwise we need to output all 3 threshold values). 
+/// 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>
 where
-    T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive 
+    T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive,
 {
     let mut threshold = 0.0;
     let n_bins = 255;
     for c in mat.axis_iter(Axis(2)) {
-        let scale_factor = (n_bins) as f64
-            /(c.max().unwrap().to_f64().unwrap()); 
+        let scale_factor = (n_bins) as f64 / (c.max().unwrap().to_f64().unwrap());
         let edges_vec: Vec<u8> = (0..n_bins).collect();
         let grid = Grid::from(vec![Bins::new(Edges::from(edges_vec))]);
-        
+
         // get the histogram
         let flat = Array::from_iter(c.iter()).insert_axis(Axis(1));
-        let flat2 = flat.mapv(
-            |x| ((*x).to_f64().unwrap() * scale_factor).to_u8().unwrap()
-        );
+        let flat2 = flat.mapv(|x| ((*x).to_f64().unwrap() * scale_factor).to_u8().unwrap());
         let hist = flat2.histogram(grid);
-        // Straight out of wikipedia: 
-        let counts = hist.counts(); 
+        // Straight out of wikipedia:
+        let counts = hist.counts();
         let total = counts.sum().to_f64().unwrap();
         let counts = Array::from_iter(counts.iter());
-        // NOTE: Could use the cdf generation for skimage-esque implementation 
-        // which entails a cumulative sum of the standard histogram 
+        // NOTE: Could use the cdf generation for skimage-esque implementation
+        // which entails a cumulative sum of the standard histogram
         let mut sum_b = 0.0;
         let mut weight_b = 0.0;
         let mut maximum = 0.0;
         let mut level = 0.0;
         let mut sum_intensity = 0.0;
-        for (index, count) in counts.indexed_iter(){
+        for (index, count) in counts.indexed_iter() {
             sum_intensity += (index as f64) * (*count).to_f64().unwrap();
         }
-        for (index, count) in counts.indexed_iter(){
+        for (index, count) in counts.indexed_iter() {
             weight_b = weight_b + count.to_f64().unwrap();
-            sum_b = sum_b + (index as f64)* count.to_f64().unwrap();
+            sum_b = sum_b + (index as f64) * count.to_f64().unwrap();
             let weight_f = total - weight_b;
-            if (weight_b > 0.0) && (weight_f > 0.0){
+            if (weight_b > 0.0) && (weight_f > 0.0) {
                 let mean_f = (sum_intensity - sum_b) / weight_f;
-                let val = weight_b * weight_f 
-			* ((sum_b / weight_b) - mean_f) 
-			* ((sum_b / weight_b) - mean_f);
-                if val > maximum{
+                let val = weight_b
+                    * weight_f
+                    * ((sum_b / weight_b) - mean_f)
+                    * ((sum_b / weight_b) - mean_f);
+                if val > maximum {
                     level = 1.0 + (index as f64);
                     maximum = val;
                 }
             }
         }
-        threshold = level as f64 / scale_factor; 
+        threshold = level as f64 / scale_factor;
     }
     Ok(threshold)
 }
@@ -153,7 +151,7 @@ where
 
 impl<T> ThresholdMeanExt<T> for Array3<T>
 where
-    T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive 
+    T: Copy + Clone + Ord + Num + NumAssignOps + ToPrimitive + FromPrimitive,
 {
     type Output = Array3<bool>;
 
@@ -170,12 +168,11 @@ where
 
 fn calculate_threshold_mean<T>(array: &Array3<T>) -> Result<f64, Error>
 where
-    T: Copy + Clone + Num + NumAssignOps + ToPrimitive + FromPrimitive 
+    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>
 where
     T: Copy + Clone + Num + NumAssignOps + ToPrimitive + FromPrimitive,
@@ -184,7 +181,6 @@ where
     result
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -208,24 +204,20 @@ mod tests {
 
         assert_eq!(result, expected);
     }
-    
+
     #[test]
     fn threshold_calculate_threshold_otsu_ints() {
-        let data = arr3(&[
-            [[2], [4], [0]],
-            [[7], [5], [8]],
-            [[1], [6], [0]],
-        ]);
+        let data = arr3(&[[[2], [4], [0]], [[7], [5], [8]], [[1], [6], [0]]]);
         let result = calculate_threshold_otsu(&data).unwrap();
         println!("Done {}", result);
 
-        // Calculated using Python's skimage.filters.threshold_otsu 
-        // on int input array. Float array returns 2.0156... 
+        // Calculated using Python's skimage.filters.threshold_otsu
+        // on int input array. Float array returns 2.0156...
         let expected = 2.0;
 
         assert_approx_eq!(result, expected, 5e-1);
     }
-    
+
     #[test]
     fn threshold_calculate_threshold_otsu_floats() {
         let data = arr3(&[
@@ -236,27 +228,23 @@ mod tests {
 
         let result = calculate_threshold_otsu(&data).unwrap();
 
-        // Calculated using Python's skimage.filters.threshold_otsu 
-        // on int input array. Float array returns 2.0156... 
+        // Calculated using Python's skimage.filters.threshold_otsu
+        // on int input array. Float array returns 2.0156...
         let expected = 2.0156;
 
         assert_approx_eq!(result, expected, 5e-1);
     }
-    
+
     #[test]
     fn threshold_calculate_threshold_mean_ints() {
-        let data = arr3(&[
-            [[4], [4], [4]],
-            [[5], [5], [5]],
-            [[6], [6], [6]],
-        ]);
+        let data = arr3(&[[[4], [4], [4]], [[5], [5], [5]], [[6], [6], [6]]]);
 
         let result = calculate_threshold_mean(&data).unwrap();
         let expected = 5.0;
-        
+
         assert_approx_eq!(result, expected, 1e-16);
     }
-    
+
     #[test]
     fn threshold_calculate_threshold_mean_floats() {
         let data = arr3(&[
@@ -267,7 +255,7 @@ mod tests {
 
         let result = calculate_threshold_mean(&data).unwrap();
         let expected = 5.0;
-        
+
         assert_approx_eq!(result, expected, 1e-16);
     }
 }