lini 0.13.0

Pretty diagrams from plain text, with fine-grained control. Compiles to clean, themeable SVG.
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

//! Rounded-link geometry: a routed polyline plus its per-corner fillet radii
//! becomes a sequence of straight runs and arcs. Both the plain link path
//! ([`super::links`]) and the wavy link ([`super::wavy`]) build on this one
//! decomposition, so a corner's fillet is computed in exactly one place
//! (LINKING §Model step 7).

pub type Point = (f64, f64);

/// One piece of a rounded path. An [`Seg::Arc`] always follows the [`Seg::Line`]
/// running into its entry point, so walking the segments and emitting `L` / `A`
/// in order reproduces the classic rounded `d`.
pub enum Seg {
    Line {
        to: Point,
    },
    Arc {
        to: Point,
        center: Point,
        radius: f64,
        /// SVG sweep flag (matches the plain path's arc direction).
        sweep: u8,
    },
}

pub struct RoundedPath {
    pub start: Point,
    pub segs: Vec<Seg>,
}

/// The SVG path `d` for a polyline with each interior corner rounded to its
/// `targets` radius — the **one** formatter, shared by routed links
/// ([`super::links`]) and a lowered `|line|` primitive's rounded corners
/// ([`super::primitives`]), so a self-message hook bends exactly like a wire.
pub fn path_d(pts: &[Point], targets: &[f64]) -> String {
    use super::values::num;
    use std::fmt::Write;
    let rounded = round(pts, targets);
    let mut d = format!("M {} {}", num(rounded.start.0), num(rounded.start.1));
    for seg in &rounded.segs {
        match seg {
            Seg::Line { to } => write!(d, " L {} {}", num(to.0), num(to.1)).unwrap(),
            Seg::Arc {
                to, radius, sweep, ..
            } => write!(
                d,
                " A {r} {r} 0 0 {sweep} {} {}",
                num(to.0),
                num(to.1),
                r = num(*radius),
            )
            .unwrap(),
        }
    }
    d
}

/// Round each interior corner of the orthogonal polyline `pts` to its fillet
/// radius in `targets`, capped at half of each adjacent run so an arc never eats
/// a neighbour. A degenerate (sub-pixel) or collinear corner stays a sharp
/// joint. The legs are axis-aligned, so the Manhattan run length doubles as the
/// Euclidean one.
pub fn round(pts: &[Point], targets: &[f64]) -> RoundedPath {
    let mut segs = Vec::new();
    for i in 1..pts.len() - 1 {
        let (a, b, c) = (pts[i - 1], pts[i], pts[i + 1]);
        let (in_dx, in_dy) = (b.0 - a.0, b.1 - a.1);
        let (out_dx, out_dy) = (c.0 - b.0, c.1 - b.1);
        let in_len = in_dx.abs() + in_dy.abs();
        let out_len = out_dx.abs() + out_dy.abs();
        let r = targets
            .get(i - 1)
            .copied()
            .unwrap_or(0.0)
            .min(in_len / 2.0)
            .min(out_len / 2.0);
        let cross = in_dx * out_dy - in_dy * out_dx;
        if r < 0.5 || cross == 0.0 {
            segs.push(Seg::Line { to: b });
            continue;
        }
        let (ux, uy) = (in_dx / in_len, in_dy / in_len);
        let (vx, vy) = (out_dx / out_len, out_dy / out_len);
        let enter = (b.0 - ux * r, b.1 - uy * r);
        segs.push(Seg::Line { to: enter });
        segs.push(Seg::Arc {
            to: (b.0 + vx * r, b.1 + vy * r),
            // The arc centre sits a radius off the entry, perpendicular into
            // the turn — equivalently a radius off the exit along the inbound
            // leg, since the legs are perpendicular.
            center: (enter.0 + vx * r, enter.1 + vy * r),
            radius: r,
            sweep: if cross > 0.0 { 1 } else { 0 },
        });
    }
    segs.push(Seg::Line {
        to: *pts.last().expect("a link polyline has at least two points"),
    });
    RoundedPath {
        start: pts[0],
        segs,
    }
}