climage 0.1.0

Rust implementation of image processing library with OpenCL.
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

use super::context::ClContext;
use super::imageproc::ImageProc;
use ocl::{Kernel, Program};

static KERNEL_SRC: &'static str = r#"
__constant sampler_t sampler_const = CLK_NORMALIZED_COORDS_FALSE |
                                    CLK_ADDRESS_NONE |
                                    CLK_FILTER_NEAREST;
__kernel void hflip(
    __read_only image2d_t src_image,
    __write_only image2d_t dst_image) {
    int2 gid = (int2)(get_global_id(0), get_global_id(1));
    int2 size = get_image_dim(src_image);

    if(all(gid < size)){
        uint4 pixel = read_imageui(src_image, sampler_const, gid);
        write_imageui(dst_image, (int2)(size.x - gid.x - 1, gid.y), pixel);
    }
}
"#;

pub struct HFlip<'a> {
    context: &'a ClContext,
    program: Program,
    kernel: Option<Kernel>,
}

impl<'a> HFlip<'a> {
    pub fn new(context: &'a ClContext) -> Self {
        let program = Program::builder()
            .src(KERNEL_SRC)
            .build(&context.context)
            .unwrap();
        HFlip {
            context,
            program,
            kernel: None,
        }
    }
}

impl<'a> ImageProc for HFlip<'a> {
    fn build_kernel(
        &mut self,
        src_img: &crate::ClImageBuffer,
        dst_img: &mut crate::ClImageBuffer,
    ) -> &mut Self {
        let kernel = ocl::Kernel::builder()
            .program(&self.program)
            .name("hflip")
            .queue(self.context.queue.clone())
            .global_work_size(src_img.dimensions())
            .arg(&src_img.data)
            .arg(&dst_img.data)
            .build()
            .unwrap();
        self.kernel = Some(kernel);
        self
    }
    fn run(&self) {
        unsafe { self.kernel.as_ref().unwrap().enq().unwrap() };
    }
}