OAR (ONNXRuntime And Rust) OCR

A comprehensive OCR (Optical Character Recognition) library, built in Rust with ONNX Runtime for efficient inference.

Quick Start

Installation

Add OAROCR to your project's Cargo.toml:

cargo add oar-ocr

For CUDA support, add with the cuda feature:

cargo add oar-ocr --features cuda

Or manually add it to your Cargo.toml:

[dependencies]
oar-ocr = "0.2"

# For CUDA support
oar-ocr = { version = "0.2", features = ["cuda"] }

Basic Usage

Here's a simple example of how to use OAROCR to extract text from an image:

use oar_ocr::prelude::*;
use std::path::Path;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Build OCR pipeline with required models
    let ocr = OAROCRBuilder::new(
        "detection_model.onnx".to_string(),
        "recognition_model.onnx".to_string(),
        "char_dict.txt".to_string(),
    ).build()?;

    // Process a single image
    let image = oar_ocr::utils::load_image(Path::new("document.jpg"))?;
    let results = ocr.predict(&[image])?;
    let result = &results[0];

    // Print extracted text with confidence scores using the modern TextRegion API
    for text_region in &result.text_regions {
        if let (Some(text), Some(confidence)) = (&text_region.text, text_region.confidence) {
            println!("Text: {} (confidence: {:.2})", text, confidence);
        }
    }

    // Process multiple images at once
    let images = oar_ocr::utils::load_images_batch(&[
        Path::new("document1.jpg"),
        Path::new("document2.jpg"),
        Path::new("document3.jpg"),
    ])?;
    let results = ocr.predict(&images)?;

    for result in results {
        println!("Image {}: {} text regions found", result.index, result.text_regions.len());
        for text_region in &result.text_regions {
            if let (Some(text), Some(confidence)) = (&text_region.text, text_region.confidence) {
                println!("  Text: {} (confidence: {:.2})", text, confidence);
            }
        }
    }

    Ok(())
}

This example creates an OCR pipeline using pre-trained models for text detection and recognition. The pipeline processes the input image and returns structured TextRegion objects containing the recognized text, confidence scores, and bounding boxes for each detected text region.

Using CUDA for GPU Acceleration

For better performance, you can enable CUDA support to run inference on GPU:

use oar_ocr::prelude::*;
use oar_ocr::core::config::onnx::{OrtSessionConfig, OrtExecutionProvider};
use std::path::Path;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Configure CUDA execution provider for GPU acceleration
    let ort_config = OrtSessionConfig::new()
        .with_execution_providers(vec![
            OrtExecutionProvider::CUDA {
                device_id: Some(0),  // Use GPU 0
                gpu_mem_limit: None,
                arena_extend_strategy: None,
                cudnn_conv_algo_search: None,
                do_copy_in_default_stream: None,
                cudnn_conv_use_max_workspace: None,
            },
            OrtExecutionProvider::CPU,  // Fallback to CPU if CUDA fails
        ]);

    // Build OCR pipeline with CUDA support
    let ocr = OAROCRBuilder::new(
        "detection_model.onnx".to_string(),
        "recognition_model.onnx".to_string(),
        "char_dict.txt".to_string(),
    )
    .global_ort_session(ort_config)  // Apply CUDA config to all components
    .build()?;

    // Process images (same as CPU example)
    let image = oar_ocr::utils::load_image(Path::new("document.jpg"))?;
    let results = ocr.predict(&[image])?;
    let result = &results[0];

    // Extract text from results
    for text_region in &result.text_regions {
        if let (Some(text), Some(confidence)) = (&text_region.text, text_region.confidence) {
            println!("Text: {} (confidence: {:.2})", text, confidence);
        }
    }

    Ok(())
}

Note: To use CUDA support, you need to:

1. Install oar-ocr with CUDA feature: cargo add oar-ocr --features cuda
2. Have CUDA toolkit and cuDNN installed on your system
3. Ensure your ONNX models are compatible with CUDA execution

Pre-trained Models

OAROCR provides several pre-trained models for different OCR tasks. Download them from the GitHub Releases page.

Text Detection Models

Choose between mobile and server variants based on your needs:

• Mobile: Smaller, faster models suitable for real-time applications
• Server: Larger, more accurate models for high-precision requirements

Text Recognition Models

Recognition models are available in multiple versions and languages:

Chinese/General Models

Language-Specific Models

Character Dictionaries

Character dictionaries are required for text recognition models. Choose the appropriate dictionary for your models:

General Dictionaries

Language-Specific Dictionaries

Optional Models

These models provide additional functionality for specialized use cases:

Acknowledgments

This project builds upon the excellent work of several open-source projects:

• ort: Rust bindings for ONNX Runtime by pykeio. This crate provides the Rust interface to ONNX Runtime that powers the efficient inference engine in this OCR library.

• PaddleOCR: Baidu's awesome multilingual OCR toolkits based on PaddlePaddle. This project utilizes PaddleOCR's pre-trained models, which provide excellent accuracy and performance for text detection and recognition across multiple languages.