Merge branch 'develop'

Author: xd009642

.github/dependabot.yml

@@ -0,0 +1,25 @@
+version: 2
+updates:
+- package-ecosystem: cargo
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10
+  target-branch: develop
+  ignore:
+  - dependency-name: ndarray-rand
+    versions:
+    - 0.13.0
+    - 0.14.0
+  - dependency-name: ndarray-linalg
+    versions:
+    - 0.13.0
+  - dependency-name: rand
+    versions:
+    - 0.8.0
+  - dependency-name: ndarray-stats
+    versions:
+    - 0.4.0
+  - dependency-name: ndarray
+    versions:
+    - 0.14.0

.github/workflows/ci.yml

@@ -0,0 +1,40 @@
+name: Build
+on:
+  push:
+    branches:
+      - "*"
+  pull_request:
+jobs:
+  linux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        version:
+          - stable
+          - beta
+          - nightly 
+        target:
+          - x86_64-unknown-linux-gnu
+          - x86_64-unknown-linux-musl
+      fail-fast: false
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}
+          override: true
+          components: rustfmt
+      - name: build
+        run: |
+          cargo check --no-default-features
+          cargo check --all-features
+      - name: test
+        run: |
+          cargo test 
+      - name: check formatting
+        run: cargo fmt -- --check
+      - name: code-coverage
+        run: |
+          cargo install cargo-tarpaulin --force --git https://github.com/xd009642/tarpaulin --branch develop
+          cargo tarpaulin --force-clean --coveralls ${{ secrets.COVERALLS_TOKEN }}
+        if: matrix.target == 'x86_64-unknown-linux-gnu' && matrix.version == 'nightly'

.travis.yml

@@ -10,17 +10,25 @@ keywords = ["image", "vision", "image-processing"]
 categories = ["science", "science::robotics", "multimedia", "multimedia::images", "graphics"]
 edition = "2018"
 
+[features]
+default = ["enhancement", "format", "morphology", "processing", "transform"]
+enhancement = []
+format = []
+morphology = []
+processing = []
+transform =["ndarray-linalg"]
+
 [dependencies]
-ndarray = { version = "0.13", default-features = false }
-ndarray-stats = { version = "0.3", default-features = false }
-ndarray-linalg = { version = "0.12", default-features = false }
-noisy_float = { version = "0.1", default-features = false }
+ndarray = { version = "0.15", default-features = false }
+ndarray-stats = { version = "0.5", default-features = false }
+ndarray-linalg = { version = "0.14", default-features = false, optional = true }
+noisy_float = { version = "0.2", default-features = false }
 num-traits = { version = "0.2", default-features = false }
 
 [dev-dependencies]
-ndarray-rand = "0.11.0"
-rand = "0.7"
+ndarray-rand = "0.14.0"
+rand = "0.8"
 assert_approx_eq = "1.1.0"
-noisy_float = "0.1.11"
+noisy_float = "0.2"
 png = "0.16"
-ndarray-linalg = { version = "0.12", features = ["intel-mkl"] }
+ndarray-linalg = { version = "0.14", features = ["intel-mkl"] }

Cargo.toml

@@ -18,4 +18,11 @@ See the examples and tests for basic usage.
 * Sobel operator
 * Canny Edge Detection
 * Histogram Equalisation
+* Thresholding (basic, mean, Otsu)
 * Encoding and decoding PPM (binary or plaintext)
+
+# Performance 
+
+Not a lot of work has been put towards performance yet but a rudimentary
+benchmarking project exists [here](https://github.com/xd009642/ndarray-vision-benchmarking)
+for comparative benchmarks against other image processing libraries in rust.

README.md

@@ -199,7 +199,7 @@ where
         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| {
+        Zip::indexed(window).for_each(|(i, j, _), pix| {
             let red = pix[[0, 0, 0]];
             let green = pix[[0, 0, 1]];
             let blue = pix[[0, 0, 2]];
@@ -228,7 +228,7 @@ where
         let mut res = Array3::<T>::zeros((image.rows(), image.cols(), RGB::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
-        Zip::indexed(window).apply(|(i, j, _), pix| {
+        Zip::indexed(window).for_each(|(i, j, _), pix| {
             let h = pix[[0, 0, 0]];
             let s = pix[[0, 0, 1]];
             let v = pix[[0, 0, 2]];
@@ -257,7 +257,7 @@ where
         let mut res = Array3::<T>::zeros((image.rows(), image.cols(), Gray::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
-        Zip::indexed(window).apply(|(i, j, _), pix| {
+        Zip::indexed(window).for_each(|(i, j, _), pix| {
             let r = normalise_pixel_value(pix[[0, 0, 0]]);
             let g = normalise_pixel_value(pix[[0, 0, 1]]);
             let b = normalise_pixel_value(pix[[0, 0, 2]]);
@@ -288,7 +288,7 @@ where
         let mut res = Array3::<T>::zeros((image.rows(), image.cols(), RGB::channels()));
         let window = image.data.windows((1, 1, image.channels()));
 
-        Zip::indexed(window).apply(|(i, j, _), pix| {
+        Zip::indexed(window).for_each(|(i, j, _), pix| {
             let gray = pix[[0, 0, 0]];
 
             res.slice_mut(s![i, j, ..])
@@ -321,7 +321,7 @@ where
             [0.0139322, 0.0971045, 0.7141733],
         ]);
 
-        Zip::indexed(window).apply(|(i, j, _), pix| {
+        Zip::indexed(window).for_each(|(i, j, _), pix| {
             let pixel = pix
                 .index_axis(Axis(0), 0)
                 .index_axis(Axis(0), 0)
@@ -360,7 +360,7 @@ where
             [0.0719453, -0.2289914, 1.4052427],
         ]);
 
-        Zip::indexed(window).apply(|(i, j, _), pix| {
+        Zip::indexed(window).for_each(|(i, j, _), pix| {
             let pixel = pix
                 .index_axis(Axis(0), 0)
                 .index_axis(Axis(0), 0)

src/core/colour_models.rs

@@ -3,7 +3,6 @@ use ndarray::{prelude::*, DataMut};
 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/enhancement/histogram_equalisation.rs

@@ -28,13 +28,18 @@
 /// The core of `ndarray-vision` contains the `Image` type and colour models
 pub mod core;
 /// Image enhancement intrinsics and algorithms
+#[cfg(feature = "enhancement")]
 pub mod enhancement;
 /// Image formats - encoding and decoding images from bytes for saving and
 /// loading
+#[cfg(feature = "format")]
 pub mod format;
 /// Operations relating to morphological image processing
+#[cfg(feature = "morphology")]
 pub mod morphology;
 /// Image processing intrinsics and common filters/algorithms.
+#[cfg(feature = "processing")]
 pub mod processing;
 /// Image transforms and warping
+#[cfg(feature = "transform")]
 pub mod transform;

src/lib.rs

@@ -32,7 +32,7 @@ where
         let (ro, co) = kernel_centre(sh[0], sh[1]);
         let mut result = Self::Output::from_elem(self.dim(), false);
         if self.shape()[0] >= sh[0] && self.shape()[1] >= sh[1] {
-            Zip::indexed(self.slice(s![.., .., 0]).windows(kernel.dim())).apply(
+            Zip::indexed(self.slice(s![.., .., 0]).windows(kernel.dim())).for_each(
                 |(i, j), window| {
                     result[[i + ro, j + co, 0]] = (&kernel & &window) == kernel;
                 },
@@ -50,7 +50,7 @@ where
         let (ro, co) = kernel_centre(sh[0], sh[1]);
         let mut result = Self::Output::from_elem(self.dim(), false);
         if self.shape()[0] >= sh[0] && self.shape()[1] >= sh[1] {
-            Zip::indexed(self.slice(s![.., .., 0]).windows(kernel.dim())).apply(
+            Zip::indexed(self.slice(s![.., .., 0]).windows(kernel.dim())).for_each(
                 |(i, j), window| {
                     result[[i + ro, j + co, 0]] = (&kernel & &window).iter().any(|x| *x);
                 },

src/morphology/mod.rs

@@ -1,6 +1,7 @@
 use crate::core::padding::*;
 use crate::core::{kernel_centre, ColourModel, Image, ImageBase};
 use crate::processing::Error;
+use core::mem::MaybeUninit;
 use ndarray::prelude::*;
 use ndarray::{Data, DataMut, Zip};
 use num_traits::{Num, NumAssignOps};
@@ -118,9 +119,9 @@ where
             let shape = (self.shape()[0], self.shape()[1], self.shape()[2]);
 
             if shape.0 > 0 && shape.1 > 0 {
-                let mut result = unsafe { Self::Output::uninitialized(shape) };
+                let mut result = Self::Output::uninit(shape);
 
-                Zip::indexed(self.windows(kernel.dim())).apply(|(i, j, _), window| {
+                Zip::indexed(self.windows(kernel.dim())).for_each(|(i, j, _), window| {
                     let mut temp;
                     for channel in 0..k_s[2] {
                         temp = T::zero();
@@ -130,7 +131,8 @@ where
                             }
                         }
                         unsafe {
-                            *result.uget_mut([i + row_offset, j + col_offset, channel]) = temp;
+                            *result.uget_mut([i + row_offset, j + col_offset, channel]) =
+                                MaybeUninit::new(temp);
                         }
                     }
                 });
@@ -140,7 +142,7 @@ where
                             apply_edge_convolution(self.view(), kernel.view(), (r, c), strategy);
                         for chan in 0..k_s[2] {
                             unsafe {
-                                *result.uget_mut([r, c, chan]) = pixel[chan];
+                                *result.uget_mut([r, c, chan]) = MaybeUninit::new(pixel[chan]);
                             }
                         }
                         let bottom = shape.0 - r - 1;
@@ -152,7 +154,7 @@ where
                         );
                         for chan in 0..k_s[2] {
                             unsafe {
-                                *result.uget_mut([bottom, c, chan]) = pixel[chan];
+                                *result.uget_mut([bottom, c, chan]) = MaybeUninit::new(pixel[chan]);
                             }
                         }
                     }
@@ -163,7 +165,7 @@ where
                             apply_edge_convolution(self.view(), kernel.view(), (r, c), strategy);
                         for chan in 0..k_s[2] {
                             unsafe {
-                                *result.uget_mut([r, c, chan]) = pixel[chan];
+                                *result.uget_mut([r, c, chan]) = MaybeUninit::new(pixel[chan]);
                             }
                         }
                         let right = shape.1 - c - 1;
@@ -175,12 +177,12 @@ where
                         );
                         for chan in 0..k_s[2] {
                             unsafe {
-                                *result.uget_mut([r, right, chan]) = pixel[chan];
+                                *result.uget_mut([r, right, chan]) = MaybeUninit::new(pixel[chan]);
                             }
                         }
                     }
                 }
-                Ok(result)
+                Ok(unsafe { result.assume_init() })
             } else {
                 Err(Error::InvalidDimensions)
             }