mirror of
https://github.com/storytold/pdfcraft.git
synced 2026-11-20 09:21:31 +01:00
213 lines
8.4 KiB
Rust
213 lines
8.4 KiB
Rust
//! Scan & OCR ▸ Recognize text: render pages, read the words in them and add an invisible text
|
|
//! layer ([`Edit::AddOcrText`]), making scanned pages searchable and selectable.
|
|
//!
|
|
//! Recognition is slow (about a second a page), so it is split from the edit: [`Session::ocr_job`]
|
|
//! captures what it needs, [`OcrJob::run`] works anywhere (the UI runs it on a worker thread) and
|
|
//! [`Session::apply_ocr`] applies the result as one undoable step.
|
|
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
use printcraft_render::{PageInfo, PageRenderer, RenderConfig, RenderRequest, RequestKind};
|
|
|
|
pub use printcraft_ocr::{LANGUAGES, Models, Ocr, OcrError, PlacedWord};
|
|
|
|
use crate::{DocId, Edit, EditError, Session};
|
|
|
|
/// Recognize Text settings.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct OcrSettings {
|
|
/// Resolution pages are rendered at for recognition (Acrobat's "Downsample to" choices).
|
|
pub dpi: f32,
|
|
/// Language code from [`LANGUAGES`] (the models read the Latin alphabet, whatever this says).
|
|
pub language: String,
|
|
/// Leave pages that already have text alone (Acrobat reports "page contains renderable
|
|
/// text" and skips them).
|
|
pub skip_text_pages: bool,
|
|
}
|
|
|
|
impl Default for OcrSettings {
|
|
fn default() -> Self {
|
|
OcrSettings { dpi: 300.0, language: "en".into(), skip_text_pages: true }
|
|
}
|
|
}
|
|
|
|
/// What recognition found on one page.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct OcrPage {
|
|
pub page: usize,
|
|
pub words: Vec<PlacedWord>,
|
|
/// Why the page was not read, if it was skipped.
|
|
pub skipped: Option<String>,
|
|
}
|
|
|
|
impl OcrPage {
|
|
pub fn text(&self) -> String {
|
|
self.words.iter().map(|w| w.text.as_str()).collect::<Vec<_>>().join(" ")
|
|
}
|
|
}
|
|
|
|
/// The recogniser, loaded once (it takes a moment) and shared.
|
|
pub fn engine() -> Result<Arc<Ocr>, String> {
|
|
static OCR: Mutex<Option<Arc<Ocr>>> = Mutex::new(None);
|
|
let mut slot = OCR.lock().unwrap_or_else(|e| e.into_inner());
|
|
if let Some(o) = slot.as_ref() {
|
|
return Ok(o.clone());
|
|
}
|
|
let o = Arc::new(Ocr::find().map_err(|e| e.to_string())?);
|
|
*slot = Some(o.clone());
|
|
Ok(o)
|
|
}
|
|
|
|
/// Whether the recognition models are installed.
|
|
pub fn available() -> bool {
|
|
Models::find().is_some()
|
|
}
|
|
|
|
/// Everything recognition needs from a document, detached from the session.
|
|
pub struct OcrJob {
|
|
bytes: Arc<Vec<u8>>,
|
|
password: Option<String>,
|
|
infos: Vec<PageInfo>,
|
|
/// Per page: the render scale (pixels per point) that shows its images at their own
|
|
/// resolution, if it has any.
|
|
native: Vec<Option<f32>>,
|
|
pub pages: Vec<usize>,
|
|
pub settings: OcrSettings,
|
|
}
|
|
|
|
impl OcrJob {
|
|
/// Read the pages. `progress(done, total)` is called before each page; returning `false`
|
|
/// stops (the pages read so far are returned).
|
|
pub fn run(self, ocr: &Ocr, mut progress: impl FnMut(usize, usize) -> bool) -> Vec<OcrPage> {
|
|
let config = RenderConfig { password: self.password.as_deref().map(Arc::from), ..Default::default() };
|
|
let mut r = PageRenderer::new(self.bytes.clone(), config);
|
|
let mut out = Vec::new();
|
|
let total = self.pages.len();
|
|
for (done, &page) in self.pages.iter().enumerate() {
|
|
if !progress(done, total) {
|
|
break;
|
|
}
|
|
let Some(info) = self.infos.get(page) else { continue };
|
|
let skip = |why: &str| OcrPage { page, words: Vec::new(), skipped: Some(why.into()) };
|
|
if self.settings.skip_text_pages {
|
|
let t = r.render(RenderRequest { page, kind: RequestKind::Text, scale: 1.0, ..Default::default() });
|
|
if t.text.as_ref().is_some_and(|t| !t.plain_text().trim().is_empty()) {
|
|
out.push(skip("the page already contains text"));
|
|
continue;
|
|
}
|
|
}
|
|
// A scan is read at its own resolution (enlarging it only blurs the letters), at most
|
|
// the chosen one.
|
|
let wanted = self.settings.dpi.clamp(72.0, 600.0) / 72.0;
|
|
let scale = self.native.get(page).copied().flatten().map_or(wanted, |n| n.clamp(1.0, wanted));
|
|
let shot = r.render(RenderRequest { page, scale, ..Default::default() });
|
|
if let Some(e) = shot.error {
|
|
out.push(skip(&e));
|
|
continue;
|
|
}
|
|
let lines = match ocr.recognize(&shot.rgba, shot.width, shot.height) {
|
|
Ok(l) => l,
|
|
Err(e) => {
|
|
out.push(skip(&e.to_string()));
|
|
continue;
|
|
}
|
|
};
|
|
let scale = shot.width as f32 / info.width.max(1e-3);
|
|
let to_user = |x: f32, y: f32| {
|
|
let [u, v] = info.view_to_user(x / scale, y / scale);
|
|
[u as f64, v as f64]
|
|
};
|
|
let words = lines.iter().flat_map(|l| &l.words).map(|w| PlacedWord::place(w, to_user)).collect();
|
|
out.push(OcrPage { page, words, skipped: None });
|
|
}
|
|
progress(total, total);
|
|
out
|
|
}
|
|
}
|
|
|
|
impl Session {
|
|
/// Capture what recognising `pages` (0-based; empty = all) of document `id` needs.
|
|
pub fn ocr_job(&self, id: DocId, pages: &[usize], settings: OcrSettings) -> Option<OcrJob> {
|
|
let doc = self.get(id)?;
|
|
let all = doc.info.pages.len();
|
|
let pages: Vec<usize> = if pages.is_empty() { (0..all).collect() } else { pages.iter().copied().filter(|p| *p < all).collect() };
|
|
let native = (0..all)
|
|
.map(|p| {
|
|
if !pages.contains(&p) {
|
|
return None;
|
|
}
|
|
doc.page_images(p)
|
|
.iter()
|
|
.filter(|i| i.width > 1 && i.height > 1)
|
|
.map(|i| {
|
|
let m = i.matrix;
|
|
let (w, h) = (m[0].hypot(m[1]), m[2].hypot(m[3]));
|
|
(i.width as f64 / w.max(1e-6)).max(i.height as f64 / h.max(1e-6)) as f32
|
|
})
|
|
.reduce(f32::max)
|
|
})
|
|
.collect();
|
|
Some(OcrJob { bytes: doc.bytes.clone(), password: doc.password.clone(), infos: doc.info.pages.clone(), native, pages, settings })
|
|
}
|
|
|
|
/// Add the words found by [`OcrJob::run`] as one undoable step. Returns the number of words.
|
|
pub fn apply_ocr(&mut self, id: DocId, found: &[OcrPage]) -> Result<usize, EditError> {
|
|
let edits: Vec<Edit> =
|
|
found.iter().filter(|p| !p.words.is_empty()).map(|p| Edit::AddOcrText { page: p.page, words: p.words.clone() }).collect();
|
|
let words = found.iter().map(|p| p.words.len()).sum();
|
|
if !edits.is_empty() {
|
|
self.apply(id, Edit::Batch { label: "Recognize text".into(), edits })?;
|
|
}
|
|
Ok(words)
|
|
}
|
|
|
|
/// Recognise text on `pages` and add it, in one call (the CLI and agents use this).
|
|
pub fn recognize_text(&mut self, id: DocId, pages: &[usize], settings: OcrSettings) -> Result<Vec<OcrPage>, String> {
|
|
let job = self.ocr_job(id, pages, settings).ok_or("no such document")?;
|
|
if let Some(why) = self.get(id).and_then(|d| d.read_only_reason.clone()) {
|
|
return Err(why);
|
|
}
|
|
let ocr = engine()?;
|
|
let found = job.run(&ocr, |_, _| true);
|
|
self.apply_ocr(id, &found).map_err(|e| e.to_string())?;
|
|
Ok(found)
|
|
}
|
|
}
|
|
|
|
/// What [`recognize_file`] did to one file.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct FileResult {
|
|
/// The new file (incrementally saved), or the original when nothing was recognised.
|
|
pub bytes: Arc<Vec<u8>>,
|
|
pub pages: Vec<OcrPage>,
|
|
}
|
|
|
|
impl FileResult {
|
|
pub fn words(&self) -> usize {
|
|
self.pages.iter().map(|p| p.words.len()).sum()
|
|
}
|
|
}
|
|
|
|
/// Recognize text in multiple files: one PDF's bytes in, the searchable PDF out. `progress`
|
|
/// works as for [`OcrJob::run`].
|
|
pub fn recognize_file(
|
|
name: &str,
|
|
bytes: Arc<Vec<u8>>,
|
|
password: Option<&str>,
|
|
settings: OcrSettings,
|
|
ocr: &Ocr,
|
|
progress: impl FnMut(usize, usize) -> bool,
|
|
) -> Result<FileResult, String> {
|
|
let mut s = Session::new();
|
|
let id = s.open(name, None, bytes.clone(), password).map_err(|e| e.to_string())?;
|
|
if let Some(why) = s.get(id).and_then(|d| d.read_only_reason.clone()) {
|
|
return Err(why);
|
|
}
|
|
let job = s.ocr_job(id, &[], settings).ok_or("the document could not be read")?;
|
|
let pages = job.run(ocr, progress);
|
|
if s.apply_ocr(id, &pages).map_err(|e| e.to_string())? == 0 {
|
|
return Ok(FileResult { bytes, pages });
|
|
}
|
|
Ok(FileResult { bytes: s.save_bytes(id).map_err(|e| e.to_string())?, pages })
|
|
}
|