pdf_oxide 0.3.38

The fastest Rust PDF library with text extraction: 0.8ms mean, 100% pass rate on 3,830 PDFs. 5× faster than pdf_extract, 17× faster than oxidize_pdf. Extract, create, and edit PDFs.
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

//! Simple top-to-bottom, left-to-right reading order strategy.

use crate::error::Result;
use crate::layout::TextSpan;
use crate::pipeline::{OrderedTextSpan, ReadingOrderInfo};

use super::{ReadingOrderContext, ReadingOrderStrategy};

/// Simple top-to-bottom, left-to-right reading order.
///
/// This strategy sorts spans by Y coordinate (descending, so top comes first)
/// then by X coordinate (ascending, so left comes first).
///
/// This is the simplest strategy and works well for single-column documents.
pub struct SimpleStrategy;

impl ReadingOrderStrategy for SimpleStrategy {
    fn apply(
        &self,
        spans: Vec<TextSpan>,
        _context: &ReadingOrderContext,
    ) -> Result<Vec<OrderedTextSpan>> {
        let mut spans_with_index: Vec<_> = spans.into_iter().enumerate().collect();

        // Sort by Y descending (top first), then X ascending (left first)
        spans_with_index.sort_by(|(_, a), (_, b)| {
            let y_cmp = crate::utils::safe_float_cmp(b.bbox.y, a.bbox.y);
            if y_cmp != std::cmp::Ordering::Equal {
                return y_cmp;
            }
            crate::utils::safe_float_cmp(a.bbox.x, b.bbox.x)
        });

        Ok(spans_with_index
            .into_iter()
            .enumerate()
            .map(|(order, (_, span))| {
                OrderedTextSpan::with_info(span, order, ReadingOrderInfo::simple())
            })
            .collect())
    }

    fn name(&self) -> &'static str {
        "SimpleStrategy"
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::geometry::Rect;
    use crate::layout::{Color, FontWeight};

    fn make_span(text: &str, x: f32, y: f32) -> TextSpan {
        TextSpan {
            artifact_type: None,
            text: text.to_string(),
            bbox: Rect::new(x, y, 50.0, 12.0),
            font_name: "Test".to_string(),
            font_size: 12.0,
            font_weight: FontWeight::Normal,
            is_italic: false,
            is_monospace: false,
            color: Color::black(),
            mcid: None,
            sequence: 0,
            offset_semantic: false,
            split_boundary_before: false,
            char_spacing: 0.0,
            word_spacing: 0.0,
            horizontal_scaling: 100.0,
            primary_detected: false,
            char_widths: vec![],
        }
    }

    #[test]
    fn test_simple_ordering() {
        let spans = vec![
            make_span("Bottom", 0.0, 50.0), // y=50 is lower on page
            make_span("Top", 0.0, 100.0),   // y=100 is higher on page
            make_span("Middle", 0.0, 75.0), // y=75 is in between
        ];

        let strategy = SimpleStrategy;
        let context = ReadingOrderContext::new();
        let ordered = strategy.apply(spans, &context).unwrap();

        assert_eq!(ordered[0].span.text, "Top");
        assert_eq!(ordered[1].span.text, "Middle");
        assert_eq!(ordered[2].span.text, "Bottom");
    }

    #[test]
    fn test_left_to_right_on_same_line() {
        let spans = vec![
            make_span("Right", 100.0, 100.0),
            make_span("Left", 0.0, 100.0),
            make_span("Center", 50.0, 100.0),
        ];

        let strategy = SimpleStrategy;
        let context = ReadingOrderContext::new();
        let ordered = strategy.apply(spans, &context).unwrap();

        assert_eq!(ordered[0].span.text, "Left");
        assert_eq!(ordered[1].span.text, "Center");
        assert_eq!(ordered[2].span.text, "Right");
    }
}