Hi ,

I copy & paste the Example code provided in here and then did cargo run .
Found Following Error error: linking with link.exe failed: exit code: 1120

MY Cargo.toml

Error Screen Shot

Here is the complete error Log
nd-array-vision-error.txt

Rust Version - rustc 1.57.0 (f1edd0429 2021-11-29)
Cargo Version - cargo 1.57.0 (b2e52d7ca 2021-10-21)
Operating System -Windows, version 10.0.19042 X64

I would greatly appreciate your assistance if I am missing something.

Sometimes image data might be converted into a format that doesn't follow a colour model this issue would involve implementing the Generic (or model-less) conversions. This generally involves either a straight copying of the data or adding/removing channels from the image data.

Implement histogram equalisation as part of an enhancement module: algorithm http://www.sci.utah.edu/~acoste/uou/Image/project1/Arthur_COSTE_Project_1_report.html

The image processing threshold methods are defined as traits for the ArrayBase and Image types that use the Otsu and Mean algorithms for calculating a threshold value and immediately applying the threshold. It could be useful to break out the one defined method into an "apply" and "calculate" methods, so that the threshold value could be calculated and obtained without immediately applying it to the image or array.

For example, the fn threshold_otsu would become:

...
fn threshold_calculate_otsu(&self) -> Result<f64, Error>;

fn threshold_apply_otsu(&self) -> Result<Self::Output, Error>;
...

The threshold_apply_otsu would be the same as the current threshold_otsu method, but the threshold_calculate_otsu method would simply return the threshold value, which could be used to do additional image processing or explicitly applied to an image using the new-ish threshold_apply method from PR #56.

With all the permutations of reflection should just a simple X, Y reflection just be supported for more complicated ones like reflecting along the line y=-x? Answer this question and implement the decision

Currently just using Ix3 as image dimensions to easily allow other colour channels. Usability may be improved by making it easy to drop the extra dimension when it's just a single channel image

A lot of my extension traits are using ArrayN<T> instead of ArrayBase<U, _> where U: Data<Elem=T>. Change things into using the Data trait and see if that adds an easy way to have the core Image struct not own it's data

As per rust-ndarray/ndarray#804 the usage is incorrect, potential UB there 😢

Just proves the point, don't mess with unsafe even when it seems safe

Bit of feature creep, as I've got sobel operator and gaussian blur I might as well implement a Canny Edge Detector while waiting for the blocker on #2 to close http://fourier.eng.hmc.edu/e161/lectures/canny/node1.html

Using:

let y = Array3::zeros((100, 100, 3));
let x = Image::from_data(y);

I get:

error[E0308]: mismatched types
   --> src/main.rs:347:30
    |
347 |     let x = Image::from_data(y);
    |                              ^ expected struct `ndarray::ArrayBase`, found a different struct `ndarray::ArrayBase`
    |
    = note: expected struct `ndarray::ArrayBase<ndarray::OwnedRepr<_>, ndarray::dimension::dim::Dim<[usize; 3]>>`
               found struct `ndarray::ArrayBase<ndarray::OwnedRepr<_>, ndarray::Dim<[usize; 3]>>`
    = note: perhaps two different versions of crate `ndarray` are being used?

Cargo.toml:

[dependencies]
ndarray = { version = "0.13.1", features = ["blas"] }
ndarray-linalg = { version = "0.12"}
ndarray-stats = { version = "0.3"}
ndarray-vision = { version = "0.1.1"}
blas-src = { version = "0.2.0", default-features = false, features = ["openblas"] }
openblas-src = { version = "0.6.0", default-features = false, features = ["cblas", "system"] }
fftw-src = { version = "0.3.0"}
fftw = { version = "0.6.0"}

Downgrading ndarray to 0.12 helped, but then I lost some functionality in other places, which was undesirable. Is there any way around this without downgrading?

The vertical and horizontal filters have been implemented, it's just a case of implementing something to do the following step sqrt(vert^2 +horz^2) where vert is the result of the vertical edge filter and horz is the result of the horizontal edge filter.

Started work on it, reference for implementation https://gurus.pyimagesearch.com/lesson-sample-histogram-of-oriented-gradients-and-car-logo-recognition/

It seems that docs are failing for the latest release 0.5.0, and for a lot of the previous releases as well. The last version for which the docs are visible is 0.1.1

Adaptive Histogram Equalisation (AHE) and as a stretch contrast-limited adaptive histogram equalisation (CLAHE)

I wanted to use this library for a CNN. After a quick look at the source, it doesn't look like you use the the FFT algorithm for fast convolution. It is probably worth implementing.

Implement a means for Hough transforms to detect lines - or other shapes (Circles or ideally any arbitrary shape)

I was just looking up some of the documentation for this crate on docs.rs, and it looks like the build has failed for the most recent version of 0.2. I think the crates.io build has worked, though, so not sure why it's happening. Just figured you might want to know!

Add benchmarking for the crate (preferably criterion)

I found during my median filter implementation that there is some issue in ppm encoding/decoding. This may be due to 16 bit width PPMs or other extensions. Or mishandling of the format.

Issues seems to partially be down to the ppm being larger than the header suggested it should be. Which is now sorted. However, there are still some issues with this random ppm I've downloaded that I've not encountered before - but could be related to the fact it's 1 byte too large.

Implement a KernelBuilder for a laplace kernel.

Hi,

thanks for this crate!
I tried to use the convolution and I noticed that the center of the kernel is not at the actual center but rather at the top left corner. This leads to a shift of the image to the upper left proportional to the size of the kernel. Furthermore some rows at the bottom and some columns on the right appear unprocessed (probably a problem with the boundary handling). I've attached two images to illustrate the problem: one without filter:

and the same with a 15x15 pixel BoxLinearFilter:

Be able to apply affine transformations to images

• Reflection
• Scale
• Rotate
• Shear
• translate

hi, how does the resize performance compare with opencv?

I was starting to play around with this crate and others in the "ndarray family" to become more familiar with using Rust for CV and ML applications. In my adventure, I have a need to (de)serialize images to pass between processes. Constantly decoding/encoding into an image format seems excessive, but maybe this is the ultimate solution. So, I saw that the ndarray crate has an optional serde feature, but the core, ImageBase type in this crate does not implement the Serialize or Deserialize traits and there is no similar optional feature.

Is there interest in adding Serde support to this crate as a similar optional feature so ImageBase can be (de)serialized?

Doc comments for everything released in 0.1.0. Also move re-exports into a prelude file to avoid unnecessary faff at start of module docs.

Ideas for algorithms to add could come from Matlab/Scikit-image/ImageJ threshold algorithms.

To start we could add some a couple of standard ones - I've been working on mean and Otsu's method implementations.