globox 0.1.0

Parse, convert and evaluate bounding box annotations
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

use crate::imgsize::ImgSize;
use crate::coords::{
    Coords,
    rel_to_abs,
    ltwh_to_ltrb,
    xywh_to_ltrb,
};

#[derive(Debug, Clone)]
pub struct BBox {
    pub label: String,
    xmin: f32, ymin: f32,
    xmax: f32, ymax: f32,
    conf: Option<f32>,
}

impl BBox {
    pub fn new<L: Into<String>>(
        label: L, 
        xmin: f32, 
        ymin: f32, 
        xmax: f32, 
        ymax: f32, 
        conf: Option<f32>
    ) -> Self {
        assert!(xmin <= xmax);
        assert!(ymin <= ymax);
        
        if let Some(conf) = conf {
            assert!(0.0 <= conf && conf <= 1.0);
        }

        Self { label: label.into(), xmin, ymin, xmax, ymax, conf }
    }
}

impl BBox {
    pub fn xmin(&self) -> f32 { self.xmin }
    pub fn ymin(&self) -> f32 { self.ymin }
    pub fn xmax(&self) -> f32 { self.xmax }
    pub fn ymax(&self) -> f32 { self.ymax }

    pub fn xmid(&self) -> f32 { (self.xmax + self.xmin) / 2.0 }
    pub fn ymid(&self) -> f32 { (self.ymax + self.ymin) / 2.0 }

    pub fn width(&self) -> f32 { self.xmax - self.xmin }
    pub fn height(&self) -> f32 { self.ymax - self.ymin }

    pub fn conf(&self) -> Option<f32> { self.conf }
}

impl BBox {
    pub fn ltrb(&self) -> Coords {
        (self.xmin(), self.ymin(), self.xmax(), self.ymax())
    }

    pub fn ltwh(&self) -> Coords {
        (self.xmin(), self.ymin(), self.width(), self.height())
    }

    pub fn xywh(&self) -> Coords {
        (self.xmid(), self.ymid(), self.width(), self.height())
    }
}

#[derive(Clone, Copy)]
pub enum BBoxFmt {
    LTRB, 
    LTWH, 
    XYWH,
}

impl BBox {
    pub fn create<L: Into<String>>(
        label: L, 
        coords: Coords, 
        fmt: BBoxFmt, 
        conf: Option<f32>, 
    ) -> Self {
        let (xmin, ymin, xmax, ymax) = match fmt {
            BBoxFmt::LTRB => coords,
            BBoxFmt::LTWH => ltwh_to_ltrb(coords),
            BBoxFmt::XYWH => xywh_to_ltrb(coords),
        };

        BBox::new(label, xmin, ymin, xmax, ymax, conf)
    }

    pub fn create_rel<L: Into<String>>(
        label: L, 
        coords: Coords, 
        fmt: BBoxFmt, 
        conf: Option<f32>,
        img_size: ImgSize,
    ) -> Self {
        let coords = rel_to_abs(coords, img_size);
        BBox::create(label, coords, fmt, conf)
    }
}

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

    #[test]
    fn test_creation() {
        let b = BBox::new("label", 10.0, 20.0, 30.0, 40.0, Some(0.25));
        
        assert_eq!(b.xmin(), 10.0);
        assert_eq!(b.ymin(), 20.0);
        assert_eq!(b.xmax(), 30.0);
        assert_eq!(b.ymax(), 40.0);

        assert_eq!(b.xmid(), 20.0);
        assert_eq!(b.ymid(), 30.0);

        assert_eq!(b.width(), 20.0);
        assert_eq!(b.height(), 20.0);

        assert_eq!(b.conf(), Some(0.25));
    }
}