Struct LayoutModel 

pub struct LayoutModel { /* private fields */ }

Implementations

impl LayoutModel

pub fn load() -> Result<Self, String>

Load the ONNX model from DOCLING_LAYOUT_ONNX. Without the override, prefers models/layout_heron_int8.onnx when present (the quantized default; DOCLING_RS_FP32=1 opts out), else models/layout_heron.onnx.

Examples found in repository

examples/layout.rs (line 11)

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 9)

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 28)

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 = docling_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) -> Result<Self, String>

Like load but with an explicit intra-op thread count. A parallel page-worker pool loads its helper models on a single thread each and gets its speed-up from running pages concurrently instead.

pub fn predict( &mut self, img: &RgbImage, page_w: f32, page_h: f32, ) -> Result<Vec<Region>, String>

Detect layout regions on a page image. page_w/page_h are the page size in points; returned boxes are in those coordinates.

Examples found in repository

examples/layout.rs (line 14)

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 12)

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 32)

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 = docling_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_batch( &mut self, pages: &[(&RgbImage, f32, f32)], ) -> Result<Vec<Vec<Region>>, String>

Detect layout regions on several page images with one inference call (issue #73). The ONNX export has a dynamic batch dimension, so a worker can amortize the per-run framework overhead and keep its cores busier on multi-page documents. Results are per-image, index-aligned with pages, and identical to calling predict per page.