solvr 0.2.0

Advanced computing library for real-world problem solving - optimization, differential equations, interpolation, statistics, and more
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

//! CPU implementation of binary morphology algorithms.

use crate::morphology::impl_generic::{
    binary_closing_impl, binary_dilation_impl, binary_erosion_impl, binary_fill_holes_impl,
    binary_opening_impl,
};
use crate::morphology::traits::binary::{BinaryMorphologyAlgorithms, StructuringElement};
use numr::error::Result;
use numr::runtime::cpu::{CpuClient, CpuRuntime};
use numr::tensor::Tensor;

impl BinaryMorphologyAlgorithms<CpuRuntime> for CpuClient {
    fn binary_erosion(
        &self,
        input: &Tensor<CpuRuntime>,
        structure: StructuringElement,
        iterations: usize,
    ) -> Result<Tensor<CpuRuntime>> {
        binary_erosion_impl(self, input, structure, iterations)
    }

    fn binary_dilation(
        &self,
        input: &Tensor<CpuRuntime>,
        structure: StructuringElement,
        iterations: usize,
    ) -> Result<Tensor<CpuRuntime>> {
        binary_dilation_impl(self, input, structure, iterations)
    }

    fn binary_opening(
        &self,
        input: &Tensor<CpuRuntime>,
        structure: StructuringElement,
        iterations: usize,
    ) -> Result<Tensor<CpuRuntime>> {
        binary_opening_impl(self, input, structure, iterations)
    }

    fn binary_closing(
        &self,
        input: &Tensor<CpuRuntime>,
        structure: StructuringElement,
        iterations: usize,
    ) -> Result<Tensor<CpuRuntime>> {
        binary_closing_impl(self, input, structure, iterations)
    }

    fn binary_fill_holes(&self, input: &Tensor<CpuRuntime>) -> Result<Tensor<CpuRuntime>> {
        binary_fill_holes_impl(self, input)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use numr::runtime::cpu::CpuDevice;

    fn setup() -> (CpuClient, CpuDevice) {
        let device = CpuDevice::new();
        let client = CpuClient::new(device.clone());
        (client, device)
    }

    #[test]
    fn test_binary_erosion_2d() {
        let (client, device) = setup();
        // 5x5 with a 3x3 block of ones in center
        let data = vec![
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0,
            1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
        ];
        let input = Tensor::from_slice(&data, &[5, 5], &device);
        let result = client
            .binary_erosion(&input, StructuringElement::Cross, 1)
            .unwrap();
        let out: Vec<f64> = result.to_vec();
        // After cross erosion, only center pixel should remain
        assert!((out[12] - 1.0).abs() < 1e-10); // center
        assert!((out[6] - 0.0).abs() < 1e-10); // edge of block
    }

    #[test]
    fn test_binary_dilation_2d() {
        let (client, device) = setup();
        // Single pixel
        let mut data = vec![0.0; 25];
        data[12] = 1.0; // center
        let input = Tensor::from_slice(&data, &[5, 5], &device);
        let result = client
            .binary_dilation(&input, StructuringElement::Cross, 1)
            .unwrap();
        let out: Vec<f64> = result.to_vec();
        // Center and 4 neighbors should be 1
        assert!((out[12] - 1.0).abs() < 1e-10);
        assert!((out[7] - 1.0).abs() < 1e-10); // above
        assert!((out[17] - 1.0).abs() < 1e-10); // below
        assert!((out[11] - 1.0).abs() < 1e-10); // left
        assert!((out[13] - 1.0).abs() < 1e-10); // right
    }

    #[test]
    fn test_binary_opening_removes_small() {
        let (client, device) = setup();
        // Large block + isolated pixel
        let data = vec![
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0,
            1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0,
        ];
        let input = Tensor::from_slice(&data, &[5, 5], &device);
        let result = client
            .binary_opening(&input, StructuringElement::Cross, 1)
            .unwrap();
        let out: Vec<f64> = result.to_vec();
        // Isolated pixel should be removed
        assert!((out[24] - 0.0).abs() < 1e-10);
        // Center of block should remain
        assert!((out[12] - 1.0).abs() < 1e-10);
    }
}