average_color 0.1.2

Get the average color of an image
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

pub mod enums;
pub mod utils;

use crate::enums::Rgb;
use async_std::path::Path;
use image::{DynamicImage, GenericImageView};

extern crate image;

pub type AverageColor = Option<Rgb>;
pub type AverageColorResult = Result<AverageColor, String>;

pub async fn get_averages_colors(paths: &[String]) -> Vec<AverageColorResult> {
    let mut results = vec![];

    let tasks = utils::join_parallel(paths.into_iter().map(|path| {
        async fn extract_average(path: String) -> AverageColorResult {
            get_average_color(&path).await
        }

        extract_average(path.to_string())
    }))
    .await;

    for task in tasks {
        results.push(task)
    }

    results
}

pub async fn get_average_color(path: &String) -> AverageColorResult {
    let file_exists = Path::new(&path).exists().await;

    if file_exists {
        let (img_type, ext) = utils::parse_path(&path);

        return match img_type {
            Some(_) => match image::open(&path) {
                Ok(img) => Ok(calculate_average(&img)),
                Err(err) => Err(format!("{:?}", err)),
            },
            None => Err(format!("Unsupported image type: {}", ext.unwrap_or(""))),
        };
    } else {
        return Err("File does not exists!".into());
    }
}

pub fn calculate_average(img: &DynamicImage) -> AverageColor {
    // See: https://stackoverflow.com/a/2541680/6784368

    let (width, height) = img.dimensions();

    let block_size = 5;
    let mut x: u32 = 0;
    let mut y: u32 = 0;
    let mut rgb: [u32; 3] = [0, 0, 0];
    let mut count = 0;

    loop {
        let (x1, y1) = next_coordinates(width, x, y, block_size);

        if y1 > height - 1 {
            break;
        }

        let pixel = img.get_pixel(x1, y1);

        rgb[0] += pixel.0[0] as u32;
        rgb[1] += pixel.0[1] as u32;
        rgb[2] += pixel.0[2] as u32;

        count += 1;
        x = x1;
        y = y1;
    }

    rgb[0] = !!(rgb[0] / count);
    rgb[1] = !!(rgb[1] / count);
    rgb[2] = !!(rgb[2] / count);

    Some(Rgb {
        r: rgb[0] as u8,
        g: rgb[1] as u8,
        b: rgb[2] as u8,
    })
}

fn next_coordinates(width: u32, x: u32, y: u32, block_size: u32) -> (u32, u32) {
    let mut next_x = x;
    let mut next_y = y;
    let w = width - 1;

    if x < w && x + block_size < w {
        next_x += block_size;
    } else {
        next_x = 0;
        next_y = y + block_size;
    }

    (next_x, next_y)
}