File size: 6,341 Bytes
d5bfab8 |
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 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 |
use super::Image;
use anyhow::Context;
/// Perform a 3x3 convolution the places where the mask is non-zero.
///
/// The `image` minimum size is 3x3.
///
/// The `mask` size is equal to the `image` size minus 2 pixels.
/// - With `image.width = 8` then use `mask.width = 6`.
/// - With `image.height = 42` then use `mask.height = 40`.
///
/// The `color_for_unprocessed_pixels` is used the places where the mask is zero.
///
/// The `callback` is invoked where the mask is non-zero. The callback is provided with a 3x3 image.
///
/// This function returns an `Image` with the same size as the `mask` image.
#[allow(dead_code)]
pub fn convolution3x3_with_mask<F>(image: &Image, mask: &Image, color_for_unprocessed_pixels: u8, callback: F) -> anyhow::Result<Image>
where F: Fn(&Image) -> anyhow::Result<u8>
{
let width: u8 = image.width();
let height: u8 = image.height();
if width < 3 || height < 3 {
return Err(anyhow::anyhow!("too small image, must be 3x3 or bigger"));
}
let invalid_width: bool = (width as u16) != (mask.width() as u16) + 2;
let invalid_height: bool = (height as u16) != (mask.height() as u16) + 2;
if invalid_width || invalid_height {
return Err(anyhow::anyhow!("Size constraint not satisfied. Expected image.width == mask.width+2 AND image.height == mask.height+2"));
}
let mut result_image = Image::color(width - 2, height - 2, color_for_unprocessed_pixels);
let mut conv_bitmap = Image::zero(3, 3);
for self_y in 0..height-2 {
for self_x in 0..width-2 {
let mask_x: i32 = self_x as i32;
let mask_y: i32 = self_y as i32;
let mask_value = mask.get(mask_x, mask_y)
.ok_or_else(|| anyhow::anyhow!("mask.get({},{}) returned None", mask_x, mask_y))?;
// Ignore areas where the mask is zero
if mask_value == 0 {
continue;
}
// Perform 3x3 convolution
for conv_y in 0..3u8 {
for conv_x in 0..3u8 {
let get_x: i32 = (self_x as i32) + (conv_x as i32);
let get_y: i32 = (self_y as i32) + (conv_y as i32);
let pixel_value: u8 = image.get(get_x, get_y)
.ok_or_else(|| anyhow::anyhow!("image.get({},{}) returned None", get_x, get_y))?;
conv_bitmap.set(conv_x as i32, conv_y as i32, pixel_value)
.ok_or_else(|| anyhow::anyhow!("conv_bitmap.set({},{}) returned None", conv_x, conv_y))?;
}
}
let computed_value: u8 = callback(&conv_bitmap)
.with_context(|| format!("error in callback when computing ({},{})", self_x, self_y))?;
result_image.set(self_x as i32, self_y as i32, computed_value)
.ok_or_else(|| anyhow::anyhow!("result_image.set({},{}) returned None", self_x, self_y))?;
}
}
Ok(result_image)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::arc::ImageTryCreate;
#[test]
fn test_10000_sunshine_scenario() {
// Arrange
let pixels: Vec<u8> = vec![
1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12, 13, 14, 15,
16, 17, 18, 19, 20,
];
let input: Image = Image::try_create(5, 4, pixels).expect("image");
let mask_pixels: Vec<u8> = vec![
1, 0, 1,
0, 1, 0,
];
let input_mask: Image = Image::try_create(3, 2, mask_pixels).expect("image");
// Act
let output: Image = convolution3x3_with_mask(&input, &input_mask, 42, |bm| {
let pixel_value: u8 = match bm.get(1, 1) {
Some(value) => value,
None => {
return Err(anyhow::anyhow!("get pixel"));
}
};
Ok(pixel_value)
}).expect("image");
// Assert
let expected_pixels: Vec<u8> = vec![
7, 42, 9,
42, 13, 42,
];
let expected: Image = Image::try_create(3, 2, expected_pixels).expect("image");
assert_eq!(output, expected);
}
#[test]
fn test_20000_error_size_constraint_not_satisfied() {
// Arrange
let pixels: Vec<u8> = vec![
1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12, 13, 14, 15,
16, 17, 18, 19, 20,
];
let input: Image = Image::try_create(5, 4, pixels).expect("image");
let mask_pixels: Vec<u8> = vec![
1, 0,
0, 1,
];
let input_mask: Image = Image::try_create(2, 2, mask_pixels).expect("image");
// Act
let result = convolution3x3_with_mask(&input, &input_mask, 42, |bm| {
let pixel_value: u8 = match bm.get(1, 1) {
Some(value) => value,
None => {
return Err(anyhow::anyhow!("get pixel"));
}
};
Ok(pixel_value)
});
// Assert
let error = result.expect_err("is supposed to fail");
let message: String = format!("{:?}", error);
assert_eq!(message.contains("Size constraint not satisfied"), true);
}
#[test]
fn test_20001_error_size_constraint_not_satisfied() {
// Arrange
let pixels: Vec<u8> = vec![
1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12, 13, 14, 15,
16, 17, 18, 19, 20,
];
let input: Image = Image::try_create(5, 4, pixels).expect("image");
let mask_pixels: Vec<u8> = vec![
1, 0,
0, 1,
1, 0,
];
let input_mask: Image = Image::try_create(2, 3, mask_pixels).expect("image");
// Act
let result = convolution3x3_with_mask(&input, &input_mask, 42, |bm| {
let pixel_value: u8 = match bm.get(1, 1) {
Some(value) => value,
None => {
return Err(anyhow::anyhow!("get pixel"));
}
};
Ok(pixel_value)
});
// Assert
let error = result.expect_err("is supposed to fail");
let message: String = format!("{:?}", error);
assert_eq!(message.contains("Size constraint not satisfied"), true);
}
}
|