Struct TableFormer 

pub struct TableFormer { /* private fields */ }

Implementations

impl TableFormer

pub fn load() -> Option<Self>

Load the exported encoder/decoder/bbox ONNX graphs (env overrides, else models/tableformer/{encoder,decoder,bbox}.onnx). Returns None if any is absent, so the pipeline falls back to geometric reconstruction.

Examples found in repository

examples/tf_otsl.rs (line 29)

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
                );
            }
        }
    }
}

pub fn load_with(intra: usize) -> Option<Self>

Like load but with an explicit intra-op thread count, so a parallel page-worker pool can run each table model on fewer threads (the throughput comes from running pages concurrently, not from one fat model).

pub fn predict_otsl(&mut self, img: &RgbImage) -> Result<Vec<i64>, String>

Predict the OTSL structure-token sequence for a table-region image.

pub fn predict_table_structure( &mut self, img: &RgbImage, ) -> Result<Vec<TableCell>, String>

Full structure prediction: OTSL grid cells with per-cell boxes (in the 448 image, normalized cxcywh). Collects per-cell decoder hidden states using docling’s exact bbox bookkeeping (skip-after-row-break, first-lcel of a horizontal span), runs the bbox decoder, merges span boxes, then lays the cells onto the OTSL grid with row/col spans.

Examples found in repository

examples/tf_otsl.rs (line 49)

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
                );
            }
        }
    }
}

pub fn predict_table_rows( &mut self, page_image: &RgbImage, page_h: f32, region: [f32; 4], words: &[TextCell], ) -> Option<Vec<Vec<String>>>

Predict a table region’s Markdown grid: crop the region (docling’s page→1024px box-average then bbox crop), run the structure model, map each cell box back to page points, match the page’s word cells into cells by intersection-over-word-area, and expand spans into a dense rows × cols grid. region is (l, t, r, b) in page points (top-left). Returns None if no structure is predicted.