pdf-engine 1.0.0-beta.17

Unified PDF rendering engine — page rendering, text extraction, thumbnails.
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

//! Adversarial audit of extract_tables(): per-table failure-mode classification.
//! Emits one JSON line per table. Run: table_audit <pdf>

use pdf_engine::PdfDocument;

fn main() {
    let path = std::env::args().nth(1).expect("usage: <pdf>");
    let data = std::fs::read(&path).expect("read");
    let doc = PdfDocument::open(data).expect("open");
    let name = std::path::Path::new(&path)
        .file_stem()
        .unwrap()
        .to_string_lossy();
    for t in doc.extract_tables() {
        let n_rows = t.n_rows();
        let n_cols = t.n_cols;
        let total = n_rows * n_cols;
        let filled: usize = t
            .rows
            .iter()
            .flatten()
            .filter(|c| !c.text.is_empty())
            .count();
        let empty: usize = t
            .rows
            .iter()
            .flatten()
            .filter(|c| c.text.is_empty())
            .count();
        // spacing artifact: cells where >40% of "words" are single chars (e.g. "I R S")
        let mut artifact_cells = 0usize;
        let mut nonempty_cells = 0usize;
        let mut single_cell_rows = 0usize;
        for row in &t.rows {
            if row.len() <= 1 {
                single_cell_rows += 1;
            }
            for c in row {
                if c.text.is_empty() {
                    continue;
                }
                nonempty_cells += 1;
                let words: Vec<&str> = c.text.split(' ').collect();
                let singles = words.iter().filter(|w| w.chars().count() == 1).count();
                if words.len() >= 4 && singles as f64 / words.len() as f64 > 0.4 {
                    artifact_cells += 1;
                }
            }
        }
        // row-length irregularity => probable spans
        let row_lens: Vec<usize> = t.rows.iter().map(|r| r.len()).collect();
        let distinct_lens = {
            let mut v = row_lens.clone();
            v.sort_unstable();
            v.dedup();
            v.len()
        };
        let is_layout = n_cols <= 1;
        let is_data_candidate = t.rectangular && n_cols >= 2 && n_rows >= 2 && !is_layout;
        println!(
            "{{\"doc\":\"{name}\",\"ti\":{},\"rows\":{n_rows},\"cols\":{n_cols},\"rect\":{},\"layout\":{is_layout},\"data_candidate\":{is_data_candidate},\"distinct_row_lens\":{distinct_lens},\"single_cell_rows\":{single_cell_rows},\"empty_cells\":{empty},\"total_cells\":{total},\"cov\":{:.3},\"artifact_cells\":{artifact_cells},\"nonempty_cells\":{nonempty_cells}}}",
            t.table_index, t.rectangular, t.cell_coverage,
        );
        let _ = filled;
    }
}