magic_kernel/
imagef64.rs

1use std::ops::{Index, IndexMut};
2
3use crate::kernel::ApplicationTarget;
4
5/// Buffer storing the image.
6/// All pixel values are expected to be f64.
7pub struct ImageF64 {
8    buffer: Vec<f64>,
9    channels: u8,
10    width: u32,
11    height: u32,
12}
13
14impl ImageF64 {
15    /// Creates new empty buffer with the specified number of channels,
16    /// width and heights. All pixel values will be initialized as 0.0
17    pub fn new_empty(channels: u8, width: u32, height: u32) -> Self {
18        Self {
19            buffer: vec![0.0; (channels as u32 * width * height) as usize],
20            channels,
21            width,
22            height,
23        }
24    }
25
26    /// Creates a new image from pre-defined buffer.
27    pub fn new(buffer: Vec<f64>, channels: u8, width: u32, height: u32) -> Self {
28        Self {
29            buffer,
30            channels,
31            width,
32            height,
33        }
34    }
35
36    /// Returns number of channels in the image
37    pub fn channels(&self) -> u8 {
38        self.channels
39    }
40
41    /// Returns width of an image
42    pub fn width(&self) -> u32 {
43        self.width
44    }
45
46    /// Returns height of an image
47    pub fn height(&self) -> u32 {
48        self.height
49    }
50
51    fn buffer_index(&self, (channel, x, y): (u8, u32, u32)) -> usize {
52        let channels = self.channels as u32;
53        (y * self.width * channels + x * channels + channel as u32) as usize
54    }
55}
56
57impl From<ImageF64> for Vec<f64> {
58    fn from(value: ImageF64) -> Self {
59        value.buffer
60    }
61}
62
63impl Index<(u8, u32, u32)> for ImageF64 {
64    type Output = f64;
65
66    fn index(&self, index: (u8, u32, u32)) -> &Self::Output {
67        &self.buffer[self.buffer_index(index)]
68    }
69}
70
71impl IndexMut<(u8, u32, u32)> for ImageF64 {
72    fn index_mut(&mut self, index: (u8, u32, u32)) -> &mut Self::Output {
73        let index = self.buffer_index(index);
74        &mut self.buffer[index]
75    }
76}
77
78pub(crate) struct Row<'a> {
79    pub in_: &'a ImageF64,
80    pub out: &'a mut ImageF64,
81    pub channel: u8,
82    pub y: u32,
83}
84
85impl<'a> ApplicationTarget for Row<'a> {
86    fn read(&self, x: u32) -> f64 {
87        self.in_[(self.channel, x, self.y)]
88    }
89
90    fn write(&mut self, x: u32, value: f64) {
91        self.out[(self.channel, x, self.y)] = value
92    }
93}
94
95pub(crate) struct Column<'a> {
96    pub in_: &'a ImageF64,
97    pub out: &'a mut ImageF64,
98    pub channel: u8,
99    pub x: u32,
100}
101
102impl<'a> ApplicationTarget for Column<'a> {
103    fn read(&self, y: u32) -> f64 {
104        self.in_[(self.channel, self.x, y)]
105    }
106
107    fn write(&mut self, y: u32, value: f64) {
108        self.out[(self.channel, self.x, y)] = value
109    }
110}