rusty-tesseract 1.1.10

A Rust wrapper for Google Tesseract
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

use super::*;
use core::fmt;

#[derive(Debug, PartialEq)]
pub struct ConfigParameterOutput {
    pub output: String,
    pub config_parameters: Vec<ConfigParameter>,
}

impl fmt::Display for ConfigParameterOutput {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.output)
    }
}

#[derive(Debug, PartialEq)]
pub struct ConfigParameter {
    pub name: String,
    pub default_value: String,
    pub description: String,
}

impl fmt::Display for ConfigParameter {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{} {} {}",
            self.name, self.default_value, self.description,
        )
    }
}

impl FromLine for ConfigParameter {
    fn from_line(line: &str) -> Option<Self> {
        let (name, x) = line.split_once("\t")?;
        let (default_value, description) = x.split_once("\t")?;

        Some(ConfigParameter {
            name: name.into(),
            default_value: default_value.into(),
            description: description.into(),
        })
    }
}

pub fn get_tesseract_config_parameters() -> TessResult<ConfigParameterOutput> {
    let mut command = get_tesseract_command();
    command.arg("--print-parameters");

    let output = run_tesseract_command(&mut command)?;

    let config_parameters = string_to_config_parameter_output(&output)?;

    Ok(ConfigParameterOutput {
        output,
        config_parameters,
    })
}

fn string_to_config_parameter_output(output: &str) -> TessResult<Vec<ConfigParameter>> {
    output
        .lines()
        .skip(1)
        .map(|line| ConfigParameter::parse(line))
        .collect::<_>()
}

#[cfg(test)]
mod tests {
    use crate::{output_config_parameters::string_to_config_parameter_output, *};

    #[test]
    fn test_string_to_config_parameter_output() {
        let result = string_to_config_parameter_output(
            "Tesseract parameters:\n\
        log_level\t2147483647\tLogging level\n\
        textord_dotmatrix_gap\t3\t pixel gap for broken pixed pitch\n\
        textord_debug_block\t0\tBlock to do debug on\n\
        textord_pitch_range\t2\tMax range test on pitch",
        )
        .unwrap();

        let expected = ConfigParameter {
            name: "log_level".into(),
            default_value: "2147483647".into(),
            description: "Logging level".into(),
        };

        assert_eq!(result.first().unwrap(), &expected);
    }

    #[test]
    fn test_get_tesseract_config_parameters() {
        let result = get_tesseract_config_parameters().unwrap();
        let x = result
            .config_parameters
            .iter()
            .find(|&x| x.name == "tessedit_char_whitelist")
            .unwrap();

        let expected = ConfigParameter {
            name: "tessedit_char_whitelist".into(),
            default_value: "".into(),
            description: "Whitelist of chars to recognize".into(),
        };

        assert_eq!(*x, expected);
    }

    #[test]
    fn test_string_to_config_parameter_output_parse_error() {
        let result = string_to_config_parameter_output(
            "Tesseract parameters:\n\
        log_level\t2147483647\tLogging level\n\
        Test\n\
        textord_debug_block\t0\tBlock to do debug on\n\
        textord_pitch_range\t2\tMax range test on pitch",
        );
        assert_eq!(
            result,
            Err(TessError::ParseError("invalid line 'Test'".into()))
        )
    }
}