Struct PdfDocument 

pub struct PdfDocument {
    pub pages: Vec<PdfPage>,
}

A parsed PDF: per-page text cells and page images.

Fields

pages: Vec<PdfPage>

Implementations

impl PdfDocument

pub fn open(bytes: &[u8], password: Option<&str>) -> Result<Self, PdfiumError>

Parse a PDF from bytes, optionally decrypting with password.

Note: this materialises every page’s rendered bitmap in memory at once. For large documents prefer for_each_page, which streams.

Examples found in repository

examples/dump_stages.rs (line 10)

fn main() {
    let path = std::env::args().nth(1).expect("pdf");
    let out = std::env::args().nth(2).expect("out_dir");
    let bytes = std::fs::read(&path).expect("read");
    let doc = PdfDocument::open(&bytes, None).expect("open");
    let page = &doc.pages[0];
    page.image.save(format!("{out}/my_page.png")).unwrap();
    println!("my_page: {}x{}", page.image.width(), page.image.height());

    let sf = 1024.0 / page.image.height() as f32;
    let pw = (page.image.width() as f32 * sf).round() as u32;
    let p1024 = imageops::thumbnail(&page.image, pw, 1024);
    p1024.save(format!("{out}/my_p1024.png")).unwrap();
    println!("my_p1024: {}x{}", p1024.width(), p1024.height());
}

examples/extract.rs (line 6)

fn main() {
    let path = std::env::args().nth(1).expect("usage: extract <file.pdf>");
    let bytes = std::fs::read(&path).expect("read pdf");
    match fleischwolf_pdf::PdfDocument::open(&bytes, None) {
        Ok(doc) => {
            for (i, page) in doc.pages.iter().enumerate() {
                println!(
                    "--- page {} ({:.0}x{:.0}, {} cells) ---",
                    i + 1,
                    page.width,
                    page.height,
                    page.cells.len()
                );
                for c in page.cells.iter().take(8) {
                    println!(
                        "  [{:.0},{:.0},{:.0},{:.0}] {:?}",
                        c.l, c.t, c.r, c.b, c.text
                    );
                }
            }
        }
        Err(e) => eprintln!("ERROR: {e}"),
    }
}

examples/layout.rs (line 10)

fn main() {
    let path = std::env::args().nth(1).expect("usage: layout <file.pdf>");
    let bytes = std::fs::read(&path).expect("read pdf");
    let doc = PdfDocument::open(&bytes, None).expect("open pdf");
    let mut model = LayoutModel::load().expect("load layout model");
    for (i, page) in doc.pages.iter().enumerate().take(1) {
        let regions = model
            .predict(&page.image, page.width, page.height)
            .expect("predict");
        println!(
            "page {} ({:.0}x{:.0}): {} regions",
            i + 1,
            page.width,
            page.height,
            regions.len()
        );
        let mut rs = regions.clone();
        rs.sort_by(|a, b| a.t.total_cmp(&b.t));
        for r in &rs {
            println!(
                "  {:<16} {:.2}  [{:.0},{:.0},{:.0},{:.0}]",
                r.label, r.score, r.l, r.t, r.r, r.b
            );
        }
    }
}

examples/dump_regions.rs (line 8)

fn main() {
    let path = std::env::args().nth(1).expect("pdf");
    let bytes = std::fs::read(&path).expect("read");
    let doc = PdfDocument::open(&bytes, None).expect("open");
    let mut layout = LayoutModel::load().expect("layout");
    for (pi, page) in doc.pages.iter().enumerate() {
        let regions = layout
            .predict(&page.image, page.width, page.height)
            .expect("layout");
        for r in &regions {
            // crude text: cells whose center is inside the region
            let txt: String = page
                .cells
                .iter()
                .filter(|c| {
                    let (cx, cy) = ((c.l + c.r) / 2.0, (c.t + c.b) / 2.0);
                    cx >= r.l && cx <= r.r && cy >= r.t && cy <= r.b
                })
                .map(|c| c.text.trim())
                .collect::<Vec<_>>()
                .join(" ");
            let tail: String = txt
                .chars()
                .rev()
                .take(40)
                .collect::<Vec<_>>()
                .into_iter()
                .rev()
                .collect();
            println!(
                "p{} {:>14} t={:6.1} b={:6.1} | …{}",
                pi + 1,
                r.label,
                r.t,
                r.b,
                tail
            );
        }
        // raw line cells in extraction order (to inspect RTL ordering)
        if std::env::var("DUMP_CELLS").is_ok() {
            for (ci, c) in page.cells.iter().enumerate() {
                let snip: String = c.text.chars().take(300).collect();
                println!(
                    "   CELL[{ci}] t={:6.1} l={:6.1} r={:6.1} | {}",
                    c.t, c.l, c.r, snip
                );
            }
        }
    }
}

examples/tf_otsl.rs (line 27)

fn main() {
    let path = std::env::args().nth(1).expect("usage: tf_otsl <pdf>");
    let bytes = std::fs::read(&path).expect("read");
    let doc = PdfDocument::open(&bytes, None).expect("open");
    let mut layout = LayoutModel::load().expect("layout");
    let mut tf = TableFormer::load().expect("tableformer models missing");
    for (pi, page) in doc.pages.iter().enumerate() {
        let regions = layout
            .predict(&page.image, page.width, page.height)
            .expect("layout");
        // docling resizes the whole page to 1024px height (cv2.INTER_AREA), then
        // crops the table bbox out of *that*. Replicate exactly.
        let sf = 1024.0 / page.image.height() as f32;
        let pw1024 = (page.image.width() as f32 * sf) as u32; // docling: int(w*r)
        let page1024 = fleischwolf_pdf::resample::inter_area(&page.image, pw1024, 1024);
        for r in regions.iter().filter(|r| r.label == "table") {
            // bbox (points) → 1024px-page coords: scale*sf = 1024/page_h_pt;
            // docling rounds the crop edges.
            let k = 1024.0 / page.height;
            let x = (r.l * k).round().max(0.0) as u32;
            let y = (r.t * k).round().max(0.0) as u32;
            let x2 = (r.r * k).round() as u32;
            let y2 = (r.b * k).round() as u32;
            let (w, h) = (x2 - x, y2 - y);
            let crop = imageops::crop_imm(&page1024, x, y, w, h).to_image();
            let cells = tf.predict_table_structure(&crop).expect("predict");
            println!(
                "page {} table {}x{}px -> {} cells",
                pi + 1,
                w,
                h,
                cells.len()
            );
            for c in &cells {
                println!(
                    "  r{} c{} {}x{} {} | cxcywh {:.4} {:.4} {:.4} {:.4}",
                    c.row,
                    c.col,
                    c.colspan,
                    c.rowspan,
                    name(c.tag),
                    c.cx,
                    c.cy,
                    c.w,
                    c.h
                );
            }
        }
    }
}