···

       
1
       
-
       
// TODO: Better wrapper here

     

       
2
       
 
       
pub const SIZE: usize = 600;

     

       
3
       
-
       
pub type Bitmap = [[(u8, u8, u8, u8); SIZE]; SIZE];

     

       
4
       
 
       


     

       
5
       
-
       
pub fn new_bitmap() -> Bitmap {

     

       
6
       
-
       
    [[(0, 0, 0, 0); SIZE]; SIZE]

     

       
0
       
 
       

     

       
0
       
 
       

     

       
7
       
 
       
}

     

       
8
       
 
       


     

       
9
       
-
       
fn output_u8(vec: &mut Vec<u8>, n: u8) {

     

       
10
       
-
       
    vec.push(n);

     

       
11
       
-
       
}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
12
       
 
       


     

       
13
       
-
       
fn output_u16(vec: &mut Vec<u8>, n: u16) {

     

       
14
       
-
       
    vec.push(n as u8);

     

       
15
       
-
       
    vec.push((n >> 8) as u8);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
16
       
 
       
}

     

       
17
       
 
       


     

       
18
       
-
       
fn output_u32(vec: &mut Vec<u8>, n: u32) {

     

       
19
       
-
       
    vec.push(n as u8);

     

       
20
       
-
       
    vec.push((n >> 8) as u8);

     

       
21
       
-
       
    vec.push((n >> 16) as u8);

     

       
22
       
-
       
    vec.push((n >> 24) as u8);

     

       
23
       
 
       
}

     

       
24
       
 
       


     

       
25
       
-
       
pub fn to_data(bmp: &Bitmap) -> Vec<u8> {

     

       
26
       
-
       
    let mut ret = Vec::new();

     

       
27
       
-
       
    let row_padding = 3 - (3 * SIZE % 4);

     

       
28
       
-
       
    output_u16(&mut ret, 0x4d42); // BM 

     

       
29
       
-
       
    output_u32(&mut ret, (0x36 + SIZE * (3 * SIZE + row_padding)) as u32); // Size

     

       
30
       
-
       
    output_u16(&mut ret, 0x0); // Reserved

     

       
31
       
-
       
    output_u16(&mut ret, 0x0); // Reserved

     

       
32
       
-
       
    output_u32(&mut ret, 0x36); // Offset of pixel array

     

       
33
       
-
       
    output_u32(&mut ret, 0x28); // Length of DIB header

     

       
34
       
-
       
    output_u32(&mut ret, SIZE as u32); // Width

     

       
35
       
-
       
    output_u32(&mut ret, SIZE as u32); // Height

     

       
36
       
-
       
    output_u16(&mut ret, 0x1); // Color planes

     

       
37
       
-
       
    output_u16(&mut ret, 0x18); // Bits per pixel

     

       
38
       
-
       
    output_u32(&mut ret, 0x0); // No pixel array compression

     

       
39
       
-
       
    output_u32(&mut ret, 0x0); // Horizontal resolution

     

       
40
       
-
       
    output_u32(&mut ret, 0x0); // Vertical resolution

     

       
41
       
-
       
    output_u32(&mut ret, 0x0); // Colors in the palette

     

       
42
       
-
       
    output_u32(&mut ret, 0x0); // All colors are important

     

       
43
       
 
       


     

       
44
       
-
       
    for y in (0..SIZE).rev() {

     

       
45
       
-
       
        for x in 0..SIZE {

     

       
46
       
-
       
            let (r, g, b, _) = bmp[x][y];

     

       
47
       
-
       
            output_u8(&mut ret, b);

     

       
48
       
-
       
            output_u8(&mut ret, g);

     

       
49
       
-
       
            output_u8(&mut ret, r);

     

       
50
       
-
       
        }

     

       
51
       
 
       


     

       
52
       
-
       
        for _ in 0..row_padding {

     

       
53
       
-
       
            output_u8(&mut ret, 0);

     

       
54
       
-
       
        }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
55
       
 
       
    }

     

       
56
       
 
       


     

       
57
       
-
       
    return ret;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
58
       
 
       
}

     

···

       
0
       
 
       

     

       
1
       
 
       
pub const SIZE: usize = 600;

     

       
0
       
 
       

     

       
2
       
 
       


     

       
3
       
+
       
pub type Point = (usize, usize);

     

       
4
       
+
       
pub type Pixel = (u8, u8, u8, u8);

     

       
5
       
+
       
pub struct Bitmap {

     

       
6
       
+
       
    data: [[Pixel; SIZE]; SIZE],

     

       
7
       
 
       
}

     

       
8
       
 
       


     

       
9
       
+
       
impl Bitmap {

     

       
10
       
+
       
    pub fn new() -> Bitmap {

     

       
11
       
+
       
        Bitmap {

     

       
12
       
+
       
            data: [[(0, 0, 0, 0); SIZE]; SIZE],

     

       
13
       
+
       
        }

     

       
14
       
+
       
    }

     

       
15
       
 
       


     

       
16
       
+
       
    pub fn pixel_mut(&mut self, p: Point) -> &mut Pixel {

     

       
17
       
+
       
        let (x, y) = p;

     

       
18
       
+
       
        &mut self.data[x][y]

     

       
19
       
+
       
    }

     

       
20
       
+
       


     

       
21
       
+
       
    pub fn pixel(&self, p: Point) -> &Pixel {

     

       
22
       
+
       
        let (x, y) = p;

     

       
23
       
+
       
        &self.data[x][y]

     

       
24
       
+
       
    }

     

       
25
       
+
       


     

       
26
       
+
       
    pub fn to_data(&self) -> Vec<u8> {

     

       
27
       
+
       
        let mut writer = Writer::new();

     

       
28
       
+
       
        let row_padding = 3 - (3 * SIZE % 4);

     

       
29
       
+
       
        writer.output_u16(0x4d42); // BM 

     

       
30
       
+
       
        writer.output_u32((0x36 + SIZE * (3 * SIZE + row_padding)) as u32); // Size

     

       
31
       
+
       
        writer.output_u16(0x0); // Reserved

     

       
32
       
+
       
        writer.output_u16(0x0); // Reserved

     

       
33
       
+
       
        writer.output_u32(0x36); // Offset of pixel array

     

       
34
       
+
       
        writer.output_u32(0x28); // Length of DIB header

     

       
35
       
+
       
        writer.output_u32(SIZE as u32); // Width

     

       
36
       
+
       
        writer.output_u32(SIZE as u32); // Height

     

       
37
       
+
       
        writer.output_u16(0x1); // Color planes

     

       
38
       
+
       
        writer.output_u16(0x18); // Bits per pixel

     

       
39
       
+
       
        writer.output_u32(0x0); // No pixel array compression

     

       
40
       
+
       
        writer.output_u32(0x0); // Horizontal resolution

     

       
41
       
+
       
        writer.output_u32(0x0); // Vertical resolution

     

       
42
       
+
       
        writer.output_u32(0x0); // Colors in the palette

     

       
43
       
+
       
        writer.output_u32(0x0); // All colors are important

     

       
44
       
+
       


     

       
45
       
+
       
        for y in (0..SIZE).rev() {

     

       
46
       
+
       
            for x in 0..SIZE {

     

       
47
       
+
       
                let (r, g, b, _) = self.data[x][y];

     

       
48
       
+
       
                writer.output_u8(b);

     

       
49
       
+
       
                writer.output_u8(g);

     

       
50
       
+
       
                writer.output_u8(r);

     

       
51
       
+
       
            }

     

       
52
       
+
       


     

       
53
       
+
       
            for _ in 0..row_padding {

     

       
54
       
+
       
                writer.output_u8(0);

     

       
55
       
+
       
            }

     

       
56
       
+
       
        }

     

       
57
       
+
       


     

       
58
       
+
       
        return writer.output();

     

       
59
       
+
       
    }

     

       
60
       
 
       
}

     

       
61
       
 
       


     

       
62
       
+
       
struct Writer {

     

       
63
       
+
       
    output: Vec<u8>,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
64
       
 
       
}

     

       
65
       
 
       


     

       
66
       
+
       
impl Writer {

     

       
67
       
+
       
    fn new() -> Writer {

     

       
68
       
+
       
        Writer { output: Vec::new() }

     

       
69
       
+
       
    }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
70
       
 
       


     

       
71
       
+
       
    fn output_u8(&mut self, n: u8) {

     

       
72
       
+
       
        self.output.push(n);

     

       
73
       
+
       
    }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
74
       
 
       


     

       
75
       
+
       
    fn output_u16(&mut self, n: u16) {

     

       
76
       
+
       
        self.output.push(n as u8);

     

       
77
       
+
       
        self.output.push((n >> 8) as u8);

     

       
78
       
+
       
    }

     

       
79
       
+
       


     

       
80
       
+
       
    fn output_u32(&mut self, n: u32) {

     

       
81
       
+
       
        self.output.push(n as u8);

     

       
82
       
+
       
        self.output.push((n >> 8) as u8);

     

       
83
       
+
       
        self.output.push((n >> 16) as u8);

     

       
84
       
+
       
        self.output.push((n >> 24) as u8);

     

       
85
       
 
       
    }

     

       
86
       
 
       


     

       
87
       
+
       
    fn output(self) -> Vec<u8> {

     

       
88
       
+
       
        self.output

     

       
89
       
+
       
    }

     

       
90
       
 
       
}

     

···

       
17
       
 
       
        let mut processor = RnaProcessor::new();

     

       
18
       
 
       
        processor.process_rna(rna.lines().collect());

     

       
19
       
 
       
        if let Some(bmp) = processor.bitmap() {

     

       
20
       
-
       
            if fs::write(&args[2], bitmap::to_data(bmp)).is_err() {

     

       
21
       
 
       
                println!("Could not write to {}", args[2]);

     

       
22
       
 
       
            }

     

       
23
       
 
       
        }

     

···

       
17
       
 
       
        let mut processor = RnaProcessor::new();

     

       
18
       
 
       
        processor.process_rna(rna.lines().collect());

     

       
19
       
 
       
        if let Some(bmp) = processor.bitmap() {

     

       
20
       
+
       
            if fs::write(&args[2], bmp.to_data()).is_err() {

     

       
21
       
 
       
                println!("Could not write to {}", args[2]);

     

       
22
       
 
       
            }

     

       
23
       
 
       
        }

     

···

       
1
       
 
       
use crate::bitmap::Bitmap;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2
       
 
       
use crate::bitmap::SIZE;

     

       
3
       
-
       
use crate::bitmap::new_bitmap;

     

       
4
       
 
       
use std::cmp::max;

     

       
5
       
 
       


     

       
6
       
 
       
struct Bucket {

     
···

       
14
       
 
       


     

       
15
       
 
       
pub struct RnaProcessor {

     

       
16
       
 
       
    bucket: Bucket,

     

       
17
       
-
       
    position: (usize, usize),

     

       
18
       
-
       
    mark: (usize, usize),

     

       
19
       
-
       
    dir: (usize, usize),

     

       
20
       
 
       
    bitmaps: Vec<Bitmap>,

     

       
21
       
 
       
}

     

       
22
       
 
       


     
···

       
32
       
 
       
        }

     

       
33
       
 
       
    }

     

       
34
       
 
       


     

       
35
       
-
       
    fn current_pixel(&self) -> (u8, u8, u8, u8) {

     

       
36
       
-
       
        let r = if self.count_rgb == 0 {

     

       
37
       
-
       
            0

     

       
38
       
 
       
        } else {

     

       
39
       
-
       
            self.total_r / self.count_rgb

     

       
40
       
-
       
        };

     

       
41
       
-
       
        let g = if self.count_rgb == 0 {

     

       
42
       
-
       
            0

     

       
43
       
-
       
        } else {

     

       
44
       
-
       
            self.total_g / self.count_rgb

     

       
45
       
-
       
        };

     

       
46
       
-
       
        let b = if self.count_rgb == 0 {

     

       
47
       
-
       
            0

     

       
48
       
-
       
        } else {

     

       
49
       
-
       
            self.total_b / self.count_rgb

     

       
50
       
 
       
        };

     

       
51
       
 
       
        let a = if self.count_a == 0 {

     

       
52
       
 
       
            255

     
···

       
95
       
 
       
        }

     

       
96
       
 
       
    }

     

       
97
       
 
       


     

       
98
       
-
       
    fn set_pixel(&mut self, x: usize, y: usize) {

     

       
99
       
 
       
        if let Some(b) = self.bitmaps.last_mut() {

     

       
100
       
-
       
            b[x][y] = self.bucket.current_pixel();

     

       
101
       
 
       
        }

     

       
102
       
 
       
    }

     

       
103
       
 
       


     
···

       
138
       
 
       
            } else if r == "PCCIFFP" {

     

       
139
       
 
       
                self.mark = self.position;

     

       
140
       
 
       
            } else if r == "PFFICCP" {

     

       
0
       
 
       

     

       
141
       
 
       
                let x0 = self.position.0 as isize;

     

       
142
       
 
       
                let y0 = self.position.1 as isize;

     

       
143
       
 
       
                let x1 = self.mark.0 as isize;

     
···

       
149
       
 
       
                let mut x = x0 * d + (d - c) / 2;

     

       
150
       
 
       
                let mut y = x0 * d + (d - c) / 2;

     

       
151
       
 
       
                for _ in 0..d {

     

       
152
       
-
       
                    self.set_pixel((x / d) as usize, (y / d) as usize);

     

       
153
       
 
       
                    x += dx;

     

       
154
       
 
       
                    y += dy;

     

       
155
       
 
       
                }

     

       
156
       
-
       
                self.set_pixel(x1 as usize, y1 as usize);

     

       
157
       
 
       
            } else if r == "PIIPIIP" {

     

       
158
       
-
       
                let (x, y) = self.position;

     

       
159
       
 
       
                if let Some(b) = self.bitmaps.last_mut() {

     

       
160
       
-
       
                    let old = b[x][y];

     

       
161
       
 
       
                    let new = self.bucket.current_pixel();

     

       
162
       
 
       
                    let mut to_fill = Vec::new();

     

       
163
       
 
       
                    to_fill.push(self.position);

     

       
164
       
-
       
                    while let Some((x, y)) = to_fill.pop() {

     

       
165
       
-
       
                        if b[x][y] == old {

     

       
166
       
-
       
                            b[x][y] = new;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
167
       
 
       
                            if x > 0 {

     

       
168
       
 
       
                                to_fill.push((x - 1, y));

     

       
169
       
 
       
                            }

     
···

       
181
       
 
       
                }

     

       
182
       
 
       
            } else if r == "PCCPFFP" {

     

       
183
       
 
       
                if self.bitmaps.len() < 10 {

     

       
184
       
-
       
                    self.bitmaps.push(new_bitmap());

     

       
185
       
 
       
                }

     

       
186
       
 
       
            } else if r == "PFFPCCP" {

     

       
187
       
-
       
                if self.bitmaps.len() >= 2 {

     

       
188
       
-
       
                    let bmp0 = self.bitmaps[self.bitmaps.len() - 1];

     

       
189
       
-
       
                    let mut bmp1 = self.bitmaps[self.bitmaps.len() - 2];

     

       
190
       
-
       
                    for x in 0..SIZE {

     

       
191
       
-
       
                        for y in 0..SIZE {

     

       
192
       
-
       
                            let (r0, b0, g0, a0) = bmp0[x][y];

     

       
193
       
-
       
                            let (r1, b1, g1, a1) = bmp1[x][y];

     

       
194
       
-
       
                            let r = r0 + (((r1 as usize) * (255 - a0 as usize) / 255) as u8);

     

       
195
       
-
       
                            let g = g0 + (((g1 as usize) * (255 - a0 as usize) / 255) as u8);

     

       
196
       
-
       
                            let b = b0 + (((b1 as usize) * (255 - a0 as usize) / 255) as u8);

     

       
197
       
-
       
                            let a = a0 + (((a1 as usize) * (255 - a0 as usize) / 255) as u8);

     

       
198
       
-
       
                            bmp1[x][y] = (r, g, b, a);

     

       
199
       
 
       
                        }

     

       
0
       
 
       

     

       
200
       
 
       
                    }

     

       
201
       
-
       
                    self.bitmaps.pop();

     

       
202
       
 
       
                }

     

       
203
       
 
       
            } else if r == "PFFICCF" {

     

       
204
       
-
       
                if self.bitmaps.len() >= 2 {

     

       
205
       
-
       
                    let bmp0 = self.bitmaps[self.bitmaps.len() - 1];

     

       
206
       
-
       
                    let mut bmp1 = self.bitmaps[self.bitmaps.len() - 2];

     

       
207
       
-
       
                    for x in 0..SIZE {

     

       
208
       
-
       
                        for y in 0..SIZE {

     

       
209
       
-
       
                            let (_, _, _, a0) = bmp0[x][y];

     

       
210
       
-
       
                            let (r1, b1, g1, a1) = bmp1[x][y];

     

       
211
       
-
       
                            let r = ((r1 as usize) * (a0 as usize) / 255) as u8;

     

       
212
       
-
       
                            let g = ((g1 as usize) * (a0 as usize) / 255) as u8;

     

       
213
       
-
       
                            let b = ((b1 as usize) * (a0 as usize) / 255) as u8;

     

       
214
       
-
       
                            let a = ((a1 as usize) * (a0 as usize) / 255) as u8;

     

       
215
       
-
       
                            bmp1[x][y] = (r, g, b, a);

     

       
216
       
 
       
                        }

     

       
0
       
 
       

     

       
217
       
 
       
                    }

     

       
218
       
-
       
                    self.bitmaps.pop();

     

       
219
       
 
       
                }

     

       
220
       
 
       
            }

     

       
221
       
 
       
        }

     

···

       
1
       
 
       
use crate::bitmap::Bitmap;

     

       
2
       
+
       
use crate::bitmap::Pixel;

     

       
3
       
+
       
use crate::bitmap::Point;

     

       
4
       
 
       
use crate::bitmap::SIZE;

     

       
0
       
 
       

     

       
5
       
 
       
use std::cmp::max;

     

       
6
       
 
       


     

       
7
       
 
       
struct Bucket {

     
···

       
15
       
 
       


     

       
16
       
 
       
pub struct RnaProcessor {

     

       
17
       
 
       
    bucket: Bucket,

     

       
18
       
+
       
    position: Point,

     

       
19
       
+
       
    mark: Point,

     

       
20
       
+
       
    dir: Point,

     

       
21
       
 
       
    bitmaps: Vec<Bitmap>,

     

       
22
       
 
       
}

     

       
23
       
 
       


     
···

       
33
       
 
       
        }

     

       
34
       
 
       
    }

     

       
35
       
 
       


     

       
36
       
+
       
    fn current_pixel(&self) -> Pixel {

     

       
37
       
+
       
        let (r, g, b) = if self.count_rgb == 0 {

     

       
38
       
+
       
            (0, 0, 0)

     

       
39
       
 
       
        } else {

     

       
40
       
+
       
            (

     

       
41
       
+
       
                self.total_r / self.count_rgb,

     

       
42
       
+
       
                self.total_g / self.count_rgb,

     

       
43
       
+
       
                self.total_b / self.count_rgb,

     

       
44
       
+
       
            )

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
45
       
 
       
        };

     

       
46
       
 
       
        let a = if self.count_a == 0 {

     

       
47
       
 
       
            255

     
···

       
90
       
 
       
        }

     

       
91
       
 
       
    }

     

       
92
       
 
       


     

       
93
       
+
       
    fn set_pixel(&mut self, p: Point) {

     

       
94
       
 
       
        if let Some(b) = self.bitmaps.last_mut() {

     

       
95
       
+
       
            *b.pixel_mut(p) = self.bucket.current_pixel();

     

       
96
       
 
       
        }

     

       
97
       
 
       
    }

     

       
98
       
 
       


     
···

       
133
       
 
       
            } else if r == "PCCIFFP" {

     

       
134
       
 
       
                self.mark = self.position;

     

       
135
       
 
       
            } else if r == "PFFICCP" {

     

       
136
       
+
       
	        // TODO: Can I rework this to reduce casts or locals?

     

       
137
       
 
       
                let x0 = self.position.0 as isize;

     

       
138
       
 
       
                let y0 = self.position.1 as isize;

     

       
139
       
 
       
                let x1 = self.mark.0 as isize;

     
···

       
145
       
 
       
                let mut x = x0 * d + (d - c) / 2;

     

       
146
       
 
       
                let mut y = x0 * d + (d - c) / 2;

     

       
147
       
 
       
                for _ in 0..d {

     

       
148
       
+
       
                    self.set_pixel(((x / d) as usize, (y / d) as usize));

     

       
149
       
 
       
                    x += dx;

     

       
150
       
 
       
                    y += dy;

     

       
151
       
 
       
                }

     

       
152
       
+
       
                self.set_pixel((x1 as usize, y1 as usize));

     

       
153
       
 
       
            } else if r == "PIIPIIP" {

     

       
0
       
 
       

     

       
154
       
 
       
                if let Some(b) = self.bitmaps.last_mut() {

     

       
155
       
+
       
                    let old = *b.pixel(self.position);

     

       
156
       
 
       
                    let new = self.bucket.current_pixel();

     

       
157
       
 
       
                    let mut to_fill = Vec::new();

     

       
158
       
 
       
                    to_fill.push(self.position);

     

       
159
       
+
       
                    while let Some(p) = to_fill.pop() {

     

       
160
       
+
       
                        if *b.pixel(p) == old {

     

       
161
       
+
       
                            *b.pixel_mut(p) = new;

     

       
162
       
+
       


     

       
163
       
+
       
                            let (x, y) = p;

     

       
164
       
 
       
                            if x > 0 {

     

       
165
       
 
       
                                to_fill.push((x - 1, y));

     

       
166
       
 
       
                            }

     
···

       
178
       
 
       
                }

     

       
179
       
 
       
            } else if r == "PCCPFFP" {

     

       
180
       
 
       
                if self.bitmaps.len() < 10 {

     

       
181
       
+
       
                    self.bitmaps.push(Bitmap::new());

     

       
182
       
 
       
                }

     

       
183
       
 
       
            } else if r == "PFFPCCP" {

     

       
184
       
+
       
                if let Some(bmp0) = self.bitmaps.pop() {

     

       
185
       
+
       
                    if let Some(mut bmp1) = self.bitmaps.pop() {

     

       
186
       
+
       
                        for x in 0..SIZE {

     

       
187
       
+
       
                            for y in 0..SIZE {

     

       
188
       
+
       
                                let (r0, b0, g0, a0) = *bmp0.pixel((x, y));

     

       
189
       
+
       
                                let (r1, b1, g1, a1) = *bmp1.pixel((x, y));

     

       
190
       
+
       
                                let r = r0 + ((r1 as usize) * (255 - a0 as usize) / 255) as u8;

     

       
191
       
+
       
                                let g = g0 + ((g1 as usize) * (255 - a0 as usize) / 255) as u8;

     

       
192
       
+
       
                                let b = b0 + ((b1 as usize) * (255 - a0 as usize) / 255) as u8;

     

       
193
       
+
       
                                let a = a0 + ((a1 as usize) * (255 - a0 as usize) / 255) as u8;

     

       
194
       
+
       
                                *bmp1.pixel_mut((x, y)) = (r, g, b, a);

     

       
195
       
+
       
                            }

     

       
196
       
 
       
                        }

     

       
197
       
+
       
                        self.bitmaps.push(bmp1);

     

       
198
       
 
       
                    }

     

       
0
       
 
       

     

       
199
       
 
       
                }

     

       
200
       
 
       
            } else if r == "PFFICCF" {

     

       
201
       
+
       
                if let Some(bmp0) = self.bitmaps.pop() {

     

       
202
       
+
       
                    if let Some(mut bmp1) = self.bitmaps.pop() {

     

       
203
       
+
       
                        for x in 0..SIZE {

     

       
204
       
+
       
                            for y in 0..SIZE {

     

       
205
       
+
       
                                let (_, _, _, a0) = *bmp0.pixel((x, y));

     

       
206
       
+
       
                                let (r1, b1, g1, a1) = *bmp1.pixel((x, y));

     

       
207
       
+
       
                                let r = ((r1 as usize) * (a0 as usize) / 255) as u8;

     

       
208
       
+
       
                                let g = ((g1 as usize) * (a0 as usize) / 255) as u8;

     

       
209
       
+
       
                                let b = ((b1 as usize) * (a0 as usize) / 255) as u8;

     

       
210
       
+
       
                                let a = ((a1 as usize) * (a0 as usize) / 255) as u8;

     

       
211
       
+
       
                                *bmp1.pixel_mut((x, y)) = (r, g, b, a);

     

       
212
       
+
       
                            }

     

       
213
       
 
       
                        }

     

       
214
       
+
       
                        self.bitmaps.push(bmp1);

     

       
215
       
 
       
                    }

     

       
0
       
 
       

     

       
216
       
 
       
                }

     

       
217
       
 
       
            }

     

       
218
       
 
       
        }