shutter 0.0.1

Image processing data structures and algorithms
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

use opencv::{core, imgproc};
use crate::image::*;
use nalgebra::Scalar;
use std::fmt::Debug;

struct MorphKernel {
    iterations : i32,
    sz : i32,
    anchor : core::Point2i,
    border_val : core::Scalar,
    kernel : core::Mat
}

fn build_kernel(sz : usize, iterations : usize) -> MorphKernel {
    let kernel_sz = (2*sz+1) as i32;
    let kernel = imgproc::get_structuring_element(
        imgproc::MORPH_RECT,
        core::Size2i { width : kernel_sz, height : kernel_sz },
        core::Point2i { x : sz as i32, y : sz as i32 }
    ).unwrap();
    let anchor = core::Point2i{x : -1, y : -1};
    let border_val = core::Scalar::from(1.);
    MorphKernel { iterations : iterations as i32, sz : sz as i32, anchor, border_val, kernel }
}

pub struct Erosion<P>
where
    P : Scalar + From<u8> + Debug + Copy
{
    tgt : Image<P>,
    kernel : MorphKernel
}

impl<P> Erosion<P>
where
    P : Scalar + From<u8> + Debug + Copy
{

    pub fn new(dim : (usize, usize), sz : usize, iterations : usize) -> Self {
        let kernel = build_kernel(sz, iterations);
        Self{ tgt : Image::new_constant(dim.0, dim.1, P::from(0)), kernel }
    }

    pub fn apply(&mut self, img : &Window<P>) -> Option<&Image<P>> {
        let src : core::Mat = img.clone().into();
        let mut dst : core::Mat = self.tgt.full_window_mut().into();
        unsafe {
            imgproc::erode(
                &src,
                &mut dst,
                &self.kernel.kernel,
                self.kernel.anchor,
                self.kernel.iterations,
                core::BORDER_CONSTANT,
                self.kernel.border_val
            ).ok()?;
        }
        Some(&self.tgt)
    }
}

pub struct Dilation<P>
where
    P : Scalar + From<u8> + Debug + Copy
{
    tgt : Image<P>
}

impl<P> Dilation<P>
where
    P : Scalar + From<u8> + Debug + Copy
{

    pub fn new(dim : (usize, usize)) -> Self {
        Self{ tgt : Image::new_constant(dim.0, dim.1, P::from(0)) }
    }

    pub fn apply(&mut self) -> Option<&Image<P>> {
        /*imgproc::dilate(
            src: &dyn ToInputArray,
            dst: &mut dyn ToOutputArray,
            kernel: &dyn ToInputArray,
            anchor: Point,
            iterations: i32,
            border_type: i32,
            border_value: Scalar
        ).ok()?*/
        unimplemented!()
    }

}