use anyhow::{Context, Result};
use pdf_extract::{MediaBox, OutputDev, OutputError, Transform};
use super::{PageRuns, TextRun, TextSource};
pub struct PureSource;
impl TextSource for PureSource {
fn pages(&self, pdf_bytes: &[u8]) -> Result<Vec<PageRuns>> {
let mut doc =
pdf_extract::Document::load_mem(pdf_bytes).context("lopdf could not parse the PDF")?;
if doc.is_encrypted() {
doc.decrypt("")
.context("PDF is encrypted with a non-empty password")?;
}
let mut collector = RunCollector::default();
pdf_extract::output_doc(&doc, &mut collector)
.map_err(|e| anyhow::anyhow!("pdf-extract failed to walk the document: {e}"))?;
Ok(collector.pages)
}
}
const WORD_GAP_EMS: f32 = 0.1;
const RUN_BREAK_EMS: f32 = 2.0;
const BASELINE_SHIFT_EMS: f32 = 0.25;
#[derive(Default)]
struct RunCollector {
pages: Vec<PageRuns>,
current: Option<TextRun>,
origin: (f32, f32),
}
impl RunCollector {
fn flush(&mut self) {
if let Some(run) = self.current.take() {
if !run.text.trim().is_empty() {
if let Some(page) = self.pages.last_mut() {
page.runs.push(run);
}
}
}
}
}
impl OutputDev for RunCollector {
fn begin_page(
&mut self,
_page_num: u32,
media_box: &MediaBox,
_art_box: Option<(f64, f64, f64, f64)>,
) -> std::result::Result<(), OutputError> {
self.flush();
self.origin = (media_box.llx as f32, media_box.lly as f32);
self.pages.push(PageRuns {
width: (media_box.urx - media_box.llx) as f32,
height: (media_box.ury - media_box.lly) as f32,
runs: Vec::new(),
});
Ok(())
}
fn end_page(&mut self) -> std::result::Result<(), OutputError> {
self.flush();
Ok(())
}
fn output_character(
&mut self,
trm: &Transform,
width: f64,
_spacing: f64,
font_size: f64,
char: &str,
) -> std::result::Result<(), OutputError> {
let em_x = (trm.m11 + trm.m21) * font_size;
let em_y = (trm.m12 + trm.m22) * font_size;
let size = ((em_x * em_y).abs().sqrt()) as f32;
if size <= 0.0 {
return Ok(()); }
let x = trm.m31 as f32 - self.origin.0;
let y = trm.m32 as f32 - self.origin.1;
let advance = width as f32 * size;
let page = self.pages.len().saturating_sub(1);
let mut split = true;
let mut word_gap = false;
if let Some(run) = &self.current {
let same_page = run.page == page;
let same_baseline = (y - run.bbox.1).abs() <= BASELINE_SHIFT_EMS * size;
let same_size = (size - run.font_size).abs() <= 0.1;
let gap = x - run.bbox.2;
if same_page && same_baseline && same_size && gap <= RUN_BREAK_EMS * size {
split = false;
word_gap = gap > WORD_GAP_EMS * size;
}
}
if split {
self.flush();
self.current = Some(TextRun {
text: String::new(),
bbox: (x, y, x, y + size),
font_size: size,
bold: false,
italic: false,
font: None,
page,
});
}
let run = self.current.as_mut().expect("run was just ensured");
if word_gap && !run.text.ends_with(' ') && !char.starts_with(' ') {
run.text.push(' ');
}
run.text.push_str(char);
run.bbox.2 = (x + advance).max(run.bbox.2);
run.bbox.3 = run.bbox.3.max(y + size);
Ok(())
}
fn begin_word(&mut self) -> std::result::Result<(), OutputError> {
Ok(())
}
fn end_word(&mut self) -> std::result::Result<(), OutputError> {
Ok(())
}
fn end_line(&mut self) -> std::result::Result<(), OutputError> {
Ok(())
}
}