kornia-rs 0.1.5

Low-level computer vision library in Rust
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

use crate::image::Image;
use anyhow::Result;

pub(crate) fn euclidean_distance(x1: Vec<f32>, x2: Vec<f32>) -> f32 {
    ((x1[0] - x2[0]).powi(2) + (x1[1] - x2[1]).powi(2)).sqrt()
}

// NOTE: only for testing, extremely slow
pub fn distance_transform_vanilla(image: &Image<f32, 1>) -> Image<f32, 1> {
    let mut output = ndarray::Array3::<f32>::zeros(image.data.dim());
    for y in 0..image.height() - 1 {
        for x in 0..image.width() - 1 {
            let mut min_distance = std::f32::MAX;
            for j in 0..image.height() - 1 {
                for i in 0..image.width() - 1 {
                    //println!("{:?} {:?}", i, j);
                    if image.data[[j, i, 0]] > 0.0 {
                        // TODO: pass as array or reference
                        let distance =
                            euclidean_distance(vec![x as f32, y as f32], vec![i as f32, j as f32]);
                        if distance < min_distance {
                            min_distance = distance;
                        }
                    }
                }
            }
            output[[y, x, 0]] = min_distance;
        }
    }
    Image { data: output }
}

// TODO: not fully working
//pub fn distance_transform(image: &Image<f32>) -> Image<f32> {
pub fn distance_transform(image: &Image<f32, 1>) -> Result<Image<f32, 1>> {
    //let mut distance = ndarray::Array3::<f32>::zeros(image.data.dim());
    let mut distance = Image::from_size_val(image.size(), 0.0f32).unwrap();

    // forwards pass

    for i in 0..image.height() {
        for j in 0..image.width() {
            if image.data[[i, j, 0]] > 0.0 {
                distance.data[[i, j, 0]] = 0.0;
            } else {
                if i > 0 {
                    distance.data[[i, j, 0]] =
                        distance.data[[i, j, 0]].min(distance.data[[i - 1, j, 0]] + 1.0)
                }
                if j > 0 {
                    distance.data[[i, j, 0]] =
                        distance.data[[i, j, 0]].min(distance.data[[i, j - 1, 0]] + 1.0)
                }
            }
        }
    }

    // backwards pass

    for i in (0..image.height()).rev() {
        for j in (0..image.width()).rev() {
            if i < image.height() - 1 {
                distance.data[[i, j, 0]] =
                    distance.data[[i, j, 0]].min(distance.data[[i + 1, j, 0]] + 1.0)
            }
            if j < image.width() - 1 {
                distance.data[[i, j, 0]] =
                    distance.data[[i, j, 0]].min(distance.data[[i, j + 1, 0]] + 1.0)
            }
        }
    }

    //for i in (0..image.width()).rev() {
    //    for j in (0..image.height()).rev() {
    //        if i < image.width() - 1 {
    //            distance[[j, i, 0]] = distance[[j, i, 0]].min(distance[[j, i + 1, 0]] + 1.0)
    //        }
    //        if j < image.height() - 1 {
    //            distance[[j, i, 0]] = distance[[j, i, 0]].min(distance[[j + 1, i, 0]] + 1.0)
    //        }
    //    }
    //}

    Ok(distance)
}

#[cfg(test)]
mod tests {
    use crate::distance_transform::distance_transform_vanilla;
    use crate::image::Image;

    #[test]
    fn distance_transform_vanilla_smoke() {
        let image = Image::<f32, 1>::new(
            crate::image::ImageSize {
                width: 3,
                height: 4,
            },
            vec![
                0.0f32, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0,
            ],
        )
        .unwrap();
        let output = distance_transform_vanilla(&image);
        println!("{:?}", output.data);
    }
}