micropdf 0.17.0

A pure Rust PDF library - A pure Rust PDF library with fz_/pdf_ API compatibility
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
118
119

use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main};
use micropdf::fitz::geometry::{Point, Rect};
use micropdf::fitz::path::Path;

fn bench_path_creation(c: &mut Criterion) {
    let mut group = c.benchmark_group("path/creation");

    group.bench_function("new", |b| b.iter(Path::new));

    group.bench_function("with_capacity", |b| {
        b.iter(|| Path::with_capacity(black_box(100)))
    });

    group.finish();
}

fn bench_path_building(c: &mut Criterion) {
    let mut group = c.benchmark_group("path/building");

    group.bench_function("move_to", |b| {
        let mut path = Path::new();
        b.iter(|| {
            black_box(&mut path).move_to(black_box(Point::new(10.0, 20.0)));
        })
    });

    group.bench_function("line_to", |b| {
        let mut path = Path::new();
        path.move_to(Point::new(0.0, 0.0));
        b.iter(|| {
            black_box(&mut path).line_to(black_box(Point::new(100.0, 100.0)));
        })
    });

    group.bench_function("curve_to", |b| {
        let mut path = Path::new();
        path.move_to(Point::new(0.0, 0.0));
        b.iter(|| {
            black_box(&mut path).curve_to(
                black_box(Point::new(25.0, 50.0)),
                black_box(Point::new(75.0, 50.0)),
                black_box(Point::new(100.0, 0.0)),
            );
        })
    });

    group.bench_function("close", |b| {
        let mut path = Path::new();
        path.move_to(Point::new(0.0, 0.0));
        path.line_to(Point::new(100.0, 0.0));
        path.line_to(Point::new(100.0, 100.0));
        b.iter(|| {
            black_box(&mut path).close();
        })
    });

    group.finish();
}

fn bench_path_shapes(c: &mut Criterion) {
    let mut group = c.benchmark_group("path/shapes");

    group.bench_function("rectangle", |b| {
        let mut path = Path::new();
        let rect = Rect::new(0.0, 0.0, 100.0, 100.0);
        b.iter(|| {
            black_box(&mut path).rect(black_box(rect));
        })
    });

    group.finish();
}

fn bench_path_operations(c: &mut Criterion) {
    let mut group = c.benchmark_group("path/operations");

    let mut path = Path::new();
    path.move_to(Point::new(0.0, 0.0));
    path.line_to(Point::new(100.0, 0.0));
    path.line_to(Point::new(100.0, 100.0));
    path.line_to(Point::new(0.0, 100.0));
    path.close();

    group.bench_function("clone", |b| b.iter(|| black_box(&path).clone()));

    group.bench_function("is_empty", |b| b.iter(|| black_box(&path).is_empty()));

    group.finish();
}

fn bench_path_complexity(c: &mut Criterion) {
    let mut group = c.benchmark_group("path/complexity");

    for segments in [10, 50, 100, 500, 1000].iter() {
        group.bench_with_input(BenchmarkId::new("lines", segments), segments, |b, &s| {
            b.iter(|| {
                let mut path = Path::new();
                path.move_to(Point::new(0.0, 0.0));
                for i in 0..s {
                    path.line_to(Point::new(i as f32, (i * 2) as f32));
                }
                black_box(path)
            })
        });
    }

    group.finish();
}

criterion_group!(
    benches,
    bench_path_creation,
    bench_path_building,
    bench_path_shapes,
    bench_path_operations,
    bench_path_complexity,
);

criterion_main!(benches);