mtb-align 0.1.0

Median threshold bitmap alignment for handheld HDR exposures
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

/// A single-channel 8-bit image: row-major samples carried with their dimensions.
#[derive(Clone)]
pub struct Gray {
    data: Vec<u8>,
    width: usize,
    height: usize,
}

impl Gray {
    /// Panics unless `data.len() == width * height`.
    pub fn from_vec(data: Vec<u8>, width: usize, height: usize) -> Self {
        assert_eq!(
            data.len(),
            width * height,
            "{width}x{height} needs {} samples, got {}",
            width * height,
            data.len()
        );
        Self {
            data,
            width,
            height,
        }
    }

    /// Interleaved 8-bit RGB flattened with the paper's weights, which sum to
    /// exactly 256. Ward notes the green channel alone works as well.
    ///
    /// Panics unless `rgb.len() == width * height * 3`.
    pub fn from_rgb(rgb: &[u8], width: usize, height: usize) -> Self {
        assert_eq!(
            rgb.len(),
            width * height * 3,
            "{width}x{height} needs {} samples, got {}",
            width * height * 3,
            rgb.len()
        );

        let data = rgb
            .chunks_exact(3)
            .map(|pixel| {
                let (red, green, blue) = (pixel[0] as u32, pixel[1] as u32, pixel[2] as u32);
                ((54 * red + 183 * green + 19 * blue) / 256) as u8
            })
            .collect();

        Self {
            data,
            width,
            height,
        }
    }

    pub fn width(&self) -> usize {
        self.width
    }

    pub fn height(&self) -> usize {
        self.height
    }

    pub fn as_slice(&self) -> &[u8] {
        &self.data
    }

    pub fn sample(&self, x: usize, y: usize) -> u8 {
        self.data[y * self.width + x]
    }
}

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

    #[test]
    fn from_vec_carries_samples_and_dimensions() {
        let gray = Gray::from_vec(vec![1, 2, 3, 4, 5, 6], 3, 2);

        assert_eq!(gray.width(), 3);
        assert_eq!(gray.height(), 2);
        assert_eq!(gray.as_slice(), &[1, 2, 3, 4, 5, 6]);
    }

    #[test]
    #[should_panic(expected = "3x2 needs 6 samples, got 5")]
    fn from_vec_rejects_a_length_that_contradicts_the_dimensions() {
        Gray::from_vec(vec![1, 2, 3, 4, 5], 3, 2);
    }

    #[test]
    fn sample_reads_row_major() {
        let gray = Gray::from_vec(vec![1, 2, 3, 4, 5, 6], 3, 2);

        assert_eq!(gray.sample(0, 0), 1);
        assert_eq!(gray.sample(2, 0), 3);
        assert_eq!(gray.sample(0, 1), 4);
        assert_eq!(gray.sample(2, 1), 6);
    }

    #[test]
    fn from_rgb_maps_white_to_full_scale_and_black_to_zero() {
        let gray = Gray::from_rgb(&[255, 255, 255, 0, 0, 0], 2, 1);

        assert_eq!(gray.as_slice(), &[255, 0]);
    }

    #[test]
    fn from_rgb_weights_the_channels_as_the_paper_does() {
        let gray = Gray::from_rgb(&[255, 0, 0, 0, 255, 0, 0, 0, 255], 3, 1);

        assert_eq!(gray.as_slice(), &[53, 182, 18]);
    }

    #[test]
    #[should_panic(expected = "2x1 needs 6 samples, got 5")]
    fn from_rgb_rejects_a_length_that_contradicts_the_dimensions() {
        Gray::from_rgb(&[1, 2, 3, 4, 5], 2, 1);
    }
}