pdf2md 0.1.0

PDF → Markdown extractor with figure rasterization, table & banner detection. Built on pdfium-render.
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

//! Recursive XY-cut page segmentation.
//!
//! Given a flat list of bounded items (e.g. text/image elements on a PDF page),
//! [`segment`] splits the page along whitespace gutters into a tree of zones.
//! Each non-leaf split is either vertical (column gutter) or horizontal (row
//! gutter); each leaf contains the items that fell into one atomic region.
//!
//! Coordinate system: PDF-native, y-up — `top > bottom`.
//!
//! The algorithm picks the **largest** valid gap (either dimension) at each
//! step, which handles mixed layouts: a page with body + table-below cuts
//! horizontally first; a 2-column page cuts vertically first; a table inside a
//! column ends up as a vertical split of horizontal splits (column-major), and
//! callers can detect that shape to render GFM tables.

mod config;
mod gaps;
mod rows;
mod segment;
mod table;
mod types;

pub use config::SegmentParams;
pub use segment::segment;
pub use types::{BBox, Bounded, SplitDir, Zone};

#[cfg(test)]
pub(crate) mod test_support {
    use super::SegmentParams;
    use super::types::{BBox, Bounded};

    #[derive(Debug, Clone)]
    pub(crate) struct Item {
        pub bbox: BBox,
        pub chars: usize,
    }
    impl Bounded for Item {
        fn bbox(&self) -> BBox {
            self.bbox
        }
        fn char_count(&self) -> usize {
            self.chars
        }
    }

    pub(crate) fn b(left: f32, bottom: f32, right: f32, top: f32) -> Item {
        // Default char count approximates from bbox width (matches the
        // trait's default for items that don't carry explicit text).
        let width = (right - left).max(0.0);
        let chars = if width <= 0.0 {
            0
        } else {
            (width / 5.0).round().max(0.0) as usize
        };
        Item {
            bbox: BBox {
                left,
                right,
                bottom,
                top,
            },
            chars,
        }
    }

    /// Builder for tests that need to set an explicit character count
    /// independently of bbox width (used by the row-alignment content-size
    /// guard tests).
    pub(crate) fn b_chars(left: f32, bottom: f32, right: f32, top: f32, chars: usize) -> Item {
        Item {
            bbox: BBox {
                left,
                right,
                bottom,
                top,
            },
            chars,
        }
    }

    pub(crate) fn params() -> SegmentParams {
        SegmentParams {
            min_v_gap: 5.0,
            min_h_gap: 5.0,
            min_zone_items: 2,
            table_regions: Vec::new(),
        }
    }
}