radsym 0.1.2

Radial symmetry detection: center proposals, local support analysis, scoring, and refinement
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

//! Geometric hypothesis types for local support analysis.
//!
//! These types pair geometric primitives with a confidence score and are the
//! primary inputs to support extraction, scoring, and refinement.

use crate::core::geometry::{Annulus, Circle, Ellipse};
use crate::core::scalar::Scalar;

/// A circle hypothesis with confidence.
#[derive(Debug, Clone, Copy)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CircleHypothesis {
    /// The circle geometry.
    pub circle: Circle,
    /// Confidence score from proposal or prior stage.
    pub confidence: Scalar,
}

impl CircleHypothesis {
    /// Create a new circle hypothesis.
    #[inline]
    pub fn new(circle: Circle, confidence: Scalar) -> Self {
        Self { circle, confidence }
    }
}

/// An ellipse hypothesis with confidence.
#[derive(Debug, Clone, Copy)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EllipseHypothesis {
    /// The ellipse geometry.
    pub ellipse: Ellipse,
    /// Confidence score.
    pub confidence: Scalar,
}

impl EllipseHypothesis {
    /// Create a new ellipse hypothesis.
    #[inline]
    pub fn new(ellipse: Ellipse, confidence: Scalar) -> Self {
        Self {
            ellipse,
            confidence,
        }
    }
}

impl From<CircleHypothesis> for EllipseHypothesis {
    fn from(ch: CircleHypothesis) -> Self {
        Self {
            ellipse: ch.circle.into(),
            confidence: ch.confidence,
        }
    }
}

/// An annulus (ring) hypothesis with confidence.
#[derive(Debug, Clone, Copy)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AnnulusHypothesis {
    /// The annulus geometry.
    pub annulus: Annulus,
    /// Confidence score.
    pub confidence: Scalar,
}

impl AnnulusHypothesis {
    /// Create a new annulus hypothesis.
    #[inline]
    pub fn new(annulus: Annulus, confidence: Scalar) -> Self {
        Self {
            annulus,
            confidence,
        }
    }
}

/// A concentric pair hypothesis: two ellipses sharing a center.
#[derive(Debug, Clone, Copy)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ConcentricPairHypothesis {
    /// Inner ellipse.
    pub inner: Ellipse,
    /// Outer ellipse.
    pub outer: Ellipse,
    /// Confidence score.
    pub confidence: Scalar,
}

impl ConcentricPairHypothesis {
    /// Create a new concentric pair hypothesis.
    #[inline]
    pub fn new(inner: Ellipse, outer: Ellipse, confidence: Scalar) -> Self {
        Self {
            inner,
            outer,
            confidence,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::core::coords::PixelCoord;

    #[test]
    fn circle_to_ellipse_hypothesis() {
        let c = Circle::new(PixelCoord::new(10.0, 20.0), 5.0);
        let ch = CircleHypothesis::new(c, 0.9);
        let eh: EllipseHypothesis = ch.into();
        assert_eq!(eh.ellipse.semi_major, 5.0);
        assert_eq!(eh.ellipse.semi_minor, 5.0);
        assert_eq!(eh.confidence, 0.9);
    }

    #[test]
    fn annulus_hypothesis() {
        let a = Annulus::new(PixelCoord::new(0.0, 0.0), 5.0, 10.0);
        let ah = AnnulusHypothesis::new(a, 0.8);
        assert_eq!(ah.annulus.thickness(), 5.0);
        assert_eq!(ah.confidence, 0.8);
    }

    #[test]
    fn concentric_pair() {
        let inner = Ellipse::new(PixelCoord::new(50.0, 50.0), 10.0, 8.0, 0.0);
        let outer = Ellipse::new(PixelCoord::new(50.0, 50.0), 20.0, 16.0, 0.0);
        let cp = ConcentricPairHypothesis::new(inner, outer, 0.75);
        assert_eq!(cp.inner.semi_major, 10.0);
        assert_eq!(cp.outer.semi_major, 20.0);
    }
}