ocr 0.1.2

A pure Rust CLI OCR tool for printed text extraction
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

//! Configuration Service
//!
//! High-level service for configuration management and validation.
//! Handles loading, saving, and validating OCR configuration.

use super::ConfigurationError;
use crate::core::config::OcrConfig;
use std::path::Path;

pub struct ConfigurationService {
    config: OcrConfig,
}

impl ConfigurationService {
    pub fn new() -> Self {
        Self {
            config: OcrConfig::default(),
        }
    }

    pub fn load_from_file<P: AsRef<Path>>(
        &self,
        path: P,
    ) -> Result<OcrConfig, ConfigurationError> {
        let content = std::fs::read_to_string(path)
            .map_err(|e| ConfigurationError::LoadFailed(format!("Failed to read config file: {}", e)))?;
        
        let config: OcrConfig = serde_json::from_str(&content)
            .map_err(|e| ConfigurationError::LoadFailed(format!("Failed to parse config: {}", e)))?;
        
        self.validate(&config)?;
        Ok(config)
    }

    pub fn save_to_file<P: AsRef<Path>>(
        &self,
        config: &OcrConfig,
        path: P,
    ) -> Result<(), ConfigurationError> {
        let content = serde_json::to_string_pretty(config)
            .map_err(|e| ConfigurationError::SaveFailed(format!("Failed to serialize config: {}", e)))?;
        
        std::fs::write(path, content)
            .map_err(|e| ConfigurationError::SaveFailed(format!("Failed to write config file: {}", e)))?;
        
        Ok(())
    }

    pub fn validate(&self, config: &OcrConfig) -> Result<(), ConfigurationError> {
        config.validate()
            .map_err(|e| ConfigurationError::ValidationFailed(e.to_string()))?;
        Ok(())
    }

    pub fn create_default(&self) -> OcrConfig {
        OcrConfig::default()
    }

    pub fn get_config(&self) -> &OcrConfig {
        &self.config
    }

    pub fn set_config(&mut self, config: OcrConfig) {
        self.config = config;
    }

    pub fn merge_configs(
        &self,
        base: &OcrConfig,
        override_config: &OcrConfig,
    ) -> OcrConfig {
        let mut merged = base.clone();
        
        if override_config.recognition.language != "en" {
            merged.recognition.language = override_config.recognition.language.clone();
        }
        if override_config.recognition.confidence_threshold != 0.5 {
            merged.recognition.confidence_threshold = override_config.recognition.confidence_threshold;
        }
        if override_config.recognition.engine != crate::core::config::RecognitionEngine::LSTM {
            merged.recognition.engine = override_config.recognition.engine;
        }
        if override_config.performance.device != "auto" {
            merged.performance.device = override_config.performance.device.clone();
        }
        
        merged
    }
}

impl Default for ConfigurationService {
    fn default() -> Self {
        Self::new()
    }
}