image_energy 0.1.3

Library crate for calculating energy 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

use std::collections::HashMap;
use std::ops::Deref;
use std::sync::{Arc, Mutex};

use image::{DynamicImage, GenericImage, GenericImageView, Rgba};
use rayon::iter::{IntoParallelIterator, ParallelIterator};

use crate::energy_of_image::pixel::{get_bottom, get_left, get_right, get_top};

/// This returns the energy of the image, but scaled to visualize as an image
pub fn get_energy_image(image: &DynamicImage) -> DynamicImage {
    let mut max: u32 = 0;
    let mut min: u32 = u32::MAX;
    let mut energies = HashMap::new();
    let mut energy_image = image.clone();
    image.pixels().for_each(|(x, y, _)| {
        let energy = calculate_energy_at(&x, &y, &image);
        if energy > max {
            max = energy;
        }
        if energy < min {
            min = energy;
        }
        energies.insert((x, y), energy);
    });

    energies.iter().for_each(|((x, y), energy)| {
        let scaled_energy = scale(energy, max, min);
        let rgba = Rgba::from([scaled_energy, scaled_energy, scaled_energy, 255]);
        energy_image.put_pixel(*x, *y, rgba);
    });
    energy_image
}

//This returns the energy_grid of the image in a HashMap
pub fn get_energy_grid(image: &DynamicImage) -> HashMap<(u32, u32), u32> {
    (0..image.height()).into_par_iter().flat_map(|y| {
        (0..image.width()).into_par_iter().map(|x| ((x,y), calculate_energy_at(&x, &y, image))).collect::<HashMap<(u32,u32), u32>>()
    }).collect()

}


fn calculate_energy_at(x: &u32, y: &u32, image: &DynamicImage) -> u32 {
    let left = get_left(x, y, &image);
    let right = get_right(x, y, &image);
    let top = get_top(x, y, &image);
    let bottom = get_bottom(x, y, &image);
    let dx = calculate_energy(left, right);
    let dy = calculate_energy(top, bottom);
    dx + dy
}

fn calculate_energy(option_pixel1: Option<Rgba<u8>>, option_pixel2: Option<Rgba<u8>>) -> u32 {
    match option_pixel1 {
        Some(pixel1) => {
            match option_pixel2 {
                Some(pixel2) => {
                    let rgb1 = pixel1.0;
                    let rgb2 = pixel2.0;
                    let dr: u32 = ((rgb1[0] as i32 - rgb2[0] as i32) * (rgb1[0] as i32 - rgb2[0] as i32)) as u32;
                    let dg: u32 = ((rgb1[1] as i32 - rgb2[1] as i32) * (rgb1[1] as i32 - rgb2[1] as i32)) as u32;
                    let db: u32 = ((rgb1[2] as i32 - rgb2[2] as i32) * (rgb1[2] as i32 - rgb2[2] as i32)) as u32;
                    dr + dg + db
                }
                None => {
                    let rgb1 = pixel1.0;
                    let dr: u32 = (rgb1[0] as u32) * (rgb1[0] as u32);
                    let dg: u32 = (rgb1[1] as u32) * (rgb1[1] as u32);
                    let db: u32 = (rgb1[2] as u32) * (rgb1[2] as u32);
                    dr + dg + db
                }
            }
        }
        None => {
            match option_pixel2 {
                Some(pixel2) => {
                    let rgb2 = pixel2.0;
                    let dr: u32 = (rgb2[0] as u32) * (rgb2[0] as u32);
                    let dg: u32 = (rgb2[1] as u32) * (rgb2[1] as u32);
                    let db: u32 = (rgb2[2] as u32) * (rgb2[2] as u32);
                    dr + dg + db
                }
                None => {
                    panic!("No neighbours")
                }
            }
        }
    }
}

fn scale(energy: &u32, max: u32, min: u32) -> u8 {
    (255 * (energy - min) / (max - min)) as u8
}