excalidraw-render 0.1.0

Render Excalidraw drawings to SVG, PNG and PDF in pure Rust, without a browser
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

//! Generic bounds of one cubic. Path traversal and union policy live in the parent.

use super::Point;
use crate::portable_math::{cube, square};

/// Endpoint and extrema bounds, in `(min_x, min_y, max_x, max_y)` order.
/// Keep the arithmetic order and root tests: these bounds feed canvas pivots
/// and coverage accounting, independently of the reference scene bounds.
pub(super) fn bounds(
    start: Point,
    control_1: Point,
    control_2: Point,
    end: Point,
) -> (f64, f64, f64, f64) {
    let mut values_x = [start.x, end.x, 0.0, 0.0];
    let mut values_y = [start.y, end.y, 0.0, 0.0];
    let count_x = 2 + cubic_extrema(start.x, control_1.x, control_2.x, end.x, &mut values_x[2..]);
    let count_y = 2 + cubic_extrema(start.y, control_1.y, control_2.y, end.y, &mut values_y[2..]);
    let min_x = values_x[..count_x]
        .iter()
        .copied()
        .fold(f64::INFINITY, f64::min);
    let min_y = values_y[..count_y]
        .iter()
        .copied()
        .fold(f64::INFINITY, f64::min);
    let max_x = values_x[..count_x]
        .iter()
        .copied()
        .fold(f64::NEG_INFINITY, f64::max);
    let max_y = values_y[..count_y]
        .iter()
        .copied()
        .fold(f64::NEG_INFINITY, f64::max);
    (min_x, min_y, max_x, max_y)
}

fn cubic_extrema(
    start: f64,
    control_1: f64,
    control_2: f64,
    end: f64,
    output: &mut [f64],
) -> usize {
    let a = -start + 3.0 * control_1 - 3.0 * control_2 + end;
    let b = 2.0 * (start - 2.0 * control_1 + control_2);
    let c = control_1 - start;
    let mut count = 0;
    if a.abs() <= f64::EPSILON {
        if b != 0.0 {
            count += retain_cubic_extremum(
                -c / b,
                start,
                control_1,
                control_2,
                end,
                &mut output[count..],
            );
        }
        return count;
    }
    let discriminant = b * b - 4.0 * a * c;
    if discriminant < 0.0 {
        return 0;
    }
    let root = discriminant.sqrt();
    count += retain_cubic_extremum(
        (-b + root) / (2.0 * a),
        start,
        control_1,
        control_2,
        end,
        &mut output[count..],
    );
    count += retain_cubic_extremum(
        (-b - root) / (2.0 * a),
        start,
        control_1,
        control_2,
        end,
        &mut output[count..],
    );
    count
}

fn retain_cubic_extremum(
    t: f64,
    start: f64,
    control_1: f64,
    control_2: f64,
    end: f64,
    output: &mut [f64],
) -> usize {
    if !(0.0..=1.0).contains(&t) || output.is_empty() {
        return 0;
    }
    let inverse = 1.0 - t;
    output[0] = cube(inverse) * start
        + 3.0 * square(inverse) * t * control_1
        + 3.0 * inverse * square(t) * control_2
        + cube(t) * end;
    1
}