ocr 0.1.1

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
96
97
98
99
100
101

//! Image Processing Service
//!
//! High-level service for image preprocessing and enhancement.
//! Coordinates between image loading, enhancement, and preprocessing components.

use super::{ImageProcessingError, ImageProcessingResult};
use crate::image::ImageProcessor;
use crate::core::image::OcrImage;
use crate::utils::Timer;

pub struct ImageProcessingService {
    max_dimensions: (u32, u32),
}

impl ImageProcessingService {
    pub fn new() -> Self {
        Self {
            max_dimensions: (10000, 10000),
        }
    }

    pub fn with_max_dimensions(width: u32, height: u32) -> Self {
        Self {
            max_dimensions: (width, height),
        }
    }

    pub async fn process_image_from_file(
        &self,
        path: &std::path::Path,
    ) -> Result<ImageProcessingResult, ImageProcessingError> {
        let timer = Timer::new();
        
        let original_data = tokio::fs::read(path)
            .await
            .map_err(|e| ImageProcessingError::LoadFailed(format!("Failed to read image: {}", e)))?;

        let image = image::load_from_memory(&original_data)
            .map_err(|e| ImageProcessingError::LoadFailed(format!("Failed to load image: {}", e)))?;

        let (width, height) = image.dimensions();
        if width > self.max_dimensions.0 || height > self.max_dimensions.1 {
            return Err(ImageProcessingError::DimensionsTooLarge { width, height });
        }

        let applied_ops = vec!["preprocessing".to_string()];
        let ocr_image = ImageProcessor::to_ocr_image(image, 300);
        let processed_image = ImageProcessor::preprocess_for_ocr(&ocr_image)
            .map_err(|e| ImageProcessingError::ProcessingFailed(e.to_string()))?;
        
        let processed_data = Self::image_to_bytes(processed_image);

        Ok(ImageProcessingResult {
            original_data,
            processed_data,
            processing_time_ms: timer.elapsed_ms(),
            applied_operations: applied_ops,
        })
    }

    pub async fn process_image_from_bytes(
        &self,
        data: &[u8],
    ) -> Result<ImageProcessingResult, ImageProcessingError> {
        let timer = Timer::new();
        
        let original_data = data.to_vec();
        let image = image::load_from_memory(&original_data)
            .map_err(|e| ImageProcessingError::LoadFailed(format!("Failed to load image: {}", e)))?;

        let applied_ops = vec!["preprocessing".to_string()];
        let ocr_image = ImageProcessor::to_ocr_image(image, 300);
        let processed_image = ImageProcessor::preprocess_for_ocr(&ocr_image)
            .map_err(|e| ImageProcessingError::ProcessingFailed(e.to_string()))?;
        
        let processed_data = Self::image_to_bytes(processed_image);

        Ok(ImageProcessingResult {
            original_data,
            processed_data,
            processing_time_ms: timer.elapsed_ms(),
            applied_operations: applied_ops,
        })
    }

    pub fn create_ocr_image(&self, data: &[u8], width: u32, height: u32) -> Result<OcrImage, ImageProcessingError> {
        OcrImage::from_raw_pixels(width, height, data.to_vec(), crate::core::image::ImageFormat::Grayscale, 300)
            .map_err(|e| ImageProcessingError::ProcessingFailed(e.to_string()))
    }

    fn image_to_bytes(ocr_image: &OcrImage) -> Vec<u8> {
        let gray = ocr_image.to_luma8();
        gray.into_raw()
    }
}

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