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

use image::{ImageBuffer, Rgb};

pub type Frame = Vec<u8>;
pub type FrameBuffer = ImageBuffer<Rgb<u8>, Frame>;

/// Converts RGB pixels to a 128x64 SSD1306 OLED byte vector.
///
/// `brightness_threshold` is used to determine if a pixel is black or white.
///
/// If the brightness of a pixel is above the given threshold the pixel becomes white, else it becomes black.
///
/// Example
///
/// ```ignore
/// use image_to_oled::to_oled_bytes;
///
/// let image_buffer: ImageBuffer<Rgb<u8>, Vec<u8>> =
/// ImageBuffer::from_vec(2, 2, vec![30; 12]).unwrap();
/// let bytes = to_oled_bytes(&image_buffer, 30);
/// ```
pub fn to_oled_bytes(frame_buffer: &FrameBuffer, brightness_threshold: u8) -> Vec<u8> {
    let resized_img =
        image::imageops::resize(frame_buffer, 128, 64, image::imageops::FilterType::Nearest);

    resized_img
        .chunks(3)
        .fold(
            (0, 0, 7_i32, resized_img.len(), Vec::<u8>::new()),
            |(mut number, mut i, mut byte_index, pixels_len, mut oled_frame), rgb| {
                // Get the average of the RGB while preventing overflow
                let avg = rgb.iter().map(|x| *x as u16).sum::<u16>() / 3;

                if avg > brightness_threshold.into() {
                    number += 2_u8.pow(byte_index as u32);
                }

                byte_index -= 1;

                // if this was the last pixel of a row or the last pixel of the
                // image, fill up the rest of our byte with zeros so it always contains 8 bits
                if (i != 0 && (((i / 3) + 1) % (128)) == 0) || (i == (pixels_len - 3)) {
                    byte_index = -1;
                }

                // When there are 8 bits push into Vec and reset counts
                if byte_index < 0 {
                    oled_frame.push(number);
                    number = 0;
                    byte_index = 7;
                }

                i += 3;

                (number, i, byte_index, pixels_len, oled_frame)
            },
        )
        .4
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_returns_a_byte_vec_of_size_1024_for_any_size_frame_buffer() {
        for i in [1, 4, 8, 16, 200, 400, 1000, 10000] {
            let frame_buffer: ImageBuffer<Rgb<u8>, Vec<u8>> =
                ImageBuffer::from_vec(i, i, vec![0; (i * i * 3) as usize]).unwrap();
            let result = to_oled_bytes(&frame_buffer, 20);

            assert_eq!(result.len(), 1024);
        }
    }

    #[test]
    fn it_uses_brightness_threshold_to_determine_number() {
        let frame_buffer: ImageBuffer<Rgb<u8>, Vec<u8>> =
            ImageBuffer::from_vec(2, 2, vec![30; 12]).unwrap();
        let black_results = to_oled_bytes(&frame_buffer, 30);

        assert_eq!(black_results, vec![0; 1024]);
        assert_eq!(black_results.len(), 1024);

        let white_results = to_oled_bytes(&frame_buffer, 20);

        assert_eq!(white_results, vec![255; 1024]);
        assert_eq!(white_results.len(), 1024);
    }

    #[test]
    fn it_does_not_overflow_when_computing_average() {
        let frame_buffer: ImageBuffer<Rgb<u8>, Vec<u8>> =
            ImageBuffer::from_vec(640, 480, vec![255; (1024 * 1024 * 3) as usize]).unwrap();
        let results = to_oled_bytes(&frame_buffer, 30);

        assert_eq!(results, vec![255; 1024]);
        assert_eq!(results.len(), 1024);
    }
}