image-ndarray 0.1.5

Zero-copy implementations for the Image crate to convert to and from ndarrays
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

[![Tests](https://ci.codeberg.org/api/badges/15489/status.svg)](https://ci.codeberg.org/repos/15489)
[![License](https://img.shields.io/crates/l/image-ndarray)](https://crates.io/crates/image-ndarray) 
[![Version](https://img.shields.io/crates/v/image-ndarray)](https://crates.io/crates/image-ndarray) 

# image-ndarray

Zero-copy implementations for the `Image` crate to convert to and from ndarrays.

Working with ndarrays allows for easy manipulation of pixel values.

While there is another crate called `ndarray-image`, that works with dedicated types.
This crate does not and implements the methods directly onto the ImageBuffer objects.

## Usage
Add the crate to your project:
```bash
cargo add image-ndarray
```

Then in your project, when you want to use the ndarrays on the images, make sure to add the prelude:
```rust
use image_ndarray::prelude::*;
```

## Example

Adding a simple value:
```rust
#[cfg(feature = "image")]
{
    use image::Rgba32FImage;
    use image_ndarray::prelude::*;

    let mut my_image = Rgba32FImage::new(1920, 1080);

    assert!(my_image.to_vec() == vec![0.0; 1920 * 1080 * 4]);

    let mut array = my_image.as_ndarray_mut();
    array += 1.0;

    assert!(my_image.to_vec() == vec![1.0; 1920 * 1080 * 4]);
}
```

Adding another image:
```rust
#[cfg(feature = "image")]
{
    use image::Rgba32FImage;
    use image_ndarray::prelude::*;

    let mut my_image = Rgba32FImage::new(1920, 1080);
    let second_image = Rgba32FImage::from_vec(1920, 1080, vec![1.0; 1920 * 1080 * 4]).unwrap();
    assert!(my_image.to_vec() == vec![0.0; 1920 * 1080 * 4]);

    let mut array = my_image.as_ndarray_mut();
    array += &second_image.as_ndarray();

    assert!(my_image.to_vec() == vec![1.0; 1920 * 1080 * 4]);
}
```


Dividing another image (just any math operation supported by [ndarray](https://docs.rs/ndarray/latest/ndarray/struct.ArrayBase.html)):
```rust
#[cfg(feature = "image")]
{
    use image::Rgba32FImage;
    use image_ndarray::prelude::*;

    let mut my_image = Rgba32FImage::from_vec(1920, 1080, vec![1.0; 1920 * 1080 * 4]).unwrap();
    let second_image = Rgba32FImage::from_vec(1920, 1080, vec![2.0; 1920 * 1080 * 4]).unwrap();
    assert!(my_image.to_vec() == vec![1.0; 1920 * 1080 * 4]);

    let mut array = my_image.as_ndarray_mut();
    array /= &second_image.as_ndarray();

    assert!(my_image.to_vec() == vec![0.5; 1920 * 1080 * 4]);
}
```

Convert image to array:
```rust 
#[cfg(feature = "image")]
{
    use image::Rgba32FImage;
    use image_ndarray::prelude::*;

    let my_image = Rgba32FImage::from_vec(1920, 1080, vec![1.0; 1920 * 1080 * 4]).unwrap();
    let array = my_image.to_ndarray();

    assert!(array.as_slice().unwrap().to_vec() == vec![1.0; 1920 * 1080 * 4]);
}
```


Or just create an image from the provided array :
```rust
#[cfg(feature = "image")]
{
    use image::Rgba32FImage;
    use image_ndarray::prelude::*;
    use ndarray::Array3;

    let array = Array3::from_elem((1080, 1920, 4), 1.0);
    let my_image = Rgba32FImage::from_ndarray(array).unwrap();

    assert!(my_image.to_vec() == vec![1.0; 1920 * 1080 * 4]);
}
```

And convert an u8 image into a f32 array:
```rust
use image_ndarray::prelude::*;
use ndarray::Array3;

let array = Array3::<u8>::from_elem((1080, 1920, 4), 255);
let float_array = array.map(|f| f.to_f32_normalized().unwrap());

let max_value = float_array.iter().cloned().fold(f32::MIN, f32::max);
assert!(max_value == 1.0);

```