diff --git a/README.de.md b/README.de.md
index e6c002a..105f375 100644
--- a/README.de.md
+++ b/README.de.md
@@ -192,6 +192,7 @@ src/
 ├── disk_watch.rs   # Änderungen anderer Geräte übernehmen (Sync-Clients)
 ├── library.rs      # Ordner der Notizbücher (library.json)
 ├── math.rs         # Exaktes Ausrechnen handgeschriebener Formeln (Issue #46)
+├── math_ink.rs     # Erkennung handgeschriebener Formeln ($P-Punktwolken)
 ├── autosave.rs     # Speichern im Hintergrund
 ├── export.rs       # PDF-Export
 ├── page_export.rs  # Seite als PNG/SVG, Auswahl als Bild
diff --git a/README.md b/README.md
index 520d4af..f5e53f4 100644
--- a/README.md
+++ b/README.md
@@ -194,6 +194,7 @@ src/
 ├── disk_watch.rs   # Taking over changes from other devices (sync clients)
 ├── library.rs      # Notebook folders (library.json)
 ├── math.rs         # Exact evaluation of handwritten math (Issue #46)
+├── math_ink.rs     # Recognition of handwritten math ($P point clouds)
 ├── autosave.rs     # Saving in the background
 ├── export.rs       # PDF export
 ├── page_export.rs  # Page as PNG/SVG, selection as image
diff --git a/src/lib.rs b/src/lib.rs
index 85172c0..35994c4 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -19,6 +19,7 @@ pub mod image_layer;
 pub mod import;
 pub mod library;
 pub mod math;
+pub mod math_ink;
 pub mod osk;
 pub mod page_export;
 pub mod paths;
diff --git a/src/math_ink.rs b/src/math_ink.rs
new file mode 100644
index 0000000..d27be6e
--- /dev/null
+++ b/src/math_ink.rs
@@ -0,0 +1,1259 @@
+//! Recognition of handwritten math (Issue #46, stage 2).
+//!
+//! Turns the strokes of a handwritten expression into text for [`crate::math::solve`], e.g.
+//! the strokes of `(x+3)²=` into `(x+3)^(2)=`. It works on the stroke points, not on an
+//! image, in three steps:
+//!
+//! 1. **Grouping**: consecutive strokes that overlap form one symbol (the two strokes of `+`,
+//!    `x` or `4`). Straight horizontal strokes and dots are kept apart, as their meaning
+//!    depends on their neighbours.
+//! 2. **Classifying** each symbol with the $P point-cloud recognizer (Vatavu, Anthony,
+//!    Wobbrock 2012): its points are compared with templates of each symbol. It does not
+//!    depend on stroke order or direction and needs no trained model; besides the built-in
+//!    templates, one's own handwriting can be added as templates.
+//! 3. **Structure** from the positions: two stacked lines are `=`, two stacked dots `:`, a
+//!    line with symbols above and below is a fraction bar, a dot low between digits a
+//!    decimal comma, and smaller raised symbols an exponent.
+
+use glam::{Vec2, Vec3};
+
+/// Points of a symbol after resampling, for $P
+const CLOUD_POINTS: usize = 32;
+/// Symbols whose best template is further away are not recognized ($P distance)
+const MAX_DISTANCE: f32 = 3.0;
+/// Factor on the distance per stroke more or less than the template has
+const STROKE_PENALTY: f32 = 0.15;
+/// Slants of the built-in templates (horizontal shift of the top against the bottom)
+const TEMPLATE_SLANTS: [f32; 2] = [0.0, 0.25];
+/// Weight of the turning angle against the position of a point ($P+)
+const ANGLE_WEIGHT: f32 = 1.0;
+
+/// A recognized symbol with the area it covers and the strokes it consists of
+#[derive(Debug, Clone, PartialEq)]
+pub struct Symbol {
+    /// `0`–`9`, `x`, `y`, `a`, `b`, `+`, `-`, `·`, `:`, `/`, `(`, `)`, `=`, `,` or `?`
+    pub ch: char,
+    pub min: Vec2,
+    pub max: Vec2,
+    /// Indices into the strokes passed to [`Recognizer::recognize`]
+    pub strokes: Vec<usize>,
+}
+
+/// Result of [`Recognizer::recognize`]
+#[derive(Debug, Clone, PartialEq)]
+pub struct Recognition {
+    /// The expression as text, e.g. `(x+3)^(2)=` or `((1)/(2))+3=`
+    pub text: String,
+    /// All symbols, from left to right
+    pub symbols: Vec<Symbol>,
+}
+
+struct Template {
+    symbol: char,
+    strokes: usize,
+    cloud: Vec<Vec3>,
+}
+
+/// $P recognizer with templates for the symbols of simple math
+pub struct Recognizer {
+    templates: Vec<Template>,
+}
+
+impl Default for Recognizer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Recognizer {
+    /// Recognizer with the built-in templates
+    pub fn new() -> Self {
+        let mut recognizer = Recognizer {
+            templates: Vec::new(),
+        };
+        // Upright and slanted, as handwriting usually leans to the right
+        for (symbol, strokes) in builtin_templates() {
+            for slant in TEMPLATE_SLANTS {
+                let width = template_width(symbol);
+                let slanted: Vec<Vec<Vec2>> = strokes
+                    .iter()
+                    .map(|s| {
+                        s.iter()
+                            .map(|p| Vec2::new(p.x * width + slant * (1.0 - p.y), p.y))
+                            .collect()
+                    })
+                    .collect();
+                recognizer.add_template(symbol, &slanted);
+            }
+        }
+        recognizer
+    }
+
+    /// Adds a template, e.g. a symbol in one's own handwriting
+    pub fn add_template(&mut self, symbol: char, strokes: &[Vec<Vec2>]) {
+        let strokes: Vec<&[Vec2]> = strokes.iter().map(Vec::as_slice).collect();
+        if let Some(cloud) = normalize(&strokes) {
+            self.templates.push(Template {
+                symbol,
+                strokes: strokes.len(),
+                cloud,
+            });
+        }
+    }
+
+    /// The symbol whose template is closest, with its $P distance (smaller is better)
+    pub fn classify(&self, strokes: &[&[Vec2]]) -> Option<(char, f32)> {
+        let cloud = normalize(strokes)?;
+        let mut best: Option<(char, f32)> = None;
+        for template in &self.templates {
+            // A different number of strokes makes a template less likely (`y` in two strokes
+            // against `7` in one), but does not rule it out
+            let penalty = 1.0 + STROKE_PENALTY * template.strokes.abs_diff(strokes.len()) as f32;
+            let limit = best.map_or(f32::MAX, |b| b.1);
+            let distance = greedy_cloud_match(&cloud, &template.cloud, limit / penalty) * penalty;
+            if distance < limit {
+                best = Some((template.symbol, distance));
+            }
+        }
+        best
+    }
+
+    /// Recognizes the expression written with `strokes` (page coordinates, y pointing down,
+    /// in the order they were written). `None` if there are no strokes.
+    pub fn recognize(&self, strokes: &[Vec<Vec2>]) -> Option<Recognition> {
+        let infos: Vec<StrokeInfo> = strokes
+            .iter()
+            .filter(|s| !s.is_empty())
+            .map(|s| StrokeInfo::new(s))
+            .collect();
+        if infos.len() != strokes.len() || infos.is_empty() {
+            return None;
+        }
+        let line_height = line_height(&infos);
+        let kinds: Vec<Kind> = infos.iter().map(|i| i.kind(line_height)).collect();
+        let groups = group_strokes(strokes, &infos, &kinds, line_height);
+
+        let mut elements = Vec::new();
+        for group in groups {
+            let (min, max) = bounds(group.iter().map(|&i| &infos[i]));
+            let ch = match (group.as_slice(), kinds[group[0]]) {
+                ([_], Kind::Line) => LINE,
+                ([_], Kind::Dot) => DOT,
+                _ => {
+                    let parts: Vec<&[Vec2]> =
+                        group.iter().map(|&i| strokes[i].as_slice()).collect();
+                    match self.classify(&parts) {
+                        Some((ch, distance)) if distance <= MAX_DISTANCE => ch,
+                        _ => '?',
+                    }
+                }
+            };
+            elements.push(Element {
+                symbol: Symbol {
+                    ch,
+                    min,
+                    max,
+                    strokes: group,
+                },
+                text: None,
+            });
+        }
+
+        let elements = pair_stacked(elements, line_height);
+        let elements = build_fractions(elements, line_height);
+        let text = layout(&elements, line_height);
+        let mut symbols = Vec::new();
+        for element in elements {
+            element.collect_symbols(&mut symbols);
+        }
+        symbols.sort_by(|a, b| a.min.x.total_cmp(&b.min.x));
+        Some(Recognition { text, symbols })
+    }
+}
+
+// --- $P point-cloud recognizer --------------------------------------------------------------
+
+/// Resamples all strokes to [`CLOUD_POINTS`] points, scales them to a unit box (keeping the
+/// aspect ratio) and moves their centroid to the origin.
+fn normalize(strokes: &[&[Vec2]]) -> Option<Vec<Vec3>> {
+    let lengths: Vec<f32> = strokes.iter().map(|s| path_length(s)).collect();
+    let total: f32 = lengths.iter().sum();
+    if strokes.is_empty() || strokes.len() > CLOUD_POINTS {
+        return None;
+    }
+    // Points per stroke in proportion to its length, at least one each (largest remainder)
+    let mut counts = vec![1usize; strokes.len()];
+    let spare = CLOUD_POINTS - strokes.len();
+    let shares: Vec<f32> = lengths
+        .iter()
+        .map(|l| {
+            if total > 0.0 {
+                l / total * spare as f32
+            } else {
+                spare as f32 / strokes.len() as f32
+            }
+        })
+        .collect();
+    let mut given = 0;
+    for (count, share) in counts.iter_mut().zip(&shares) {
+        *count += share.floor() as usize;
+        given += share.floor() as usize;
+    }
+    let mut order: Vec<usize> = (0..strokes.len()).collect();
+    order.sort_by(|&a, &b| {
+        (shares[b] - shares[b].floor()).total_cmp(&(shares[a] - shares[a].floor()))
+    });
+    for &i in order.iter().cycle().take(spare - given) {
+        counts[i] += 1;
+    }
+
+    let mut points = Vec::with_capacity(CLOUD_POINTS);
+    let mut angles = Vec::with_capacity(CLOUD_POINTS);
+    for (stroke, count) in strokes.iter().zip(counts) {
+        let resampled = resample(stroke, count);
+        angles.extend(turning_angles(&resampled));
+        points.extend(resampled);
+    }
+    let (min, max) = points.iter().fold(
+        (Vec2::splat(f32::MAX), Vec2::splat(f32::MIN)),
+        |(lo, hi), p| (lo.min(*p), hi.max(*p)),
+    );
+    let size = (max - min).max_element().max(1e-6);
+    let centroid = points.iter().copied().sum::<Vec2>() / points.len() as f32;
+    Some(
+        points
+            .iter()
+            .zip(angles)
+            .map(|(p, angle)| ((*p - centroid) / size).extend(angle * ANGLE_WEIGHT))
+            .collect(),
+    )
+}
+
+/// How sharply the stroke turns at each point, from 0 (straight on, or an end) to 1 (back)
+fn turning_angles(points: &[Vec2]) -> Vec<f32> {
+    (0..points.len())
+        .map(|i| {
+            if i == 0 || i + 1 >= points.len() {
+                return 0.0;
+            }
+            let a = points[i] - points[i - 1];
+            let b = points[i + 1] - points[i];
+            if a.length_squared() == 0.0 || b.length_squared() == 0.0 {
+                return 0.0;
+            }
+            a.angle_between(b).abs() / std::f32::consts::PI
+        })
+        .collect()
+}
+
+fn path_length(points: &[Vec2]) -> f32 {
+    points.windows(2).map(|w| w[0].distance(w[1])).sum()
+}
+
+/// `count` points evenly spaced along the polyline (for one point: its middle)
+fn resample(points: &[Vec2], count: usize) -> Vec<Vec2> {
+    let length = path_length(points);
+    if count == 0 {
+        return Vec::new();
+    }
+    if count == 1 || length <= 0.0 {
+        let at = if count == 1 { length / 2.0 } else { 0.0 };
+        return vec![point_at(points, at); count];
+    }
+    let step = length / (count - 1) as f32;
+    (0..count)
+        .map(|i| point_at(points, step * i as f32))
+        .collect()
+}
+
+/// The point at distance `at` along the polyline
+fn point_at(points: &[Vec2], at: f32) -> Vec2 {
+    let mut remaining = at;
+    for w in points.windows(2) {
+        let d = w[0].distance(w[1]);
+        if remaining <= d && d > 0.0 {
+            return w[0].lerp(w[1], remaining / d);
+        }
+        remaining -= d;
+    }
+    *points.last().unwrap_or(&Vec2::ZERO)
+}
+
+/// $P distance between two clouds, or infinity if it is not below `limit` (then the
+/// matching stops early)
+fn greedy_cloud_match(points: &[Vec3], template: &[Vec3], limit: f32) -> f32 {
+    let n = points.len();
+    let step = (n as f32).sqrt().floor().max(1.0) as usize;
+    let mut best = f32::INFINITY;
+    for start in (0..n).step_by(step) {
+        best = best.min(cloud_distance(points, template, start, best.min(limit)));
+        best = best.min(cloud_distance(template, points, start, best.min(limit)));
+    }
+    if best < limit {
+        best
+    } else {
+        f32::INFINITY
+    }
+}
+
+fn cloud_distance(a: &[Vec3], b: &[Vec3], start: usize, limit: f32) -> f32 {
+    let n = a.len();
+    let mut matched = [false; CLOUD_POINTS];
+    let mut sum = 0.0;
+    for k in 0..n {
+        let i = (start + k) % n;
+        let mut best = f32::MAX;
+        let mut best_j = 0;
+        for (j, q) in b.iter().enumerate() {
+            if !matched[j] {
+                let d = a[i].distance_squared(*q);
+                if d < best {
+                    best = d;
+                    best_j = j;
+                }
+            }
+        }
+        if best == f32::MAX {
+            break;
+        }
+        matched[best_j] = true;
+        sum += (1.0 - k as f32 / n as f32) * best.sqrt();
+        if sum >= limit {
+            return sum;
+        }
+    }
+    sum
+}
+
+// --- Built-in templates ---------------------------------------------------------------------
+
+/// Points on an elliptic arc in a unit box (y down); angles in degrees, 0° = right,
+/// 90° = bottom
+fn arc(cx: f32, cy: f32, rx: f32, ry: f32, from: f32, to: f32) -> Vec<Vec2> {
+    const STEPS: usize = 24;
+    (0..=STEPS)
+        .map(|i| {
+            let a = (from + (to - from) * i as f32 / STEPS as f32).to_radians();
+            Vec2::new(cx + rx * a.cos(), cy + ry * a.sin())
+        })
+        .collect()
+}
+
+/// Usual width of a symbol relative to its height; the templates below are drawn in a
+/// square and narrowed by this
+fn template_width(symbol: char) -> f32 {
+    match symbol {
+        '0'..='9' | 'b' | 'y' => 0.65,
+        '/' => 0.8,
+        _ => 1.0,
+    }
+}
+
+fn polyline(points: &[(f32, f32)]) -> Vec<Vec2> {
+    points.iter().map(|&(x, y)| Vec2::new(x, y)).collect()
+}
+
+fn chain(parts: &[Vec<Vec2>]) -> Vec<Vec2> {
+    parts.concat()
+}
+
+/// Several ways to write each symbol; strokes in a unit box with y pointing down
+fn builtin_templates() -> Vec<(char, Vec<Vec<Vec2>>)> {
+    vec![
+        ('0', vec![arc(0.5, 0.5, 0.35, 0.5, -90.0, 270.0)]),
+        ('0', vec![arc(0.5, 0.5, 0.3, 0.5, -100.0, -460.0)]),
+        ('1', vec![polyline(&[(0.5, 0.0), (0.5, 1.0)])]),
+        ('1', vec![polyline(&[(0.3, 0.2), (0.55, 0.0), (0.55, 1.0)])]),
+        (
+            '2',
+            vec![chain(&[
+                arc(0.5, 0.3, 0.35, 0.3, 190.0, 400.0),
+                polyline(&[(0.1, 1.0), (0.9, 1.0)]),
+            ])],
+        ),
+        (
+            '2',
+            vec![chain(&[
+                arc(0.5, 0.3, 0.35, 0.3, 200.0, 380.0),
+                polyline(&[(0.15, 0.95)]),
+                arc(0.5, 1.15, 0.4, 0.25, 200.0, 330.0),
+            ])],
+        ),
+        (
+            '3',
+            vec![chain(&[
+                arc(0.5, 0.25, 0.35, 0.25, 200.0, 450.0),
+                arc(0.5, 0.75, 0.38, 0.25, 270.0, 520.0),
+            ])],
+        ),
+        (
+            '4',
+            vec![
+                polyline(&[(0.6, 0.0), (0.1, 0.65), (0.9, 0.65)]),
+                polyline(&[(0.65, 0.3), (0.65, 1.0)]),
+            ],
+        ),
+        (
+            '4',
+            vec![
+                polyline(&[(0.2, 0.0), (0.15, 0.6), (0.9, 0.6)]),
+                polyline(&[(0.7, 0.05), (0.7, 1.0)]),
+            ],
+        ),
+        (
+            '4',
+            vec![polyline(&[
+                (0.6, 0.0),
+                (0.1, 0.65),
+                (0.9, 0.65),
+                (0.65, 0.65),
+                (0.65, 0.3),
+                (0.65, 1.0),
+            ])],
+        ),
+        (
+            '5',
+            vec![chain(&[
+                polyline(&[(0.8, 0.0), (0.25, 0.0), (0.2, 0.45)]),
+                arc(0.5, 0.7, 0.35, 0.3, 225.0, 510.0),
+            ])],
+        ),
+        (
+            '5',
+            vec![
+                chain(&[
+                    polyline(&[(0.25, 0.0), (0.2, 0.45)]),
+                    arc(0.5, 0.7, 0.35, 0.3, 225.0, 510.0),
+                ]),
+                polyline(&[(0.25, 0.0), (0.85, 0.0)]),
+            ],
+        ),
+        (
+            '6',
+            vec![chain(&[
+                polyline(&[(0.75, 0.0), (0.45, 0.12), (0.25, 0.35), (0.16, 0.65)]),
+                arc(0.5, 0.72, 0.34, 0.28, 180.0, -180.0),
+            ])],
+        ),
+        ('7', vec![polyline(&[(0.1, 0.0), (0.9, 0.0), (0.35, 1.0)])]),
+        (
+            '7',
+            vec![
+                polyline(&[(0.1, 0.0), (0.9, 0.0), (0.35, 1.0)]),
+                polyline(&[(0.35, 0.5), (0.85, 0.5)]),
+            ],
+        ),
+        (
+            '8',
+            vec![chain(&[
+                arc(0.5, 0.25, 0.28, 0.25, 0.0, 360.0),
+                arc(0.5, 0.75, 0.35, 0.25, 0.0, -360.0),
+            ])],
+        ),
+        (
+            '8',
+            vec![chain(&[
+                arc(0.5, 0.25, 0.3, 0.25, 90.0, -270.0),
+                arc(0.5, 0.75, 0.36, 0.25, -90.0, 270.0),
+            ])],
+        ),
+        (
+            '9',
+            vec![chain(&[
+                arc(0.5, 0.28, 0.32, 0.28, 0.0, -360.0),
+                polyline(&[(0.82, 0.28), (0.75, 1.0)]),
+            ])],
+        ),
+        (
+            '9',
+            vec![chain(&[
+                arc(0.5, 0.28, 0.32, 0.28, 0.0, -360.0),
+                arc(0.42, 0.28, 0.4, 0.72, 0.0, 100.0),
+            ])],
+        ),
+        (
+            '+',
+            vec![
+                polyline(&[(0.0, 0.5), (1.0, 0.5)]),
+                polyline(&[(0.5, 0.0), (0.5, 1.0)]),
+            ],
+        ),
+        ('(', vec![arc(1.0, 0.5, 0.7, 0.5, 240.0, 120.0)]),
+        ('(', vec![arc(1.2, 0.5, 0.9, 0.55, 235.0, 125.0)]),
+        (')', vec![arc(0.0, 0.5, 0.7, 0.5, -60.0, 60.0)]),
+        (')', vec![arc(-0.2, 0.5, 0.9, 0.55, -55.0, 55.0)]),
+        ('/', vec![polyline(&[(0.75, 0.0), (0.25, 1.0)])]),
+        (
+            'x',
+            vec![
+                polyline(&[(0.0, 0.0), (1.0, 1.0)]),
+                polyline(&[(1.0, 0.0), (0.0, 1.0)]),
+            ],
+        ),
+        (
+            'x',
+            vec![
+                arc(0.0, 0.5, 0.45, 0.5, -90.0, 90.0),
+                arc(1.0, 0.5, 0.45, 0.5, 270.0, 90.0),
+            ],
+        ),
+        (
+            'y',
+            vec![
+                polyline(&[(0.0, 0.0), (0.5, 0.5)]),
+                polyline(&[(1.0, 0.0), (0.2, 1.0)]),
+            ],
+        ),
+        (
+            'y',
+            vec![chain(&[
+                polyline(&[(0.05, 0.0), (0.1, 0.35)]),
+                arc(0.45, 0.35, 0.35, 0.15, 180.0, 90.0),
+                polyline(&[(0.8, 0.0), (0.8, 0.8)]),
+                arc(0.45, 0.8, 0.35, 0.2, 0.0, 150.0),
+            ])],
+        ),
+        (
+            'a',
+            vec![chain(&[
+                arc(0.45, 0.5, 0.4, 0.45, -20.0, -380.0),
+                polyline(&[(0.85, 0.05), (0.85, 1.0)]),
+            ])],
+        ),
+        (
+            'a',
+            vec![chain(&[
+                arc(0.45, 0.5, 0.4, 0.45, -20.0, -380.0),
+                polyline(&[(0.85, 0.05), (0.85, 0.9), (1.0, 1.0)]),
+            ])],
+        ),
+        (
+            'b',
+            vec![chain(&[
+                polyline(&[(0.2, 0.0), (0.2, 1.0)]),
+                arc(0.5, 0.72, 0.3, 0.28, 180.0, -180.0),
+            ])],
+        ),
+        (
+            'b',
+            vec![chain(&[
+                polyline(&[(0.2, 0.0), (0.2, 0.95)]),
+                arc(0.5, 0.72, 0.3, 0.28, 160.0, 520.0),
+            ])],
+        ),
+    ]
+}
+
+// --- Grouping strokes into symbols ----------------------------------------------------------
+
+/// Placeholder symbols before the structure is known
+const LINE: char = '—';
+const DOT: char = '•';
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+enum Kind {
+    /// Straight, roughly horizontal: minus, fraction bar or half of `=`
+    Line,
+    /// Small: multiplication dot, half of `:` or decimal comma
+    Dot,
+    Other,
+}
+
+struct StrokeInfo {
+    min: Vec2,
+    max: Vec2,
+    straight_horizontal: bool,
+}
+
+impl StrokeInfo {
+    fn new(points: &[Vec2]) -> StrokeInfo {
+        let (min, max) = points.iter().fold(
+            (Vec2::splat(f32::MAX), Vec2::splat(f32::MIN)),
+            |(lo, hi), p| (lo.min(*p), hi.max(*p)),
+        );
+        let size = max - min;
+        let straight_horizontal =
+            size.x > 0.0 && size.x >= 2.5 * size.y && path_length(points) <= 1.3 * size.x;
+        StrokeInfo {
+            min,
+            max,
+            straight_horizontal,
+        }
+    }
+
+    fn size(&self) -> Vec2 {
+        self.max - self.min
+    }
+
+    fn kind(&self, line_height: f32) -> Kind {
+        if self.size().max_element() < 0.2 * line_height {
+            Kind::Dot
+        } else if self.straight_horizontal {
+            Kind::Line
+        } else {
+            Kind::Other
+        }
+    }
+}
+
+/// Typical symbol height: the median height of the strokes that are not lines
+fn line_height(infos: &[StrokeInfo]) -> f32 {
+    let mut heights: Vec<f32> = infos
+        .iter()
+        .filter(|i| !i.straight_horizontal)
+        .map(|i| i.size().y)
+        .collect();
+    if heights.is_empty() {
+        heights = infos.iter().map(|i| i.size().max_element()).collect();
+    }
+    heights.sort_by(f32::total_cmp);
+    // The upper median, so that small symbols (dots, exponents) do not dominate
+    heights[heights.len() * 2 / 3].max(1e-3)
+}
+
+fn bounds<'a>(infos: impl Iterator<Item = &'a StrokeInfo>) -> (Vec2, Vec2) {
+    infos.fold(
+        (Vec2::splat(f32::MAX), Vec2::splat(f32::MIN)),
+        |(lo, hi), i| (lo.min(i.min), hi.max(i.max)),
+    )
+}
+
+/// Joins each stroke with the symbol written just before it if they belong together
+fn group_strokes(
+    strokes: &[Vec<Vec2>],
+    infos: &[StrokeInfo],
+    kinds: &[Kind],
+    line_height: f32,
+) -> Vec<Vec<usize>> {
+    let mut groups: Vec<Vec<usize>> = Vec::new();
+    for (i, info) in infos.iter().enumerate() {
+        let joins = groups.last().is_some_and(|group| {
+            let (gmin, gmax) = bounds(group.iter().map(|&j| &infos[j]));
+            let gsize = gmax - gmin;
+            let group_kinds: Vec<Kind> = group.iter().map(|&j| kinds[j]).collect();
+            if kinds[i] == Kind::Dot || group_kinds.contains(&Kind::Dot) {
+                return false;
+            }
+            let touches = || {
+                group
+                    .iter()
+                    .any(|&j| polyline_distance(&strokes[i], &strokes[j]) < 0.12 * line_height)
+            };
+            let only_lines = group_kinds.iter().all(|k| *k == Kind::Line);
+            match (kinds[i], only_lines) {
+                // Two lines are `=` or a fraction bar and a minus; decided later
+                (Kind::Line, true) => false,
+                // The bar of `+`, `7` or `5`: it crosses or touches the symbol and is not much
+                // wider (a fraction bar is wider than the numerator and lies below it)
+                (Kind::Line, false) => info.size().x <= 1.5 * gsize.max_element() && touches(),
+                (_, true) => gsize.x <= 1.5 * info.size().max_element() && touches(),
+                _ => {
+                    let margin = 0.1 * line_height;
+                    let overlap_x =
+                        info.max.x.min(gmax.x + margin) - info.min.x.max(gmin.x - margin);
+                    let overlap_y =
+                        info.max.y.min(gmax.y + margin) - info.min.y.max(gmin.y - margin);
+                    overlap_x >= 0.3 * info.size().x.min(gsize.x)
+                        && overlap_x > 0.0
+                        && overlap_y > 0.0
+                }
+            }
+        });
+        match groups.last_mut() {
+            Some(group) if joins => group.push(i),
+            _ => groups.push(vec![i]),
+        }
+    }
+    groups
+}
+
+fn point_segment_distance(p: Vec2, a: Vec2, b: Vec2) -> f32 {
+    let ab = b - a;
+    let t = if ab.length_squared() > 0.0 {
+        ((p - a).dot(ab) / ab.length_squared()).clamp(0.0, 1.0)
+    } else {
+        0.0
+    };
+    p.distance(a + ab * t)
+}
+
+fn segment_distance(a0: Vec2, a1: Vec2, b0: Vec2, b1: Vec2) -> f32 {
+    let cross = |o: Vec2, p: Vec2, q: Vec2| (p - o).perp_dot(q - o);
+    let (d1, d2) = (cross(b0, b1, a0), cross(b0, b1, a1));
+    let (d3, d4) = (cross(a0, a1, b0), cross(a0, a1, b1));
+    if d1 * d2 < 0.0 && d3 * d4 < 0.0 {
+        return 0.0;
+    }
+    point_segment_distance(a0, b0, b1)
+        .min(point_segment_distance(a1, b0, b1))
+        .min(point_segment_distance(b0, a0, a1))
+        .min(point_segment_distance(b1, a0, a1))
+}
+
+/// Smallest distance between two polylines (0 if they cross)
+fn polyline_distance(a: &[Vec2], b: &[Vec2]) -> f32 {
+    let segments = |p: &[Vec2]| -> Vec<(Vec2, Vec2)> {
+        match p {
+            [only] => vec![(*only, *only)],
+            _ => p.windows(2).map(|w| (w[0], w[1])).collect(),
+        }
+    };
+    let (sa, sb) = (segments(a), segments(b));
+    sa.iter()
+        .flat_map(|&(a0, a1)| {
+            sb.iter()
+                .map(move |&(b0, b1)| segment_distance(a0, a1, b0, b1))
+        })
+        .fold(f32::MAX, f32::min)
+}
+
+// --- Structure ------------------------------------------------------------------------------
+
+/// A symbol, or a fraction made of several (then `text` holds its text)
+#[derive(Debug, Clone)]
+struct Element {
+    symbol: Symbol,
+    text: Option<(String, Vec<Element>)>,
+}
+
+impl Element {
+    fn center(&self) -> Vec2 {
+        (self.symbol.min + self.symbol.max) / 2.0
+    }
+
+    fn height(&self) -> f32 {
+        self.symbol.max.y - self.symbol.min.y
+    }
+
+    fn width(&self) -> f32 {
+        self.symbol.max.x - self.symbol.min.x
+    }
+
+    fn is_operand(&self) -> bool {
+        self.text.is_some() || self.symbol.ch.is_ascii_alphanumeric() || self.symbol.ch == ')'
+    }
+
+    fn collect_symbols(self, out: &mut Vec<Symbol>) {
+        match self.text {
+            Some((_, parts)) => {
+                for part in parts {
+                    part.collect_symbols(out);
+                }
+            }
+            None => out.push(self.symbol),
+        }
+    }
+}
+
+fn merged(a: &Element, b: &Element, ch: char) -> Element {
+    let mut strokes = a.symbol.strokes.clone();
+    strokes.extend(&b.symbol.strokes);
+    Element {
+        symbol: Symbol {
+            ch,
+            min: a.symbol.min.min(b.symbol.min),
+            max: a.symbol.max.max(b.symbol.max),
+            strokes,
+        },
+        text: None,
+    }
+}
+
+/// Two stacked lines of similar length become `=`, two stacked dots `:`
+fn pair_stacked(mut elements: Vec<Element>, line_height: f32) -> Vec<Element> {
+    let mut i = 0;
+    while i < elements.len() {
+        let partner = (0..elements.len()).find(|&j| {
+            if j == i {
+                return false;
+            }
+            let (a, b) = (&elements[i], &elements[j]);
+            let dy = (a.center().y - b.center().y).abs();
+            match (a.symbol.ch, b.symbol.ch) {
+                (LINE, LINE) => {
+                    let overlap =
+                        a.symbol.max.x.min(b.symbol.max.x) - a.symbol.min.x.max(b.symbol.min.x);
+                    let (short, long) = (a.width().min(b.width()), a.width().max(b.width()));
+                    overlap >= 0.5 * short && long <= 2.0 * short && dy < 0.7 * line_height
+                }
+                (DOT, DOT) => {
+                    (a.center().x - b.center().x).abs() < 0.3 * line_height
+                        && dy > 0.15 * line_height
+                        && dy < line_height
+                }
+                _ => false,
+            }
+        });
+        if let Some(j) = partner {
+            let ch = if elements[i].symbol.ch == LINE {
+                '='
+            } else {
+                ':'
+            };
+            let pair = merged(&elements[i], &elements[j], ch);
+            let (first, second) = (i.min(j), i.max(j));
+            elements.remove(second);
+            elements[first] = pair;
+        }
+        i += 1;
+    }
+    elements
+}
+
+/// Lines with symbols above and below become fractions, the narrowest first so that nested
+/// fractions work
+fn build_fractions(mut elements: Vec<Element>, line_height: f32) -> Vec<Element> {
+    loop {
+        let mut bars: Vec<usize> = (0..elements.len())
+            .filter(|&i| elements[i].symbol.ch == LINE)
+            .collect();
+        bars.sort_by(|&a, &b| elements[a].width().total_cmp(&elements[b].width()));
+        let found = bars.into_iter().find_map(|bar| {
+            let b = &elements[bar];
+            let y = b.center().y;
+            let margin = 0.1 * line_height;
+            let inside = |e: &Element| {
+                let c = e.center().x;
+                c >= b.symbol.min.x - margin && c <= b.symbol.max.x + margin
+            };
+            let mut above = Vec::new();
+            let mut below = Vec::new();
+            for (i, e) in elements.iter().enumerate() {
+                if i == bar || !inside(e) {
+                    continue;
+                }
+                if e.symbol.max.y <= y + margin && e.symbol.max.y > y - 1.5 * line_height {
+                    above.push(i);
+                } else if e.symbol.min.y >= y - margin && e.symbol.min.y < y + 1.5 * line_height {
+                    below.push(i);
+                }
+            }
+            (!above.is_empty() && !below.is_empty()).then_some((bar, above, below))
+        });
+        let Some((bar, above, below)) = found else {
+            return elements;
+        };
+        let take = |indices: &[usize]| -> Vec<Element> {
+            indices.iter().map(|&i| elements[i].clone()).collect()
+        };
+        let numerator = take(&above);
+        let denominator = take(&below);
+        let text = format!(
+            "(({})/({}))",
+            layout(&numerator, line_height),
+            layout(&denominator, line_height)
+        );
+        let mut fraction = elements[bar].clone();
+        // No longer a line, so that it is not taken as a bar again
+        fraction.symbol.ch = '/';
+        for part in numerator.iter().chain(&denominator) {
+            fraction.symbol.min = fraction.symbol.min.min(part.symbol.min);
+            fraction.symbol.max = fraction.symbol.max.max(part.symbol.max);
+        }
+        let mut parts = numerator;
+        parts.extend(denominator);
+        let mut bar_element = elements[bar].clone();
+        bar_element.symbol.ch = '/';
+        parts.push(bar_element);
+        fraction.symbol.strokes = parts
+            .iter()
+            .flat_map(|p| p.symbol.strokes.clone())
+            .collect();
+        fraction.text = Some((text, parts));
+        let mut removed: Vec<usize> = above.into_iter().chain(below).chain([bar]).collect();
+        removed.sort_unstable();
+        let at = removed[0];
+        for &i in removed.iter().rev() {
+            elements.remove(i);
+        }
+        elements.insert(at, fraction);
+    }
+}
+
+/// Is `e` written raised next to `base`, i.e. an exponent? Its bottom is well above the
+/// bottom of `base`, and its middle is in the upper part of `base`. A minus has to be at
+/// about the top of `base`, so that a minus after a small letter such as `x` stays a minus.
+fn is_raised(e: &Element, base: &Element, line_height: f32) -> bool {
+    let (rise, upper_part) = if e.symbol.ch == LINE {
+        (0.6, 0.1)
+    } else {
+        (0.45, 0.35)
+    };
+    e.symbol.max.y < base.symbol.max.y - rise * line_height
+        && e.center().y < base.symbol.min.y + upper_part * base.height()
+}
+
+/// Text of the elements from left to right, with exponents as `^(…)`
+fn layout(elements: &[Element], line_height: f32) -> String {
+    let mut sorted: Vec<&Element> = elements.iter().collect();
+    sorted.sort_by(|a, b| a.symbol.min.x.total_cmp(&b.symbol.min.x));
+    let mut out = String::new();
+    let mut base: Option<&Element> = None;
+    // The first symbol of the exponent being read
+    let mut exponent: Option<&Element> = None;
+    for (k, e) in sorted.iter().enumerate() {
+        match exponent {
+            None => {
+                let starts_exponent = e.is_operand() || matches!(e.symbol.ch, '(' | LINE);
+                if base.is_some_and(|b| starts_exponent && is_raised(e, b, line_height)) {
+                    out.push_str("^(");
+                    exponent = Some(e);
+                }
+            }
+            // The exponent goes on as long as the symbols stay as high as its first one (or
+            // are raised themselves, after a minus)
+            Some(first) => {
+                let high = e.center().y < first.symbol.max.y
+                    || base.is_some_and(|b| is_raised(e, b, line_height));
+                if e.symbol.ch == '=' || !high {
+                    out.push(')');
+                    exponent = None;
+                }
+            }
+        }
+        let previous_digit = out.chars().last().is_some_and(|c| c.is_ascii_digit());
+        let next_digit = sorted
+            .get(k + 1)
+            .is_some_and(|n| n.text.is_none() && n.symbol.ch.is_ascii_digit());
+        match (&e.text, e.symbol.ch) {
+            (Some((text, _)), _) => out.push_str(text),
+            (None, LINE) => out.push('-'),
+            (None, DOT) => {
+                // Low between digits it is a decimal comma, otherwise a multiplication dot
+                let low = base.is_some_and(|b| e.center().y > b.symbol.min.y + 0.7 * b.height());
+                out.push(if low && previous_digit && next_digit {
+                    ','
+                } else {
+                    '·'
+                });
+            }
+            // An x between two numbers is a multiplication sign
+            (None, 'x') if previous_digit && next_digit => out.push('·'),
+            (None, ch) => out.push(ch),
+        }
+        if exponent.is_none() && e.is_operand() {
+            base = Some(e);
+        }
+    }
+    if exponent.is_some() {
+        out.push(')');
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Deterministic pseudo-random numbers in [-1, 1]
+    struct Jitter(u64);
+
+    impl Jitter {
+        fn next(&mut self) -> f32 {
+            self.0 = self
+                .0
+                .wrapping_mul(6364136223846793005)
+                .wrapping_add(1442695040888963407);
+            ((self.0 >> 33) as f32 / (1u64 << 31) as f32) * 2.0 - 1.0
+        }
+    }
+
+    /// Writes `symbol` in a box at `origin` with the given size, slanted, with jittered
+    /// points and every stroke reversed if `reverse`, using the `variant`-th built-in template
+    fn write(
+        symbol: char,
+        variant: usize,
+        origin: Vec2,
+        size: Vec2,
+        jitter: &mut Jitter,
+        reverse: bool,
+    ) -> Vec<Vec<Vec2>> {
+        let strokes = builtin_templates()
+            .into_iter()
+            .filter(|(s, _)| *s == symbol)
+            .nth(variant)
+            .unwrap_or_else(|| panic!("no template {variant} for {symbol}"))
+            .1;
+        // Slanted, slightly rotated and smoothly warped like real handwriting, plus a little
+        // pen noise
+        let slant = 0.15 + 0.1 * jitter.next();
+        let rotation = Vec2::from_angle(0.08 * jitter.next());
+        let (fx, fy) = (1.0 + 0.5 * jitter.next(), 1.0 + 0.5 * jitter.next());
+        let (px, py) = (3.0 * jitter.next(), 3.0 * jitter.next());
+        strokes
+            .into_iter()
+            .map(|stroke| {
+                let mut points: Vec<Vec2> = stroke
+                    .iter()
+                    .map(|p| {
+                        let warp =
+                            Vec2::new((p.y * fx * 4.0 + px).sin(), (p.x * fy * 6.0 + py).sin())
+                                * 0.04;
+                        let noise = Vec2::new(jitter.next(), jitter.next()) * 0.005;
+                        let p = Vec2::new(p.x + slant * (1.0 - p.y), p.y) + warp + noise;
+                        origin + rotation.rotate(p - 0.5) * size + 0.5 * size
+                    })
+                    .collect();
+                if reverse {
+                    points.reverse();
+                }
+                points
+            })
+            .collect()
+    }
+
+    fn line(from: Vec2, to: Vec2) -> Vec<Vec2> {
+        (0..=8).map(|i| from.lerp(to, i as f32 / 8.0)).collect()
+    }
+
+    fn dot(at: Vec2) -> Vec<Vec2> {
+        vec![at, at + Vec2::new(0.5, 0.4), at + Vec2::new(0.2, 0.8)]
+    }
+
+    #[test]
+    fn classifies_distorted_symbols() {
+        // Synthetic handwriting is no substitute for real samples, but it keeps the templates
+        // apart from each other: at most 1 in 20 distorted symbols may be misread
+        let recognizer = Recognizer::new();
+        let mut jitter = Jitter(7);
+        let templates = builtin_templates();
+        let mut total = 0;
+        let mut wrong = Vec::new();
+        for (index, (symbol, _)) in templates.iter().enumerate() {
+            let variant = templates[..index]
+                .iter()
+                .filter(|(s, _)| s == symbol)
+                .count();
+            for round in 0..6 {
+                let aspect = 1.0 + 0.2 * jitter.next();
+                let strokes = write(
+                    *symbol,
+                    variant,
+                    Vec2::ZERO,
+                    Vec2::new(14.0 * template_width(*symbol) * aspect, 14.0),
+                    &mut jitter,
+                    round % 2 == 1,
+                );
+                let parts: Vec<&[Vec2]> = strokes.iter().map(Vec::as_slice).collect();
+                let (found, distance) = recognizer.classify(&parts).unwrap();
+                total += 1;
+                if found != *symbol || distance > MAX_DISTANCE {
+                    wrong.push((*symbol, variant, found, distance));
+                }
+            }
+        }
+        assert!(
+            wrong.len() * 20 <= total,
+            "misread {} of {total}: {wrong:?}",
+            wrong.len()
+        );
+    }
+
+    /// Writes the symbols of `text` from left to right; `^` raises the next symbol
+    fn write_line(text: &str, jitter: &mut Jitter) -> Vec<Vec<Vec2>> {
+        let mut strokes = Vec::new();
+        let mut x = 0.0;
+        let mut raised = false;
+        for ch in text.chars() {
+            let (y, h) = if raised { (-5.0, 8.0) } else { (0.0, 14.0) };
+            let w = h * 0.7;
+            match ch {
+                '^' => {
+                    raised = true;
+                    continue;
+                }
+                ' ' => x += 4.0,
+                '-' => {
+                    strokes.push(line(
+                        Vec2::new(x, y + h * 0.5),
+                        Vec2::new(x + w, y + h * 0.5),
+                    ));
+                    x += w + 4.0;
+                }
+                '=' => {
+                    strokes.push(line(Vec2::new(x, 4.0), Vec2::new(x + 10.0, 4.5)));
+                    strokes.push(line(Vec2::new(x, 9.0), Vec2::new(x + 10.0, 9.5)));
+                    x += 14.0;
+                }
+                '·' => {
+                    strokes.push(dot(Vec2::new(x, 6.5)));
+                    x += 5.0;
+                }
+                ',' => {
+                    strokes.push(dot(Vec2::new(x, 13.0)));
+                    x += 4.0;
+                }
+                ':' => {
+                    strokes.push(dot(Vec2::new(x, 3.0)));
+                    strokes.push(dot(Vec2::new(x, 10.0)));
+                    x += 5.0;
+                }
+                _ => {
+                    // Lowercase letters are smaller and sit on the baseline, `y` goes below it
+                    let (top, size) = match ch {
+                        'a' | 'x' => (y + 0.4 * h, Vec2::splat(0.6 * h)),
+                        'y' => (y + 0.4 * h, Vec2::new(0.5 * h, 0.9 * h)),
+                        '+' => (y + 0.15 * h, Vec2::splat(0.7 * h)),
+                        _ => (y, Vec2::new(template_width(ch) * h, h)),
+                    };
+                    strokes.extend(write(ch, 0, Vec2::new(x, top), size, jitter, false));
+                    x += size.x + 4.0;
+                }
+            }
+            raised = false;
+        }
+        strokes
+    }
+
+    #[test]
+    fn reads_expressions() {
+        let cases = [
+            ("2^4=", "2^(4)="),
+            ("12+34=", "12+34="),
+            ("(x+3)^2=", "(x+3)^(2)="),
+            ("7-5=", "7-5="),
+            ("2,5·3=", "2,5·3="),
+            ("9:3=", "9:3="),
+            ("2x3=", "2·3="),
+            ("(a+b)^2=", "(a+b)^(2)="),
+            ("x^2+2x=", "x^(2)+2x="),
+            ("x^2-1=", "x^(2)-1="),
+            ("y^1^0=", "y^(10)="),
+            ("2^x^+^1=", "2^(x+1)="),
+            ("2^-^1=", "2^(-1)="),
+            ("56·78=", "56·78="),
+            ("90-1=", "90-1="),
+            ("3(x+1)=", "3(x+1)="),
+            ("(x+1)(x-1)=", "(x+1)(x-1)="),
+            ("b^2:4=", "b^(2):4="),
+            ("y·y·y=", "y·y·y="),
+        ];
+        let recognizer = Recognizer::new();
+        for seed in 1..=4 {
+            for (written, expected) in cases {
+                let strokes = write_line(written, &mut Jitter(seed));
+                let text = recognizer.recognize(&strokes).unwrap().text;
+                assert_eq!(text, expected, "{written} (seed {seed})");
+            }
+        }
+    }
+
+    fn read(text: &str) -> String {
+        let strokes = write_line(text, &mut Jitter(11));
+        Recognizer::new().recognize(&strokes).unwrap().text
+    }
+
+    #[test]
+    fn reads_fractions() {
+        let mut jitter = Jitter(3);
+        let mut strokes = write(
+            '1',
+            0,
+            Vec2::new(2.0, -16.0),
+            Vec2::new(8.0, 13.0),
+            &mut jitter,
+            false,
+        );
+        strokes.push(line(Vec2::new(0.0, 0.0), Vec2::new(12.0, 0.3)));
+        strokes.extend(write(
+            '2',
+            0,
+            Vec2::new(2.0, 3.0),
+            Vec2::new(8.0, 13.0),
+            &mut jitter,
+            false,
+        ));
+        strokes.extend(write(
+            '+',
+            0,
+            Vec2::new(16.0, -5.0),
+            Vec2::new(9.0, 9.0),
+            &mut jitter,
+            false,
+        ));
+        strokes.extend(write(
+            '3',
+            0,
+            Vec2::new(29.0, -7.0),
+            Vec2::new(9.0, 14.0),
+            &mut jitter,
+            false,
+        ));
+        strokes.push(line(Vec2::new(42.0, -3.0), Vec2::new(52.0, -3.0)));
+        strokes.push(line(Vec2::new(42.0, 2.0), Vec2::new(52.0, 2.0)));
+        let recognition = Recognizer::new().recognize(&strokes).unwrap();
+        assert_eq!(recognition.text, "((1)/(2))+3=");
+        assert_eq!(
+            crate::math::solve(&recognition.text, true),
+            Some("3,5".into())
+        );
+    }
+
+    fn shifted(strokes: Vec<Vec<Vec2>>, offset: Vec2) -> Vec<Vec<Vec2>> {
+        strokes
+            .into_iter()
+            .map(|s| s.into_iter().map(|p| p + offset).collect())
+            .collect()
+    }
+
+    #[test]
+    fn reads_fractions_with_expressions() {
+        let mut jitter = Jitter(9);
+        // (x+1)/2 + 1/(2·3) =, with the bars drawn after the numerators
+        let mut strokes = shifted(write_line("x+1", &mut jitter), Vec2::new(2.0, -17.0));
+        strokes.push(line(Vec2::new(0.0, 0.0), Vec2::new(40.0, 0.5)));
+        strokes.extend(shifted(write_line("2", &mut jitter), Vec2::new(14.0, 3.0)));
+        strokes.extend(shifted(write_line("+", &mut jitter), Vec2::new(46.0, -7.0)));
+        strokes.extend(shifted(
+            write_line("1", &mut jitter),
+            Vec2::new(70.0, -17.0),
+        ));
+        strokes.push(line(Vec2::new(62.0, 0.0), Vec2::new(90.0, 0.0)));
+        strokes.extend(shifted(
+            write_line("2·3", &mut jitter),
+            Vec2::new(64.0, 3.0),
+        ));
+        strokes.extend(shifted(write_line("=", &mut jitter), Vec2::new(96.0, -7.0)));
+        let recognition = Recognizer::new().recognize(&strokes).unwrap();
+        assert_eq!(recognition.text, "((x+1)/(2))+((1)/(2·3))=");
+        assert_eq!(
+            crate::math::solve(&recognition.text, true),
+            Some("0,5x + 2/3".into())
+        );
+    }
+
+    #[test]
+    fn recognized_text_can_be_computed() {
+        let solve = |text: &str| crate::math::solve(&read(text), true);
+        assert_eq!(solve("2^4="), Some("16".into()));
+        assert_eq!(solve("(x+3)^2="), Some("x² + 6x + 9".into()));
+        assert_eq!(solve("2,5·3="), Some("7,5".into()));
+        assert_eq!(solve("9:3="), Some("3".into()));
+    }
+
+    #[test]
+    fn symbols_cover_their_strokes() {
+        let strokes = write_line("4+7=", &mut Jitter(5));
+        let recognition = Recognizer::new().recognize(&strokes).unwrap();
+        let chars: String = recognition.symbols.iter().map(|s| s.ch).collect();
+        assert_eq!(chars, "4+7=");
+        let mut covered: Vec<usize> = recognition
+            .symbols
+            .iter()
+            .flat_map(|s| s.strokes.iter().copied())
+            .collect();
+        covered.sort_unstable();
+        assert_eq!(covered, (0..strokes.len()).collect::<Vec<_>>());
+    }
+
+    #[test]
+    fn scribbles_are_not_recognized() {
+        let recognizer = Recognizer::new();
+        let zigzag: Vec<Vec2> = (0..40)
+            .map(|i| Vec2::new(i as f32, if i % 2 == 0 { 0.0 } else { 10.0 }))
+            .collect();
+        let recognition = recognizer.recognize(&[zigzag]).unwrap();
+        assert_eq!(recognition.text, "?");
+        assert!(recognizer.recognize(&[]).is_none());
+    }
+}