rasterize 0.6.9

Simple and small 2D rendering library
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

#![deny(warnings)]
use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
use rasterize::*;
use std::{
    fs::File,
    hint::black_box,
    io::{Cursor, Read},
    time::Duration,
};

const SQUIRREL_FILE: &str = "data/squirrel.path";
const MATERIAL_FILE: &str = "data/material-big.path";

fn rasterizers() -> impl Iterator<Item = Box<dyn Rasterizer>> {
    let r0: Box<dyn Rasterizer> = Box::new(SignedDifferenceRasterizer::default());
    let r1: Box<dyn Rasterizer> = Box::new(ActiveEdgeRasterizer::default());
    Some(r0).into_iter().chain(Some(r1))
}

fn curve_benchmark(c: &mut Criterion) {
    let cubic = Cubic::new((158.0, 70.0), (210.0, 250.0), (25.0, 190.0), (219.0, 89.0));
    let length = cubic.length(0.0, 1.0) / 2.0;
    let mut group = c.benchmark_group("cubic");
    group
        .throughput(Throughput::Elements(1))
        .bench_function("extremities", |b| b.iter(|| black_box(cubic).extremities()))
        .bench_function("bbox", |b| b.iter(|| black_box(cubic).bbox(None)))
        .bench_function("length", |b| b.iter(|| black_box(cubic).length(0.0, 1.0)))
        .bench_function("from length", |b| {
            b.iter(|| cubic.param_at_length(black_box(length), None))
        });
    group.finish();
}

fn stroke_benchmark(c: &mut Criterion) {
    let mut file = File::open(SQUIRREL_FILE).expect("failed to open path");
    let path = Path::read_svg_path(&mut file).expect("failed to load path");
    let (size, tr, _) = path.size(Transform::identity()).expect("path is empty");
    let mut img = ImageOwned::new_default(size);
    let style = StrokeStyle {
        width: 1.0,
        line_join: LineJoin::Round,
        line_cap: LineCap::Round,
    };
    let stroke = path.stroke(style);

    let mut group = c.benchmark_group("squirrel");
    group.throughput(Throughput::Elements(path.segments_count() as u64));
    group.bench_function("stroke", |b| b.iter_with_large_drop(|| path.stroke(style)));
    for rasterizer in rasterizers() {
        group
            .bench_with_input(
                BenchmarkId::new("mask stroked", rasterizer.name()),
                &rasterizer,
                |b, r| {
                    b.iter(|| {
                        img.clear();
                        stroke.mask(r, tr, FillRule::EvenOdd, &mut img);
                    })
                },
            )
            .bench_with_input(
                BenchmarkId::new("mask", rasterizer.name()),
                &rasterizer,
                |b, r| {
                    b.iter(|| {
                        img.clear();
                        path.mask(r, tr, FillRule::EvenOdd, &mut img);
                    });
                },
            );
    }
    group.finish()
}

fn large_path_benchmark(c: &mut Criterion) {
    let mut path_str = String::new();
    let mut file = File::open(MATERIAL_FILE).expect("failed to open a path");
    file.read_to_string(&mut path_str)
        .expect("failed to read path");
    let path: Path = path_str.parse().unwrap();
    let (size, tr, _) = path.size(Transform::identity()).expect("path is empty");
    let mut img = ImageOwned::new_default(size);

    let mut group = c.benchmark_group("material-big");
    group
        .throughput(Throughput::Elements(path.segments_count() as u64))
        .bench_function("parse-only", |b| {
            b.iter(|| SvgPathParser::new(Cursor::new(path_str.as_str())).count())
        })
        .bench_function("parse", |b| {
            b.iter_with_large_drop(|| path_str.parse::<Path>())
        })
        .bench_function("flatten", |b| {
            b.iter(|| path.flatten(tr, DEFAULT_FLATNESS, true).count())
        })
        .bench_function("bbox", |b| b.iter(|| path.bbox(tr)));
    for rasterizer in rasterizers() {
        let id = BenchmarkId::new("mask", rasterizer.name());
        group.bench_with_input(id, &rasterizer, |b, r| {
            b.iter(|| {
                img.clear();
                path.mask(r, tr, FillRule::EvenOdd, &mut img);
            })
        });
    }
    group.finish()
}

criterion_group!(
    name = rasterize;
    config = Criterion::default().sample_size(10).warm_up_time(Duration::new(1, 0));
    targets = curve_benchmark, large_path_benchmark, stroke_benchmark
);
criterion_main!(rasterize);