ndarray-ndimage 0.6.0

Multidimensional image processing for ArrayBase, the n-dimensional array data structure provided by ndarray.
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
128
129
130
131
132
133
134

#[derive(Debug, PartialEq)]
pub enum SymmetryState {
    NonSymmetric,
    Symmetric,
    AntiSymmetric,
}

#[inline(always)]
pub fn symmetry_state<A: SymmetryStateCheck>(a: A) -> SymmetryState {
    a.symmetry_state()
}

pub trait SymmetryStateCheck {
    fn symmetry_state(self) -> SymmetryState;
}

macro_rules! impl_symmetry_state_for_unsigned {
    ( $( $self:ty ),* ) => {
        $(
            impl<'a> SymmetryStateCheck for &'a [$self] {
                fn symmetry_state(self) -> SymmetryState {
                    // Test for symmetry
                    let mut state = SymmetryState::NonSymmetric;
                    let filter_size = self.len();
                    let half = filter_size / 2;
                    if filter_size & 1 > 0 {
                        state = SymmetryState::Symmetric;
                        for ii in 1..=half {
                            if self[ii + half] != self[half - ii] {
                                state = SymmetryState::NonSymmetric;
                                break;
                            }
                        }
                    }
                    state
                }
            }
        )*
    }
}

macro_rules! impl_symmetry_state_for_signed {
    ( $( $self:ty ),* ) => {
        $(
            impl<'a> SymmetryStateCheck for &'a [$self] {
                fn symmetry_state(self) -> SymmetryState {
                    // Test for symmetry or anti-symmetry
                    let mut state = SymmetryState::NonSymmetric;
                    let filter_size = self.len();
                    let half = filter_size / 2;
                    if filter_size & 1 > 0 {
                        state = SymmetryState::Symmetric;
                        for ii in 1..=half {
                            if self[ii + half] != self[half - ii] {
                                state = SymmetryState::NonSymmetric;
                                break;
                            }
                        }
                        if state == SymmetryState::NonSymmetric {
                            state = SymmetryState::AntiSymmetric;
                            for ii in 1..=half {
                                if self[ii + half] != -self[half - ii] {
                                    state = SymmetryState::NonSymmetric;
                                    break;
                                }
                            }
                        }
                    }
                    state
                }
            }
        )*
    }
}

macro_rules! impl_symmetry_state_for_fp {
    ( $( $self:ty ),* ) => {
        $(
            impl<'a> SymmetryStateCheck for &'a [$self] {
                fn symmetry_state(self) -> SymmetryState {
                    // Test for symmetry or anti-symmetry
                    let mut state = SymmetryState::NonSymmetric;
                    let filter_size = self.len();
                    let half = filter_size / 2;
                    if filter_size & 1 > 0 {
                        state = SymmetryState::Symmetric;
                        for ii in 1..=half {
                            if (self[ii + half] - self[half - ii]).abs() > <$self>::EPSILON {
                                state = SymmetryState::NonSymmetric;
                                break;
                            }
                        }
                        if state == SymmetryState::NonSymmetric {
                            state = SymmetryState::AntiSymmetric;
                            for ii in 1..=half {
                                if (self[ii + half] + self[half - ii]).abs() > <$self>::EPSILON {
                                    state = SymmetryState::NonSymmetric;
                                    break;
                                }
                            }
                        }
                    }
                    state
                }
            }
        )*
    }
}

impl_symmetry_state_for_unsigned!(u8, u16, u32, u64);
impl_symmetry_state_for_signed!(i8, i16, i32, i64);
impl_symmetry_state_for_fp!(f32, f64);

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

    #[test] // Results verified with SciPy. (v1.9.0)
    fn test_symmetry_state() {
        assert_eq!(symmetry_state(&[1.0, 1.0][..]), SymmetryState::NonSymmetric);
        assert_eq!(symmetry_state(&[1.0, 1.0, 2.0][..]), SymmetryState::NonSymmetric);
        assert_eq!(symmetry_state(&[1.0, 2.0, 0.0][..]), SymmetryState::NonSymmetric);
        assert_eq!(symmetry_state(&[1.0, 2.0, 1.000000001][..]), SymmetryState::NonSymmetric);

        assert_eq!(symmetry_state(&[-1.0, 2.0, -1.0][..]), SymmetryState::Symmetric);
        assert_eq!(symmetry_state(&[1.0, 2.0, 1.0][..]), SymmetryState::Symmetric);
        assert_eq!(symmetry_state(&[1.0, 2.0, 1.0, 2.0, 1.0][..]), SymmetryState::Symmetric);

        assert_eq!(symmetry_state(&[-1.0, 2.0, 1.0][..]), SymmetryState::AntiSymmetric);
        assert_eq!(symmetry_state(&[1.0, 2.0, -1.0][..]), SymmetryState::AntiSymmetric);
        assert_eq!(symmetry_state(&[1.0, 2.0, 1.0, -2.0, -1.0][..]), SymmetryState::AntiSymmetric);
        assert_eq!(symmetry_state(&[1.0, 2.0, -1.0, -2.0, -1.0][..]), SymmetryState::AntiSymmetric);
    }
}