pdf 0.10.0

PDF reader
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

use pdf::content::ViewRect;
use pdf::error::PdfError;
use pdf::file::FileOptions;
use pdf::object::Resolve;
use pdf::primitive::{Dictionary, Primitive};
use std::env::args;

/// Extract data from a page entry that is under "other".
/// This example looks for stikethroughs in the annotations entry
/// and returns a Vec<Rect> for the bounds of the struckthrough text.
#[cfg(feature="cache")]
fn main() -> Result<(), PdfError> {
    let path = args()
        .nth(1)
        .expect("Please provide a file path to the PDF you want to explore.");

    let file = FileOptions::cached().open(&path).unwrap();
    let resolver = file.resolver();

    for (i, page) in file.pages().enumerate() {
        let page = page.unwrap();
        let strikethroughs = annotation_strikethrough(&page.other, &resolver)?;
        println!(
            "Found {} strikethrough annotations on page {}.",
            strikethroughs.len(),
            i + 1
        );
        for strikethrough in strikethroughs {
            println!();
            println!("Struck text:");
            println!("{:#?}", strikethrough.0);
            println!();
            println!("Text spans {} lines", strikethrough.1.len());
            println!();
            println!("Strikethrough bounding boxes:");
            for rect in strikethrough.1 {
                println!("{:#?}", rect);
                println!();
            }
            println!();
            println!();
        }
    }

    Ok(())
}

fn annotation_strikethrough(
    other_dict: &Dictionary,
    resolver: &impl Resolve,
) -> Result<Vec<(String, Vec<pdf::content::ViewRect>)>, PdfError> {
    let mut strikethroughs: Vec<(String, Vec<pdf::content::ViewRect>)> = Vec::new();

    if !other_dict.is_empty() {
        let annotations = other_dict.get("Annots".into());
        if let Some(annotations) = annotations {
            let annotations_resolved = annotations.clone().resolve(resolver)?;
            let annotations_array = annotations_resolved.into_array()?;
            for annotation in annotations_array.iter() {
                let mut paths: Vec<pdf::content::ViewRect> = Vec::new();
                let annotation_resolved = annotation.clone().resolve(resolver)?;
                let annotation_dict = annotation_resolved.into_dictionary()?;

                // If you have multiline strikethrough "Rect" will be the bounding
                // box around all the strikethrough lines.
                // "QuadPoints" gives 8 points for each line that is struckthrough,
                // so if a single annotation involves text on two lines, QuadPoints
                // should have 16 values in it. It starts with bottom left and
                // runs counter-clockwise.
                let subtype = annotation_dict.get("Subtype".into());
                if let Some(subtype) = subtype {
                    let subtype = subtype.clone().into_name()?;
                    if subtype.as_str() == "StrikeOut" {
                        let rects = annotation_dict.get("QuadPoints".into());
                        let text = annotation_dict.get("Contents".into());
                        if let (Some(rects), Some(text)) = (rects, text) {
                            let text = text.to_string()?;

                            // Check multiples of 8.
                            let rects_array = rects.clone().into_array()?;
                            if rects_array.len() % 8 == 0 {
                                let rects: Vec<Vec<Primitive>> =
                                    rects_array.chunks(8).map(|chunk| chunk.to_vec()).collect();

                                for rect in rects {
                                    let mut quad_points: Vec<f32> = Vec::new();
                                    for num in rect {
                                        let number = num.as_number()?;
                                        quad_points.push(number);
                                    }
                                    if quad_points.len() == 8 {
                                        paths.push(ViewRect {
                                            x: quad_points[0],
                                            y: quad_points[1],
                                            width: quad_points[2] - quad_points[0],
                                            height: quad_points[7] - quad_points[1],
                                        });
                                    }
                                }
                                strikethroughs.push((text, paths))
                            }
                        }
                    }
                }
            }
        }
    }

    Ok(strikethroughs)
}