bpm-ocr 0.2.0

A library for attempting to extract a blood pressure monitor reading from an image using opencv.
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
135
136
137
138
139
140
141
142
143
144
145

use std::rc::Rc;

use opencv::core::{Mat, Size, Vector};
use opencv::imgcodecs::ImreadModes;
use opencv::{imgcodecs, imgproc};

use crate::debug::BpmOcrDebugOutputter;
use crate::lcd_number_extractor::LcdNumberExtractor;
use crate::lcd_screen_extractor::LcdScreenExtractor;
use crate::models::{BloodPressureReading, ProcessingError};
pub mod debug;
mod digit_extractor;
mod lcd_number_extractor;
mod lcd_screen_extractor;
pub mod models;
mod rectangle;

pub struct BloodPressureReadingExtractor<T: BpmOcrDebugOutputter> {
    screen_extractor: LcdScreenExtractor<T>,
    screen_number_extractor: LcdNumberExtractor<T>,
    debugger: Rc<T>
}

impl<T: BpmOcrDebugOutputter> BloodPressureReadingExtractor<T> {
    pub fn new(debugger: T) -> Self {
        let shared_debugger = Rc::new(debugger);

        let screen_extractor = LcdScreenExtractor::new(&shared_debugger);
        let screen_number_extractor = LcdNumberExtractor::new(&shared_debugger);

        BloodPressureReadingExtractor {
            screen_extractor,
            screen_number_extractor,
            debugger: shared_debugger
        }
    }

    fn process_image(self: &Self, image: &Mat) -> Result<BloodPressureReading, ProcessingError> {
        self.debugger.debug_original_picture(&image)?;

        let mut resized_image = Mat::default();

        let interpolation: i32 = 0;
        imgproc::resize(
            &image,
            &mut resized_image,
            Size::new(800, 800),
            0.,
            0.,
            interpolation,
        )?;

        let birdseye_lcd_only = self.screen_extractor.extract_lcd(&resized_image)?;

        let reading = self
            .screen_number_extractor
            .extract_reading(&birdseye_lcd_only)?;

        Ok(reading)
    }

    /// Attempts to extract a blood pressure reading from a photo file of a blood pressure monitor screen
    /// * `filename` - the path to the photo file
    pub fn get_reading_from_file(
        self: &Self,
        filename: &str,
    ) -> Result<BloodPressureReading, ProcessingError> {
        let gray_scale_mode: i32 = ImreadModes::IMREAD_GRAYSCALE.into();
        let image = imgcodecs::imread(filename, gray_scale_mode)?;

        self.process_image(&image)
    }

    /// Attempts to extract a blood pressure reading from a byte buffer containing a photo file of a blood pressure monitor screen
    /// * `filename` - the byte buffer with the photo file
    pub fn get_reading_from_buffer(
        self: &Self,
        file_contents: Vec<u8>,
    ) -> Result<BloodPressureReading, ProcessingError> {
        let contents = Vector::from_slice(&file_contents);
        let image = imgcodecs::imdecode(&contents, ImreadModes::IMREAD_GRAYSCALE.into())?;

        self.process_image(&image)
    }
}


#[cfg(test)]
mod tests {
    use crate::debug::UnsafeTempFolderDebugger;

    use super::*;

    #[test]
    fn test_success_photo_at_angle() {
        let debugger: UnsafeTempFolderDebugger = UnsafeTempFolderDebugger::new("test_success", true);
        let testfile = Vec::from(include_bytes!("./test_resources/example_at_angle.jpg"));
        let extractor = BloodPressureReadingExtractor::new(debugger);

        let expected_result = BloodPressureReading {
            systolic: 133,
            diastolic: 93,
            pulse: 65
        };

        let result = extractor.get_reading_from_buffer(testfile).unwrap();

        assert_eq!(result, expected_result);
    }

    #[test]
    fn test_success_topdown_photo() {
        let debugger: UnsafeTempFolderDebugger = UnsafeTempFolderDebugger::new("test_topdown_photo", true);
        let testfile = Vec::from(include_bytes!("./test_resources/example_top_down.jpg"));
        let extractor = BloodPressureReadingExtractor::new(debugger);

        let expected_result = BloodPressureReading {
            systolic: 131,
            diastolic: 88,
            pulse: 77
        };

        let result = extractor.get_reading_from_buffer(testfile).unwrap();

        assert_eq!(result, expected_result);
    }

    #[test]
    fn test_with_2_digit() {
        let debugger: UnsafeTempFolderDebugger = UnsafeTempFolderDebugger::new("test_with_2_digit", true);
        let testfile = Vec::from(include_bytes!("./test_resources/contour_candidates.jpeg"));
        let extractor = BloodPressureReadingExtractor::new(debugger);

        let expected_result = BloodPressureReading {
            systolic: 123,
            diastolic: 85,
            pulse: 68
        };

        let result = extractor.get_reading_from_buffer(testfile).unwrap();

        assert_eq!(result, expected_result);
    }

}