Skip to main content

Document

Struct Document 

Source
pub struct Document { /* private fields */ }
Expand description

An open PDF document.

Document is Send + Sync: internal caches are lock-guarded and there is no global state, so separate documents can be processed on separate threads freely — and a single document can be shared across threads too.

Implementations§

Source§

impl Document

Source

pub fn open(path: impl AsRef<Path>) -> Result<Self>

Examples found in repository?
examples/text.rs (line 14)
6fn main() {
7    let mut args = std::env::args().skip(1);
8    let Some(path) = args.next() else {
9        eprintln!("usage: text <file.pdf> [page-index]");
10        std::process::exit(2);
11    };
12    let only: Option<usize> = args.next().and_then(|s| s.parse().ok());
13
14    let doc = match rustium_pdf::Document::open(&path) {
15        Ok(d) => d,
16        Err(e) => {
17            eprintln!("{path}: {e}");
18            std::process::exit(1);
19        }
20    };
21
22    let pages: Vec<usize> = match only {
23        Some(i) => vec![i],
24        None => (0..doc.page_count()).collect(),
25    };
26    for (n, i) in pages.iter().enumerate() {
27        if n > 0 {
28            print!("\u{000C}");
29        }
30        match doc.page(*i) {
31            Ok(page) => println!("{}", page.text()),
32            Err(e) => eprintln!("page {i}: {e}"),
33        }
34    }
35}
More examples
Hide additional examples
examples/render.rs (line 13)
3fn main() {
4    let mut args = std::env::args().skip(1);
5    let Some(path) = args.next() else {
6        eprintln!("usage: render <file.pdf> [page] [dpi] [out.png]");
7        std::process::exit(2);
8    };
9    let index: usize = args.next().and_then(|s| s.parse().ok()).unwrap_or(0);
10    let dpi: f32 = args.next().and_then(|s| s.parse().ok()).unwrap_or(150.0);
11    let out = args.next().unwrap_or_else(|| "page.png".into());
12
13    let doc = rustium_pdf::Document::open(&path).expect("open");
14    let page = doc.page(index).expect("page");
15    let started = std::time::Instant::now();
16    let image = page
17        .render(&doc, rustium_pdf::RenderOptions::at_dpi(dpi))
18        .expect("render");
19    let elapsed = started.elapsed();
20
21    std::fs::write(&out, image.to_png().expect("encode")).expect("write");
22    println!(
23        "{out}: {}x{} at {dpi}dpi in {:.0}ms ({} glyphs, {} paths, {} images)",
24        image.width,
25        image.height,
26        elapsed.as_secs_f32() * 1000.0,
27        page.glyphs.len(),
28        page.paths.len(),
29        page.images.len()
30    );
31}
examples/dump.rs (line 11)
3fn main() {
4    let mut args = std::env::args().skip(1);
5    let Some(path) = args.next() else {
6        eprintln!("usage: dump <file.pdf> [page-index]");
7        std::process::exit(2);
8    };
9    let only: Option<usize> = args.next().and_then(|s| s.parse().ok());
10
11    let doc = match rustium_pdf::Document::open(&path) {
12        Ok(d) => d,
13        Err(e) => {
14            eprintln!("{path}: {e}");
15            std::process::exit(1);
16        }
17    };
18    println!("{path}: {} pages", doc.page_count());
19
20    let range: Vec<usize> = match only {
21        Some(i) => vec![i],
22        None => (0..doc.page_count()).collect(),
23    };
24    let (mut glyphs, mut paths, mut images) = (0usize, 0usize, 0usize);
25    let mut fonts: std::collections::BTreeSet<String> = Default::default();
26
27    for i in range {
28        let page = match doc.page(i) {
29            Ok(p) => p,
30            Err(e) => {
31                eprintln!("page {i}: {e}");
32                continue;
33            }
34        };
35        glyphs += page.glyphs.len();
36        paths += page.paths.len();
37        images += page.images.len();
38        for g in &page.glyphs {
39            if !g.base_font.is_empty() {
40                fonts.insert(g.base_font.clone());
41            }
42        }
43        let text = page.text();
44        println!(
45            "\n--- page {i} ({:.0}x{:.0}, rot {}) {} glyphs, {} paths, {} images ---",
46            page.width(),
47            page.height(),
48            page.rotation,
49            page.glyphs.len(),
50            page.paths.len(),
51            page.images.len()
52        );
53        println!("{}", text.chars().take(600).collect::<String>());
54    }
55
56    println!("\n=== totals: {glyphs} glyphs, {paths} paths, {images} images ===");
57    println!("fonts: {fonts:?}");
58}
examples/fonts.rs (line 25)
19fn main() {
20    let mut args = std::env::args().skip(1);
21    let Some(path) = args.next() else {
22        eprintln!("usage: fonts <file.pdf>");
23        std::process::exit(2);
24    };
25    let doc = match rustium_pdf::Document::open(&path) {
26        Ok(d) => d,
27        Err(e) => {
28            eprintln!("{path}: {e}");
29            std::process::exit(1);
30        }
31    };
32
33    let mut fonts: BTreeMap<String, Tally> = BTreeMap::new();
34    for i in 0..doc.page_count() {
35        let Ok(page) = doc.page(i) else { continue };
36        for g in page.glyphs.iter().filter(|g| !g.is_generated_space) {
37            let t = fonts.entry(g.base_font.clone()).or_default();
38            t.total += 1;
39            t.flags = g.flags.0;
40            if g.text.is_empty() {
41                t.unmapped += 1;
42                if t.sample.len() < 12 {
43                    t.sample.push(g.code());
44                }
45            }
46        }
47    }
48
49    let (mut total, mut unmapped) = (0usize, 0usize);
50    println!(
51        "{:<40} {:>8} {:>9}  unmapped codes",
52        "font", "glyphs", "unmapped"
53    );
54    println!("{}", "-".repeat(96));
55    for (name, t) in &fonts {
56        total += t.total;
57        unmapped += t.unmapped;
58        let pct = if t.total > 0 {
59            t.unmapped as f32 * 100.0 / t.total as f32
60        } else {
61            0.0
62        };
63        let codes: Vec<String> = t.sample.iter().map(|c| format!("{c:#04x}")).collect();
64        let marker = if pct > 5.0 { " <<<" } else { "" };
65        println!(
66            "{:<40} {:>8} {:>7.1}%  {}{}",
67            name.chars().take(40).collect::<String>(),
68            t.total,
69            pct,
70            codes.join(" "),
71            marker
72        );
73    }
74    println!("{}", "-".repeat(96));
75    let pct = if total > 0 {
76        unmapped as f32 * 100.0 / total as f32
77    } else {
78        0.0
79    };
80    println!("{:<40} {:>8} {:>7.1}%", "TOTAL", total, pct);
81}
Source

pub fn open_with_password( path: impl AsRef<Path>, password: Option<&str>, ) -> Result<Self>

Source

pub fn from_bytes(data: Vec<u8>, password: Option<&str>) -> Result<Self>

Source

pub fn page_count(&self) -> usize

Examples found in repository?
examples/text.rs (line 24)
6fn main() {
7    let mut args = std::env::args().skip(1);
8    let Some(path) = args.next() else {
9        eprintln!("usage: text <file.pdf> [page-index]");
10        std::process::exit(2);
11    };
12    let only: Option<usize> = args.next().and_then(|s| s.parse().ok());
13
14    let doc = match rustium_pdf::Document::open(&path) {
15        Ok(d) => d,
16        Err(e) => {
17            eprintln!("{path}: {e}");
18            std::process::exit(1);
19        }
20    };
21
22    let pages: Vec<usize> = match only {
23        Some(i) => vec![i],
24        None => (0..doc.page_count()).collect(),
25    };
26    for (n, i) in pages.iter().enumerate() {
27        if n > 0 {
28            print!("\u{000C}");
29        }
30        match doc.page(*i) {
31            Ok(page) => println!("{}", page.text()),
32            Err(e) => eprintln!("page {i}: {e}"),
33        }
34    }
35}
More examples
Hide additional examples
examples/dump.rs (line 18)
3fn main() {
4    let mut args = std::env::args().skip(1);
5    let Some(path) = args.next() else {
6        eprintln!("usage: dump <file.pdf> [page-index]");
7        std::process::exit(2);
8    };
9    let only: Option<usize> = args.next().and_then(|s| s.parse().ok());
10
11    let doc = match rustium_pdf::Document::open(&path) {
12        Ok(d) => d,
13        Err(e) => {
14            eprintln!("{path}: {e}");
15            std::process::exit(1);
16        }
17    };
18    println!("{path}: {} pages", doc.page_count());
19
20    let range: Vec<usize> = match only {
21        Some(i) => vec![i],
22        None => (0..doc.page_count()).collect(),
23    };
24    let (mut glyphs, mut paths, mut images) = (0usize, 0usize, 0usize);
25    let mut fonts: std::collections::BTreeSet<String> = Default::default();
26
27    for i in range {
28        let page = match doc.page(i) {
29            Ok(p) => p,
30            Err(e) => {
31                eprintln!("page {i}: {e}");
32                continue;
33            }
34        };
35        glyphs += page.glyphs.len();
36        paths += page.paths.len();
37        images += page.images.len();
38        for g in &page.glyphs {
39            if !g.base_font.is_empty() {
40                fonts.insert(g.base_font.clone());
41            }
42        }
43        let text = page.text();
44        println!(
45            "\n--- page {i} ({:.0}x{:.0}, rot {}) {} glyphs, {} paths, {} images ---",
46            page.width(),
47            page.height(),
48            page.rotation,
49            page.glyphs.len(),
50            page.paths.len(),
51            page.images.len()
52        );
53        println!("{}", text.chars().take(600).collect::<String>());
54    }
55
56    println!("\n=== totals: {glyphs} glyphs, {paths} paths, {images} images ===");
57    println!("fonts: {fonts:?}");
58}
examples/fonts.rs (line 34)
19fn main() {
20    let mut args = std::env::args().skip(1);
21    let Some(path) = args.next() else {
22        eprintln!("usage: fonts <file.pdf>");
23        std::process::exit(2);
24    };
25    let doc = match rustium_pdf::Document::open(&path) {
26        Ok(d) => d,
27        Err(e) => {
28            eprintln!("{path}: {e}");
29            std::process::exit(1);
30        }
31    };
32
33    let mut fonts: BTreeMap<String, Tally> = BTreeMap::new();
34    for i in 0..doc.page_count() {
35        let Ok(page) = doc.page(i) else { continue };
36        for g in page.glyphs.iter().filter(|g| !g.is_generated_space) {
37            let t = fonts.entry(g.base_font.clone()).or_default();
38            t.total += 1;
39            t.flags = g.flags.0;
40            if g.text.is_empty() {
41                t.unmapped += 1;
42                if t.sample.len() < 12 {
43                    t.sample.push(g.code());
44                }
45            }
46        }
47    }
48
49    let (mut total, mut unmapped) = (0usize, 0usize);
50    println!(
51        "{:<40} {:>8} {:>9}  unmapped codes",
52        "font", "glyphs", "unmapped"
53    );
54    println!("{}", "-".repeat(96));
55    for (name, t) in &fonts {
56        total += t.total;
57        unmapped += t.unmapped;
58        let pct = if t.total > 0 {
59            t.unmapped as f32 * 100.0 / t.total as f32
60        } else {
61            0.0
62        };
63        let codes: Vec<String> = t.sample.iter().map(|c| format!("{c:#04x}")).collect();
64        let marker = if pct > 5.0 { " <<<" } else { "" };
65        println!(
66            "{:<40} {:>8} {:>7.1}%  {}{}",
67            name.chars().take(40).collect::<String>(),
68            t.total,
69            pct,
70            codes.join(" "),
71            marker
72        );
73    }
74    println!("{}", "-".repeat(96));
75    let pct = if total > 0 {
76        unmapped as f32 * 100.0 / total as f32
77    } else {
78        0.0
79    };
80    println!("{:<40} {:>8} {:>7.1}%", "TOTAL", total, pct);
81}
Source

pub fn page(&self, index: usize) -> Result<Page>

Loads one page and interprets its content streams into primitives.

Examples found in repository?
examples/text.rs (line 30)
6fn main() {
7    let mut args = std::env::args().skip(1);
8    let Some(path) = args.next() else {
9        eprintln!("usage: text <file.pdf> [page-index]");
10        std::process::exit(2);
11    };
12    let only: Option<usize> = args.next().and_then(|s| s.parse().ok());
13
14    let doc = match rustium_pdf::Document::open(&path) {
15        Ok(d) => d,
16        Err(e) => {
17            eprintln!("{path}: {e}");
18            std::process::exit(1);
19        }
20    };
21
22    let pages: Vec<usize> = match only {
23        Some(i) => vec![i],
24        None => (0..doc.page_count()).collect(),
25    };
26    for (n, i) in pages.iter().enumerate() {
27        if n > 0 {
28            print!("\u{000C}");
29        }
30        match doc.page(*i) {
31            Ok(page) => println!("{}", page.text()),
32            Err(e) => eprintln!("page {i}: {e}"),
33        }
34    }
35}
More examples
Hide additional examples
examples/render.rs (line 14)
3fn main() {
4    let mut args = std::env::args().skip(1);
5    let Some(path) = args.next() else {
6        eprintln!("usage: render <file.pdf> [page] [dpi] [out.png]");
7        std::process::exit(2);
8    };
9    let index: usize = args.next().and_then(|s| s.parse().ok()).unwrap_or(0);
10    let dpi: f32 = args.next().and_then(|s| s.parse().ok()).unwrap_or(150.0);
11    let out = args.next().unwrap_or_else(|| "page.png".into());
12
13    let doc = rustium_pdf::Document::open(&path).expect("open");
14    let page = doc.page(index).expect("page");
15    let started = std::time::Instant::now();
16    let image = page
17        .render(&doc, rustium_pdf::RenderOptions::at_dpi(dpi))
18        .expect("render");
19    let elapsed = started.elapsed();
20
21    std::fs::write(&out, image.to_png().expect("encode")).expect("write");
22    println!(
23        "{out}: {}x{} at {dpi}dpi in {:.0}ms ({} glyphs, {} paths, {} images)",
24        image.width,
25        image.height,
26        elapsed.as_secs_f32() * 1000.0,
27        page.glyphs.len(),
28        page.paths.len(),
29        page.images.len()
30    );
31}
examples/dump.rs (line 28)
3fn main() {
4    let mut args = std::env::args().skip(1);
5    let Some(path) = args.next() else {
6        eprintln!("usage: dump <file.pdf> [page-index]");
7        std::process::exit(2);
8    };
9    let only: Option<usize> = args.next().and_then(|s| s.parse().ok());
10
11    let doc = match rustium_pdf::Document::open(&path) {
12        Ok(d) => d,
13        Err(e) => {
14            eprintln!("{path}: {e}");
15            std::process::exit(1);
16        }
17    };
18    println!("{path}: {} pages", doc.page_count());
19
20    let range: Vec<usize> = match only {
21        Some(i) => vec![i],
22        None => (0..doc.page_count()).collect(),
23    };
24    let (mut glyphs, mut paths, mut images) = (0usize, 0usize, 0usize);
25    let mut fonts: std::collections::BTreeSet<String> = Default::default();
26
27    for i in range {
28        let page = match doc.page(i) {
29            Ok(p) => p,
30            Err(e) => {
31                eprintln!("page {i}: {e}");
32                continue;
33            }
34        };
35        glyphs += page.glyphs.len();
36        paths += page.paths.len();
37        images += page.images.len();
38        for g in &page.glyphs {
39            if !g.base_font.is_empty() {
40                fonts.insert(g.base_font.clone());
41            }
42        }
43        let text = page.text();
44        println!(
45            "\n--- page {i} ({:.0}x{:.0}, rot {}) {} glyphs, {} paths, {} images ---",
46            page.width(),
47            page.height(),
48            page.rotation,
49            page.glyphs.len(),
50            page.paths.len(),
51            page.images.len()
52        );
53        println!("{}", text.chars().take(600).collect::<String>());
54    }
55
56    println!("\n=== totals: {glyphs} glyphs, {paths} paths, {images} images ===");
57    println!("fonts: {fonts:?}");
58}
examples/fonts.rs (line 35)
19fn main() {
20    let mut args = std::env::args().skip(1);
21    let Some(path) = args.next() else {
22        eprintln!("usage: fonts <file.pdf>");
23        std::process::exit(2);
24    };
25    let doc = match rustium_pdf::Document::open(&path) {
26        Ok(d) => d,
27        Err(e) => {
28            eprintln!("{path}: {e}");
29            std::process::exit(1);
30        }
31    };
32
33    let mut fonts: BTreeMap<String, Tally> = BTreeMap::new();
34    for i in 0..doc.page_count() {
35        let Ok(page) = doc.page(i) else { continue };
36        for g in page.glyphs.iter().filter(|g| !g.is_generated_space) {
37            let t = fonts.entry(g.base_font.clone()).or_default();
38            t.total += 1;
39            t.flags = g.flags.0;
40            if g.text.is_empty() {
41                t.unmapped += 1;
42                if t.sample.len() < 12 {
43                    t.sample.push(g.code());
44                }
45            }
46        }
47    }
48
49    let (mut total, mut unmapped) = (0usize, 0usize);
50    println!(
51        "{:<40} {:>8} {:>9}  unmapped codes",
52        "font", "glyphs", "unmapped"
53    );
54    println!("{}", "-".repeat(96));
55    for (name, t) in &fonts {
56        total += t.total;
57        unmapped += t.unmapped;
58        let pct = if t.total > 0 {
59            t.unmapped as f32 * 100.0 / t.total as f32
60        } else {
61            0.0
62        };
63        let codes: Vec<String> = t.sample.iter().map(|c| format!("{c:#04x}")).collect();
64        let marker = if pct > 5.0 { " <<<" } else { "" };
65        println!(
66            "{:<40} {:>8} {:>7.1}%  {}{}",
67            name.chars().take(40).collect::<String>(),
68            t.total,
69            pct,
70            codes.join(" "),
71            marker
72        );
73    }
74    println!("{}", "-".repeat(96));
75    let pct = if total > 0 {
76        unmapped as f32 * 100.0 / total as f32
77    } else {
78        0.0
79    };
80    println!("{:<40} {:>8} {:>7.1}%", "TOTAL", total, pct);
81}

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.