lernie 0.1.16

lernie: the operator seat — the window and wire client for a yog server
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! **The three primitives the mark is made of**, each answering the same two
//! questions: is this point inside me, and what element am I in SVG.
//!
//! Two answers, one geometry, and the geometry is stated once. A shape that
//! rasterized one way and vectorized another would be two pictures wearing one
//! name, and nothing in the tree could say which was the mark.
//!
//! **Everything is an integer**, in thousandths of the canvas — see [`super`]
//! for why that is the whole design and not an implementation detail.

use super::Ink;

/// The canvas, in the units every coordinate below is written in.
pub(super) const SPAN: i64 = 1000;

/// One flat-filled figure.
///
/// Three, because three is what the mark has: the engine held elsewhere, the
/// seat that is here, and the one wire between them. A fourth arrives with a
/// mark that needs it.
pub(super) enum Shape {
    /// A filled circle.
    Disc { cx: i64, cy: i64, r: i64, ink: Ink },
    /// An annulus: a circle of radius `r` drawn `half` thick either side.
    Ring {
        cx: i64,
        cy: i64,
        r: i64,
        half: i64,
        ink: Ink,
    },
    /// A capsule: everything within `half` of the segment `a`–`b`, round caps
    /// included, which is exactly what an SVG round-capped line paints.
    Bar {
        ax: i64,
        ay: i64,
        bx: i64,
        by: i64,
        half: i64,
        ink: Ink,
    },
}

impl Shape {
    /// The colour this shape lays down.
    pub(super) fn ink(&self) -> Ink {
        match self {
            Self::Disc { ink, .. } | Self::Ring { ink, .. } | Self::Bar { ink, .. } => *ink,
        }
    }

    /// **Is the point `(x, y)` inside?** The point is given as a numerator over
    /// `den`, so a sample taken anywhere on any subpixel grid is compared
    /// against the same geometry with no rounding on either side: every
    /// coordinate below is multiplied up to the sample's denominator rather
    /// than the sample being divided down to the geometry's.
    pub(super) fn holds(&self, x: i64, y: i64, den: i64) -> bool {
        match self {
            Self::Disc { cx, cy, r, .. } => square(x - cx * den, y - cy * den) <= (r * den).pow(2),
            Self::Ring {
                cx, cy, r, half, ..
            } => {
                let from = square(x - cx * den, y - cy * den);
                from <= ((r + half) * den).pow(2) && from >= ((r - half) * den).pow(2)
            }
            Self::Bar {
                ax,
                ay,
                bx,
                by,
                half,
                ..
            } => {
                let (ax, ay) = (x - ax * den, y - ay * den);
                let (bx, by) = (x - bx * den, y - by * den);
                let (ux, uy) = (ax - bx, ay - by);
                let along = ax * ux + ay * uy;
                let span = square(ux, uy);
                let reach = (half * den).pow(2);
                // Past either end the nearest point is that end, so the cap is
                // the same disc test. Between them the perpendicular distance
                // is `|a|² − along²/span`, and multiplying the comparison
                // through by `span` keeps it exact — the one product that can
                // outgrow an `i64`, which is why it is taken in `i128`.
                if along <= 0 {
                    square(ax, ay) <= reach
                } else if along >= span {
                    square(bx, by) <= reach
                } else {
                    i128::from(square(ax, ay) - reach) * i128::from(span)
                        <= i128::from(along).pow(2)
                }
            }
        }
    }

    /// The SVG element this shape is, at the canvas's own scale.
    pub(super) fn element(&self) -> String {
        match self {
            Self::Disc { cx, cy, r, ink } => format!(
                "  <circle cx=\"{cx}\" cy=\"{cy}\" r=\"{r}\" fill=\"{}\"/>",
                ink.hex()
            ),
            Self::Ring {
                cx,
                cy,
                r,
                half,
                ink,
            } => format!(
                "  <circle cx=\"{cx}\" cy=\"{cy}\" r=\"{r}\" fill=\"none\" \
                 stroke=\"{}\" stroke-width=\"{}\"/>",
                ink.hex(),
                half * 2
            ),
            Self::Bar {
                ax,
                ay,
                bx,
                by,
                half,
                ink,
            } => format!(
                "  <line x1=\"{ax}\" y1=\"{ay}\" x2=\"{bx}\" y2=\"{by}\" \
                 stroke=\"{}\" stroke-width=\"{}\" stroke-linecap=\"round\"/>",
                ink.hex(),
                half * 2
            ),
        }
    }
}

/// The squared length of `(x, y)`.
fn square(x: i64, y: i64) -> i64 {
    x.pow(2) + y.pow(2)
}