ocrs seems to be very slow compared to rusty_tesseract

[Raj2032]

This is my code for ocrs:

use std::{collections::VecDeque, path::PathBuf};

use image;
use ocrs::{OcrEngine, OcrEngineParams};
use rten;
use rten_imageio::read_image;
use rten_tensor::AsView;

const SAMPLE_CONTENTS_DIR: &str = "testing_images";
const MODELS_DIR: &str = "models";

mod ocrs_extras;
/// Read a file from a path that is relative to the crate root.
//fn read_file(path: &str) -> Result<Vec<u8>, std::io::Error>
fn read_file(path: &str) -> Vec<u8>
{
    //let mut abs_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    let mut abs_path = PathBuf::new();
    abs_path.push(path);
    return std::fs::read(abs_path).unwrap();
}
struct Args
{
    image: String,
}
//fn parse_args() -> Result<Args, lexopt::Error>
fn parse_args() -> Result<Args, lexopt::Error>
{
    use lexopt::prelude::*;

    let mut values = VecDeque::new();
    let mut parser = lexopt::Parser::from_env();

    while let Some(arg) = parser.next()?
    {
        match arg
        {
            Value(val) => values.push_back(val.string()?),
            Long("help") =>
            {
                println!(
                    "Usage: {bin_name} <image>",
                    bin_name = parser.bin_name().unwrap_or("hello_ocrs")
                );
                std::process::exit(0);
            }
            _ => return Err(arg.unexpected()),
        }
    }

    let image = values.pop_front().ok_or("missing `image` arg")?;

    Ok(Args{image})
}
fn main()
{

    let detection_model_data = read_file(&format!("{}/text-detection.rten", MODELS_DIR));
    let rec_model_data = read_file(&format!("{}/text-recognition.rten", MODELS_DIR));

    let detection_model = rten::Model::load(&detection_model_data).unwrap();
    let recognition_model = rten::Model::load(&rec_model_data).unwrap();

    let engine = OcrEngine::new(OcrEngineParams
    {
        detection_model: Some(detection_model),
        recognition_model: Some(recognition_model),
        ..Default::default()
    }).unwrap();

    //let img = image::open(&format!("{}/image.jpeg", SAMPLE_CONTENTS_DIR)).map(|image| image.into_rgb8()).unwrap();
    let img = read_image(&format!("{}/image.jpeg", SAMPLE_CONTENTS_DIR)).unwrap();
    //ocrs_extras::preprocess::test();
    //let img_source = ocrs_extras::preprocess::ImageSource::from_bytes(img.as_raw(), img.dimensions()).unwrap();

    let ocr_input = engine.prepare_input(img.view()).unwrap();

    // Get oriented bounding boxes of text words in input image.
    let word_rects = engine.detect_words(&ocr_input).unwrap(); // Slow

    // Group words into lines. Each line is represented by a list of word
    // bounding boxes.
    let line_rects = engine.find_text_lines(&ocr_input, &word_rects);

    // Recognize the characters in each line.
    let line_texts = engine.recognize_text(&ocr_input, &line_rects).unwrap(); // Slow

    for line in line_texts
    .iter()
    .flatten()
    // Filter likely spurious detections. With future model improvements
    // this should become unnecessary.
    .filter(|l| l.to_string().len() > 1)
    {
        println!("for loop: {}", line);
    }

}

and this is my code for rusty_tesseract

use std::collections::HashMap;
//use opencv::{core, imgcodecs, imgproc, prelude::*};
use opencv::{imgcodecs, imgproc, prelude::*, text::{OCRTesseract, OCR_LEVEL_WORD}};
use rusty_tesseract::{Image, Args};
use image::{DynamicImage, GenericImageView, ImageBuffer, Rgba};

use std::env;
//use ocrs;
const SAMPLE_CONTENTS_DIR: &str = "testing_images";
fn main()
{    
    env::set_var("TESSDATA_PREFIX", "/usr/share/tessdata");

    let img = Image::from_path(&format!("{}/image.jpeg", SAMPLE_CONTENTS_DIR)).unwrap();
    //let args: Args = Args::default();
    
    let args = Args
    {
        lang: "eng".to_string(),
        config_variables: HashMap::from([(
                "tessedit_char_whitelist".into(),
                "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".into(),
            )]),
        dpi: Some(150),
        psm: Some(6),
        oem: Some(3)
    };
    
    let output = rusty_tesseract::image_to_string(&img, &args).unwrap();

    println!("output: {}", output);
}

Whilst ocrs actually gives me better results (though I could maybe use a different model of tesseract or use better settings), ocrs takes much longer to process compared to rusty_tesseract, plus uses a lot of processing resources while running this.

I used multiple sample images.

I am currenlt using 0.6.0 for ocrs, not too sure if in the new version it resolves this issue or there is some adjustments I need to do to speed it up?

[robertknight]

Whilst ocrs actually gives me better results (though I could maybe use a different model of tesseract or use better settings), ocrs takes much longer to process compared to rusty_tesseract, plus uses a lot of processing resources while running this.

The first thing to check is that you are building ocrs in release mode. Debug builds will be extremely slow. Either build your whole application with cargo's --release flag or enable this just for the ocrs and rten* crates.

• Can you provide examples of typical processing time per image for both ocrs and rusty_tesseract?
• How large are your input images? If you can provide an example image that would be useful.

Regarding resource usage, Ocrs will automatically use multiple threads. The default number of threads is determined by the Rayon library. You can customize this by setting the RAYON_NUM_THREADS environment variable or by calling ThreadPoolBuilder::build_global at the top of your program. The optimal number of threads for best performance is the number of physical CPU cores you have. By default Rayon may pick a larger number (usually 2x), as it uses the number of logical cores. I plan to change this default in future. You can use a smaller number to trade slower runtime for less resource usage.

[robertknight]

Weird, I am using now cargo r --release and this actually crashes my computer (by switching it off and then it turn itself back on).

Does it crash when building only (using cargo build --release) or when running?

Can you reproduce the problem even if only one thread is used? Before running set:

export RAYON_NUM_THREADS=1

CPU is: Intel(R) Core(TM) i7-4790K CPU @ 4.00GHz. Maybe there are certain features which requires extra volts for my CPU, I need to overvolt my CPU?

That's plenty of computing power, you don't need to overclock it or anything.

There was an issue with older CPUs (older than yours) in ocrs v0.5.0, but that got fixed in v0.6.0. That problem caused the program to crash, but not the whole system.

[Raj2032]

@robertknight hey mate:

Does it crash when building only (using cargo build --release) or when running?

no it only crashes if I did cargo r --release. When I cd into the target/release directory, then when I run the program directly then it errored out cause it could not find the image directory but it did not crash my computer, meaining if it did not panic then at some line the program crashes

Can you reproduce the problem even if only one thread is used? Before running set:

Not too sure where to add this, so I can add let pool = rayon::ThreadPoolBuilder::new().num_threads(1).build().unwrap(); into my main.rs if that is the same thing?

Weird I just added rayon = "1.10.0" into Cargo.toml file in vscode and it crashed my computer again as soon as I saved it. all though when I started it up and saved the project it did not crash so yeah weird.

Anyways tried addiing this to the top of the main() function and yes it crashed again after I executed it. Somthing to do with rayon library or something?

That's plenty of computing power, you don't need to overclock it or anything.

I see, maybe I need to do a BIOS update (got the gaming computer 10 years ago never did a bios update)? Maybe the program is accessing certain features the CPU cannot handle or something and I should do a bios update?

There was an issue with older CPUs (older than yours) in ocrs v0.5.0, but that got fixed in v0.6.0. That problem caused the program to crash, but not the whole system.

I assume maybe then that problem is compeltly different to my problem.

[robertknight]

I see, maybe I need to do a BIOS update (got the gaming computer 10 years ago never did a bios update)? Maybe the program is accessing certain features the CPU cannot handle or something and I should do a bios update?

That might be worth trying, along with any system updates that are available. If a program tries to use CPU instructions that aren't available, that would normally just crash the program with an "illegal instruction" error. If the entire computer crashes, that suggests a lower-level system problem of some kind.

[Raj2032]

@robertknight I just checked for my bios updates https://www.gigabyte.com/Motherboard/GA-Z97X-SOC-rev-10/support#support-dl-bios

and there are no improvements for 4th gen intel cpu (which is what I am using), only for 5th gen cpu.

Also in any line of my code, does it use GPU rather than CPU?

or enable this just for the ocrs and rten* crates.

Do you think I should try this instead?

Edit: Just tried the alternative same thing, I tried using level 2 and even level 1 causes the same issue, so as soon as I optimise it it then causes this issue.

Edit: After pausing my code in random places, this is where where it crashes as soon as it gets up to:

let word_rects = engine.detect_words(&ocr_input).unwrap(); // Slow

ANy idea why this is happening?

[Raj2032]

@robertknight Anyways I am going to file a formal issue regarding this.