Struct ImageBuffer

Source

pub struct ImageBuffer<'a> { /* private fields */ }

Expand description

Borrowed wrapper around a caller-owned image buffer.

Implementations§

Source §

impl<'a> ImageBuffer<'a>

Source

pub fn from_argb8888( data: &'a mut [u8], width: usize, height: usize, ) -> Result<Self>

Borrows caller-owned ARGB8888 storage as a vImage_Buffer.

Examples found in repository ?

examples/02_blas_vimage.rs (line 31)

5fn main() {
6    let mut output = vec![0.0_f32; 4];
7    sgemm_row_major(
8        2,
9        2,
10        3,
11        1.0,
12        &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0],
13        &[7.0, 8.0, 9.0, 10.0, 11.0, 12.0],
14        0.0,
15        &mut output,
16    )
17    .expect("sgemm failed");
18    let expected = [58.0_f32, 64.0, 139.0, 154.0];
19    for (actual, expected_value) in output.iter().zip(expected) {
20        assert!(
21            (actual - expected_value).abs() < 1.0e-5,
22            "unexpected sgemm output: {output:?}"
23        );
24    }
25
26    let source_pixels = vec![
27        255_u8, 10, 20, 30, 255, 40, 50, 60, 255, 70, 80, 90, 255, 100, 110, 120,
28    ];
29    let mut src_pixels = source_pixels.clone();
30    let mut rotated_pixels = vec![0_u8; source_pixels.len()];
31    let src = ImageBuffer::from_argb8888(&mut src_pixels, 2, 2).expect("src buffer");
32    let mut rotated =
33        ImageBuffer::from_argb8888(&mut rotated_pixels, 2, 2).expect("rotated buffer");
34    rotate_argb8888(
35        &src,
36        &mut rotated,
37        0.0,
38        [0, 0, 0, 0],
39        vimage_flags::NO_FLAGS,
40    )
41    .expect("rotate failed");
42    assert_eq!(rotated_pixels, source_pixels);
43
44    let mut planar_src = vec![10_u8, 20, 30, 40];
45    let mut planar_dst = vec![0_u8; 4];
46    let planar_src_buffer = ImageBuffer::from_planar8(&mut planar_src, 2, 2).expect("planar src");
47    let mut planar_dst_buffer =
48        ImageBuffer::from_planar8(&mut planar_dst, 2, 2).expect("planar dst");
49    contrast_stretch_planar8(
50        &planar_src_buffer,
51        &mut planar_dst_buffer,
52        vimage_flags::NO_FLAGS,
53    )
54    .expect("contrast stretch failed");
55    assert_eq!(planar_dst, vec![0, 85, 170, 255]);
56
57    println!("blas+vimage smoke passed: sgemm={output:?} contrast={planar_dst:?}");
58}

More examples

Hide additional examples

examples/08_vimage_processing.rs (line 9)

6fn main() {
7    let mut source = vec![255_u8, 10, 20, 30];
8    let mut scaled = vec![0_u8; 16];
9    let src = ImageBuffer::from_argb8888(&mut source, 1, 1).expect("src");
10    let mut dst = ImageBuffer::from_argb8888(&mut scaled, 2, 2).expect("dst");
11    scale_argb8888(&src, &mut dst, vimage_flags::NO_FLAGS).expect("scale");
12    for pixel in scaled.chunks_exact(4) {
13        assert_eq!(pixel, &[255, 10, 20, 30]);
14    }
15
16    let mut interleaved = vec![255_u8, 10, 20, 30, 128, 40, 50, 60];
17    let mut alpha = vec![0_u8; 2];
18    let mut red = vec![0_u8; 2];
19    let mut green = vec![0_u8; 2];
20    let mut blue = vec![0_u8; 2];
21    let src_interleaved =
22        ImageBuffer::from_argb8888(&mut interleaved, 2, 1).expect("src interleaved");
23    let mut alpha_plane = ImageBuffer::from_planar8(&mut alpha, 2, 1).expect("alpha");
24    let mut red_plane = ImageBuffer::from_planar8(&mut red, 2, 1).expect("red");
25    let mut green_plane = ImageBuffer::from_planar8(&mut green, 2, 1).expect("green");
26    let mut blue_plane = ImageBuffer::from_planar8(&mut blue, 2, 1).expect("blue");
27    convert_argb8888_to_planar8(
28        &src_interleaved,
29        &mut alpha_plane,
30        &mut red_plane,
31        &mut green_plane,
32        &mut blue_plane,
33        vimage_flags::NO_FLAGS,
34    )
35    .expect("deinterleave");
36
37    let alpha_plane = ImageBuffer::from_planar8(&mut alpha, 2, 1).expect("alpha src");
38    let red_plane = ImageBuffer::from_planar8(&mut red, 2, 1).expect("red src");
39    let green_plane = ImageBuffer::from_planar8(&mut green, 2, 1).expect("green src");
40    let blue_plane = ImageBuffer::from_planar8(&mut blue, 2, 1).expect("blue src");
41    let mut reinterleaved = vec![0_u8; 8];
42    let mut dst_interleaved =
43        ImageBuffer::from_argb8888(&mut reinterleaved, 2, 1).expect("dst interleaved");
44    convert_planar8_to_argb8888(
45        &alpha_plane,
46        &red_plane,
47        &green_plane,
48        &blue_plane,
49        &mut dst_interleaved,
50        vimage_flags::NO_FLAGS,
51    )
52    .expect("reinterleave");
53    assert_eq!(reinterleaved, interleaved);
54
55    let mut clip_source = vec![64_u8, 100, 50, 10];
56    let mut clip_dest = vec![0_u8; 4];
57    let src_clip = ImageBuffer::from_argb8888(&mut clip_source, 1, 1).expect("clip src");
58    let mut dst_clip = ImageBuffer::from_argb8888(&mut clip_dest, 1, 1).expect("clip dst");
59    clip_to_alpha_argb8888(&src_clip, &mut dst_clip, vimage_flags::NO_FLAGS).expect("clip");
60    assert_eq!(clip_dest, vec![64, 64, 50, 10]);
61
62    let mut planar_src = vec![5_u8, 15, 25, 35];
63    let mut planar_dst = vec![0_u8; 4];
64    let src_planar = ImageBuffer::from_planar8(&mut planar_src, 2, 2).expect("planar src");
65    let mut dst_planar = ImageBuffer::from_planar8(&mut planar_dst, 2, 2).expect("planar dst");
66    contrast_stretch_planar8(&src_planar, &mut dst_planar, vimage_flags::NO_FLAGS)
67        .expect("stretch");
68    assert_eq!(planar_dst, vec![0, 85, 170, 255]);
69
70    println!("vimage smoke passed: scaled={scaled:?} reinterleaved={reinterleaved:?} clipped={clip_dest:?}");
71}

Source

pub fn from_planar8( data: &'a mut [u8], width: usize, height: usize, ) -> Result<Self>

Borrows caller-owned Planar8 storage as a vImage_Buffer.

Examples found in repository ?

examples/02_blas_vimage.rs (line 46)

5fn main() {
6    let mut output = vec![0.0_f32; 4];
7    sgemm_row_major(
8        2,
9        2,
10        3,
11        1.0,
12        &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0],
13        &[7.0, 8.0, 9.0, 10.0, 11.0, 12.0],
14        0.0,
15        &mut output,
16    )
17    .expect("sgemm failed");
18    let expected = [58.0_f32, 64.0, 139.0, 154.0];
19    for (actual, expected_value) in output.iter().zip(expected) {
20        assert!(
21            (actual - expected_value).abs() < 1.0e-5,
22            "unexpected sgemm output: {output:?}"
23        );
24    }
25
26    let source_pixels = vec![
27        255_u8, 10, 20, 30, 255, 40, 50, 60, 255, 70, 80, 90, 255, 100, 110, 120,
28    ];
29    let mut src_pixels = source_pixels.clone();
30    let mut rotated_pixels = vec![0_u8; source_pixels.len()];
31    let src = ImageBuffer::from_argb8888(&mut src_pixels, 2, 2).expect("src buffer");
32    let mut rotated =
33        ImageBuffer::from_argb8888(&mut rotated_pixels, 2, 2).expect("rotated buffer");
34    rotate_argb8888(
35        &src,
36        &mut rotated,
37        0.0,
38        [0, 0, 0, 0],
39        vimage_flags::NO_FLAGS,
40    )
41    .expect("rotate failed");
42    assert_eq!(rotated_pixels, source_pixels);
43
44    let mut planar_src = vec![10_u8, 20, 30, 40];
45    let mut planar_dst = vec![0_u8; 4];
46    let planar_src_buffer = ImageBuffer::from_planar8(&mut planar_src, 2, 2).expect("planar src");
47    let mut planar_dst_buffer =
48        ImageBuffer::from_planar8(&mut planar_dst, 2, 2).expect("planar dst");
49    contrast_stretch_planar8(
50        &planar_src_buffer,
51        &mut planar_dst_buffer,
52        vimage_flags::NO_FLAGS,
53    )
54    .expect("contrast stretch failed");
55    assert_eq!(planar_dst, vec![0, 85, 170, 255]);
56
57    println!("blas+vimage smoke passed: sgemm={output:?} contrast={planar_dst:?}");
58}

More examples

Hide additional examples

examples/08_vimage_processing.rs (line 23)

6fn main() {
7    let mut source = vec![255_u8, 10, 20, 30];
8    let mut scaled = vec![0_u8; 16];
9    let src = ImageBuffer::from_argb8888(&mut source, 1, 1).expect("src");
10    let mut dst = ImageBuffer::from_argb8888(&mut scaled, 2, 2).expect("dst");
11    scale_argb8888(&src, &mut dst, vimage_flags::NO_FLAGS).expect("scale");
12    for pixel in scaled.chunks_exact(4) {
13        assert_eq!(pixel, &[255, 10, 20, 30]);
14    }
15
16    let mut interleaved = vec![255_u8, 10, 20, 30, 128, 40, 50, 60];
17    let mut alpha = vec![0_u8; 2];
18    let mut red = vec![0_u8; 2];
19    let mut green = vec![0_u8; 2];
20    let mut blue = vec![0_u8; 2];
21    let src_interleaved =
22        ImageBuffer::from_argb8888(&mut interleaved, 2, 1).expect("src interleaved");
23    let mut alpha_plane = ImageBuffer::from_planar8(&mut alpha, 2, 1).expect("alpha");
24    let mut red_plane = ImageBuffer::from_planar8(&mut red, 2, 1).expect("red");
25    let mut green_plane = ImageBuffer::from_planar8(&mut green, 2, 1).expect("green");
26    let mut blue_plane = ImageBuffer::from_planar8(&mut blue, 2, 1).expect("blue");
27    convert_argb8888_to_planar8(
28        &src_interleaved,
29        &mut alpha_plane,
30        &mut red_plane,
31        &mut green_plane,
32        &mut blue_plane,
33        vimage_flags::NO_FLAGS,
34    )
35    .expect("deinterleave");
36
37    let alpha_plane = ImageBuffer::from_planar8(&mut alpha, 2, 1).expect("alpha src");
38    let red_plane = ImageBuffer::from_planar8(&mut red, 2, 1).expect("red src");
39    let green_plane = ImageBuffer::from_planar8(&mut green, 2, 1).expect("green src");
40    let blue_plane = ImageBuffer::from_planar8(&mut blue, 2, 1).expect("blue src");
41    let mut reinterleaved = vec![0_u8; 8];
42    let mut dst_interleaved =
43        ImageBuffer::from_argb8888(&mut reinterleaved, 2, 1).expect("dst interleaved");
44    convert_planar8_to_argb8888(
45        &alpha_plane,
46        &red_plane,
47        &green_plane,
48        &blue_plane,
49        &mut dst_interleaved,
50        vimage_flags::NO_FLAGS,
51    )
52    .expect("reinterleave");
53    assert_eq!(reinterleaved, interleaved);
54
55    let mut clip_source = vec![64_u8, 100, 50, 10];
56    let mut clip_dest = vec![0_u8; 4];
57    let src_clip = ImageBuffer::from_argb8888(&mut clip_source, 1, 1).expect("clip src");
58    let mut dst_clip = ImageBuffer::from_argb8888(&mut clip_dest, 1, 1).expect("clip dst");
59    clip_to_alpha_argb8888(&src_clip, &mut dst_clip, vimage_flags::NO_FLAGS).expect("clip");
60    assert_eq!(clip_dest, vec![64, 64, 50, 10]);
61
62    let mut planar_src = vec![5_u8, 15, 25, 35];
63    let mut planar_dst = vec![0_u8; 4];
64    let src_planar = ImageBuffer::from_planar8(&mut planar_src, 2, 2).expect("planar src");
65    let mut dst_planar = ImageBuffer::from_planar8(&mut planar_dst, 2, 2).expect("planar dst");
66    contrast_stretch_planar8(&src_planar, &mut dst_planar, vimage_flags::NO_FLAGS)
67        .expect("stretch");
68    assert_eq!(planar_dst, vec![0, 85, 170, 255]);
69
70    println!("vimage smoke passed: scaled={scaled:?} reinterleaved={reinterleaved:?} clipped={clip_dest:?}");
71}