blind_watermark 0.1.3

Picture blind watermarking.
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
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::{PaddedYCrBrAMat, YCrBrAMat};
use faer::prelude::*;

impl YCrBrAMat {
    /// Add padding to the matrix to make dimensions even
    pub fn add_padding(mut self) -> PaddedYCrBrAMat {
        let (height, width) = self.dimensions;

        match (height % 2 == 1, width % 2 == 1) {
            (true, true) => {
                self.add_zero_row_yuv();
                self.add_zero_col_yuv();
                self.internal_into_padded()
            }
            (true, false) => {
                self.add_zero_row_yuv();
                self.internal_into_padded()
            }
            (false, true) => {
                self.add_zero_col_yuv();
                self.internal_into_padded()
            }
            (false, false) => self.internal_into_padded(),
        }
    }

    fn add_zero_row_yuv(&mut self) {
        let cols = self.y.ncols();
        let zero_row = Row::<f32>::zeros(cols);
        let zero_row_view = zero_row.as_ref();

        self.y.push_row(zero_row_view);
        self.cb.push_row(zero_row_view);
        self.cr.push_row(zero_row_view);
    }

    fn add_zero_col_yuv(&mut self) {
        let rows = self.y.nrows();
        let zero_col = Col::<f32>::zeros(rows);
        let zero_col_view = zero_col.as_ref();

        self.y.push_col(zero_col_view);
        self.cb.push_col(zero_col_view);
        self.cr.push_col(zero_col_view);
    }

    fn internal_into_padded(self) -> PaddedYCrBrAMat {
        PaddedYCrBrAMat {
            y: self.y,
            cb: self.cb,
            cr: self.cr,
            a: self.a,
            original_dimensions: self.dimensions,
        }
    }
}

impl PaddedYCrBrAMat {
    /// Remove padding to restore original dimensions
    pub fn remove_padding(self) -> YCrBrAMat {
        YCrBrAMat {
            y: self
                .y
                .as_ref()
                .submatrix(0, 0, self.original_dimensions.0, self.original_dimensions.1)
                .to_owned(),
            cb: self
                .cb
                .as_ref()
                .submatrix(0, 0, self.original_dimensions.0, self.original_dimensions.1)
                .to_owned(),
            cr: self
                .cr
                .as_ref()
                .submatrix(0, 0, self.original_dimensions.0, self.original_dimensions.1)
                .to_owned(),
            a: self.a,
            dimensions: self.original_dimensions,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add_padding() {
        let yuv = YCrBrAMat {
            y: Mat::<f32>::ones(2, 3),
            cb: Mat::<f32>::ones(2, 3),
            cr: Mat::<f32>::ones(2, 3),
            a: Mat::<f32>::ones(2, 3),
            dimensions: (2, 3),
        };
        let padded = yuv.add_padding();
        assert_eq!(padded.y.ncols(), 4);
        assert_eq!(padded.cr.ncols(), 4);
        assert_eq!(padded.cb.ncols(), 4);
        assert_eq!(padded.y.nrows(), 2);
        assert_eq!(padded.cb.nrows(), 2);
        assert_eq!(padded.cr.nrows(), 2);
        assert_eq!(padded.a.nrows(), 2);
        assert_eq!(padded.a.ncols(), 3);
    }

    #[test]
    fn test_remove_padding() {
        let yuv = YCrBrAMat {
            y: Mat::<f32>::ones(2, 3),
            cb: Mat::<f32>::ones(2, 3),
            cr: Mat::<f32>::ones(2, 3),
            a: Mat::<f32>::ones(2, 3),
            dimensions: (2, 3),
        };
        let padded = yuv.add_padding();
        let yuv_recovered = padded.remove_padding();
        assert_eq!(yuv_recovered.y.nrows(), 2);
        assert_eq!(yuv_recovered.y.ncols(), 3);
        assert_eq!(yuv_recovered.cb.nrows(), 2);
        assert_eq!(yuv_recovered.cb.ncols(), 3);
        assert_eq!(yuv_recovered.cr.nrows(), 2);
        assert_eq!(yuv_recovered.cr.ncols(), 3);
        assert_eq!(yuv_recovered.a.nrows(), 2);
        assert_eq!(yuv_recovered.a.ncols(), 3);
    }
}