bookforge-pdf 1.8.0

PDF ingestion for BookForge: poppler-based layout extraction and deterministic reconstruction into a translatable EPUB.
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
111
112
113
114
115
116
117

//! Page/line intermediate representation produced by the poppler XML
//! parser and consumed by reconstruction. Coordinates are pdftohtml's
//! integer pixel units, top-left origin.

/// A styled run of text within a line fragment.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Span {
    pub text: String,
    pub bold: bool,
    pub italic: bool,
}

/// One `<text>` fragment from pdftohtml, already a visual line or part
/// of one.
#[derive(Debug, Clone, PartialEq)]
pub struct Fragment {
    pub top: i32,
    pub left: i32,
    pub width: i32,
    pub height: i32,
    pub font: u32,
    pub spans: Vec<Span>,
}

impl Fragment {
    pub fn right(&self) -> i32 {
        self.left + self.width
    }

    pub fn char_count(&self) -> usize {
        self.spans
            .iter()
            .map(|span| span.text.chars().filter(|ch| !ch.is_whitespace()).count())
            .sum()
    }
}

/// A merged visual line (one or more fragments at the same height).
#[derive(Debug, Clone, PartialEq)]
pub struct Line {
    pub top: i32,
    pub left: i32,
    pub right: i32,
    pub height: i32,
    pub font_size: u32,
    pub spans: Vec<Span>,
}

impl Line {
    pub fn width(&self) -> i32 {
        self.right - self.left
    }

    pub fn text(&self) -> String {
        self.spans
            .iter()
            .map(|span| span.text.as_str())
            .collect::<String>()
    }

    pub fn char_count(&self) -> usize {
        self.spans
            .iter()
            .map(|span| span.text.chars().filter(|ch| !ch.is_whitespace()).count())
            .sum()
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct Page {
    pub number: u32,
    pub width: i32,
    pub height: i32,
    pub fragments: Vec<Fragment>,
    /// font id -> point size, from `<fontspec>` declarations.
    pub font_sizes: std::collections::HashMap<u32, u32>,
}

/// Column handling requested on the CLI.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ColumnMode {
    #[default]
    Auto,
    Single,
    Two,
}

/// A reconstructed, reading-ordered document block ready for XHTML
/// emission.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DocBlock {
    Heading { level: u8, spans: Vec<Span> },
    Paragraph { spans: Vec<Span> },
}

impl DocBlock {
    pub fn spans(&self) -> &[Span] {
        match self {
            DocBlock::Heading { spans, .. } => spans,
            DocBlock::Paragraph { spans } => spans,
        }
    }

    pub fn text(&self) -> String {
        self.spans()
            .iter()
            .map(|span| span.text.as_str())
            .collect::<String>()
    }

    pub fn char_count(&self) -> usize {
        self.spans()
            .iter()
            .map(|span| span.text.chars().filter(|ch| !ch.is_whitespace()).count())
            .sum()
    }
}