opendefocus 0.1.10

An advanced open-source convolution library for image post-processing
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

use crate::traits::{TraitBounds};
use ndarray::{ArrayView2, ArrayViewMut3};

fn render_pixel(depth: f32, channel: usize, output_real_values: bool) -> f32 {
    if output_real_values {
        match channel {
            0 => {
                if depth > 0.0 {
                    depth.abs()
                } else {
                    0.0
                }
            }
            1 => {
                if depth == 0.0 {
                    1.0
                } else {
                    0.0
                }
            }
            2 => {
                if depth < 0.0 {
                    depth.abs()
                } else {
                    0.0
                }
            }
            _ => 1.0,
        }
    } else {
        match channel {
            0 => {
                if depth > 0.0 {
                    1.0
                } else {
                    0.0
                }
            }
            1 => {
                if depth == 0.0 {
                    1.0
                } else {
                    0.0
                }
            }
            2 => {
                if depth < 0.0 {
                    1.0
                } else {
                    0.0
                }
            }
            _ => 0.5,
        }
    }
}

pub fn render_focal_plane_overlay<T: TraitBounds>(
    mut image: ArrayViewMut3<T>,
    depth: &ArrayView2<f32>,
    output_real_values: bool,
) {
    image
        .indexed_iter_mut()
        .for_each(|((y, x, channel), value)| {
            let alpha = T::from_f32_normalized(render_pixel(depth[[y, x]], 3, output_real_values))
                .unwrap_or_default();
            *value =
                ((T::from_f32_normalized(render_pixel(depth[[y, x]], channel, output_real_values))
                    .unwrap_or_default())
                    * alpha)
                    + (*value * (T::from_f32_normalized(1.0).unwrap_or_default() - alpha))
        });
}

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

    #[rstest]
    #[case(true, 10.0, 10.0, 0.0, 0.0, 1.0)] // Test positive depth with output_real_values
    #[case(true, -10.0, 0.0, 0.0, 10.0, 1.0)] // Test negative depth with output_real_values
    #[case(true, 0.0, 0.0, 1.0, 0.0, 1.0)] // Test zero depth with output_real_values
    #[case(false, 10.0, 1.0, 0.0, 0.0, 0.5)] // Test positive depth with output_real_values=false
    #[case(false, -10.0, 0.0, 0.0, 1.0, 0.5)] // Test negative depth with output_real_values=false
    #[case(false, 0.0, 0.0, 1.0, 0.0, 0.5)] // Test zero depth with output_real_values=false

    /// Test render_pixel method with different depth values and output_real_values settings
    fn test_render_pixel(
        #[case] output_real_values: bool,
        #[case] depth: f32,
        #[case] expected_r: f32,
        #[case] expected_g: f32,
        #[case] expected_b: f32,
        #[case] expected_a: f32,
    ) {
        assert_approx_eq!(render_pixel(depth, 0, output_real_values), expected_r, 1e-6);
        assert_approx_eq!(render_pixel(depth, 1, output_real_values), expected_g, 1e-6);
        assert_approx_eq!(render_pixel(depth, 2, output_real_values), expected_b, 1e-6);
        assert_approx_eq!(render_pixel(depth, 3, output_real_values), expected_a, 1e-6);
    }
}