@mlightcad/cad-pdf-plugin 1.8.0-preview.2 → 1.8.0-preview.4

package/lib/recognition/pdfGlyphClustering.js

@@ -0,0 +1,1005 @@
+/**
+ * Groups exploded text strokes (SHX line text, outlined fonts) into text
+ * line candidates with a CAD placement.
+ *
+ * Pure geometry: strokes are plain point lists, so the algorithm is
+ * unit-testable without the data model. The `pdftext` command samples
+ * entities into strokes and turns candidates into `AcDbText`.
+ */
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+function strokeBox(stroke) {
+    var e_1, _a;
+    var minX = Infinity;
+    var minY = Infinity;
+    var maxX = -Infinity;
+    var maxY = -Infinity;
+    try {
+        for (var _b = __values(stroke.points), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var p = _c.value;
+            minX = Math.min(minX, p.x);
+            minY = Math.min(minY, p.y);
+            maxX = Math.max(maxX, p.x);
+            maxY = Math.max(maxY, p.y);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return { minX: minX, minY: minY, maxX: maxX, maxY: maxY };
+}
+function boxSize(box) {
+    return Math.max(box.maxX - box.minX, box.maxY - box.minY);
+}
+function boxGap(a, b) {
+    var dx = Math.max(0, a.minX - b.maxX, b.minX - a.maxX);
+    var dy = Math.max(0, a.minY - b.maxY, b.minY - a.maxY);
+    return Math.hypot(dx, dy);
+}
+function percentile(sorted, q) {
+    if (sorted.length === 0)
+        return 0;
+    var index = Math.min(sorted.length - 1, Math.max(0, Math.round(q * (sorted.length - 1))));
+    return sorted[index];
+}
+/**
+ * Estimates text height from the sizes of glyph parts. Parts far above the
+ * median are treated as non-text so a frame in the selection does not skew
+ * the result.
+ *
+ * Strokes chained end to end are measured together: some PDFs store a glyph
+ * stroke as many tiny separate segments, each far smaller than the text.
+ */
+export function estimatePdfTextHeight(strokes) {
+    var sized = strokes.filter(function (stroke) { return boxSize(strokeBox(stroke)) > 0; });
+    if (sized.length === 0)
+        return 0;
+    var strokeMedian = percentile(sized.map(function (stroke) { return boxSize(strokeBox(stroke)); }).sort(byNumber), 0.5);
+    var sizes = chainStrokes(sized, strokeMedian * 0.01)
+        .map(function (group) {
+        return boxSize(strokeBox({ id: 0, points: group.flatMap(function (i) { return sized[i].points; }) }));
+    })
+        .sort(byNumber);
+    var median = percentile(sizes, 0.5);
+    var textLike = sizes.filter(function (size) { return size <= median * 4; });
+    return percentile(textLike, 0.9);
+}
+function byNumber(a, b) {
+    return a - b;
+}
+/**
+ * Groups strokes whose end points meet within `tolerance` (a stroke split
+ * into consecutive segments), using a hash grid of end points.
+ *
+ * @param canJoin - Optional extra condition for joining two strokes.
+ */
+function chainStrokes(strokes, tolerance, canJoin) {
+    var uf = new UnionFind(strokes.length);
+    var cell = Math.max(tolerance, 1e-12);
+    var grid = new Map();
+    strokes.forEach(function (stroke, index) {
+        var e_2, _a, e_3, _b;
+        var _c;
+        var ends = [stroke.points[0], stroke.points[stroke.points.length - 1]];
+        try {
+            for (var ends_1 = __values(ends), ends_1_1 = ends_1.next(); !ends_1_1.done; ends_1_1 = ends_1.next()) {
+                var p = ends_1_1.value;
+                var gx = Math.floor(p.x / cell);
+                var gy = Math.floor(p.y / cell);
+                for (var dx = -1; dx <= 1; dx++) {
+                    for (var dy = -1; dy <= 1; dy++) {
+                        try {
+                            for (var _d = (e_3 = void 0, __values((_c = grid.get("".concat(gx + dx, ",").concat(gy + dy))) !== null && _c !== void 0 ? _c : [])), _e = _d.next(); !_e.done; _e = _d.next()) {
+                                var other = _e.value;
+                                if (Math.hypot(other.p.x - p.x, other.p.y - p.y) <= tolerance &&
+                                    (!canJoin || canJoin(index, other.index))) {
+                                    uf.union(index, other.index);
+                                }
+                            }
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
+                            }
+                            finally { if (e_3) throw e_3.error; }
+                        }
+                    }
+                }
+                var key = "".concat(gx, ",").concat(gy);
+                var bucket = grid.get(key);
+                if (bucket)
+                    bucket.push({ index: index, p: p });
+                else
+                    grid.set(key, [{ index: index, p: p }]);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (ends_1_1 && !ends_1_1.done && (_a = ends_1.return)) _a.call(ends_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    });
+    var groups = new Map();
+    strokes.forEach(function (_, i) {
+        var root = uf.find(i);
+        var group = groups.get(root);
+        if (group)
+            group.push(i);
+        else
+            groups.set(root, [i]);
+    });
+    return __spreadArray([], __read(groups.values()), false);
+}
+/** Sine of the largest angle between segments still treated as collinear. */
+var COLLINEAR_SINE = Math.sin((2 * Math.PI) / 180);
+/** Unit direction of a straight stroke, or `undefined` for a curved one. */
+function straightDirection(stroke, tolerance) {
+    var e_4, _a;
+    var a = stroke.points[0];
+    var b = stroke.points[stroke.points.length - 1];
+    var length = Math.hypot(b.x - a.x, b.y - a.y);
+    if (!(length > 0))
+        return undefined;
+    var ux = (b.x - a.x) / length;
+    var uy = (b.y - a.y) / length;
+    try {
+        for (var _b = __values(stroke.points), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var p = _c.value;
+            if (Math.abs((p.x - a.x) * uy - (p.y - a.y) * ux) > tolerance) {
+                return undefined;
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return { x: ux, y: uy };
+}
+/**
+ * Size of the straight line each stroke belongs to: straight strokes that
+ * meet end to end in the same direction are measured together. PDFs often
+ * split table grids and frames into segments shorter than the text, which
+ * would otherwise pass as glyph strokes and glue table cells together.
+ */
+function straightRunSizes(strokes, tolerance) {
+    var e_5, _a;
+    var directions = strokes.map(function (stroke) { return straightDirection(stroke, tolerance); });
+    var runs = chainStrokes(strokes, tolerance, function (i, j) {
+        var a = directions[i];
+        var b = directions[j];
+        return !!a && !!b && Math.abs(a.x * b.y - a.y * b.x) <= COLLINEAR_SINE;
+    });
+    var sizes = new Array(strokes.length);
+    var _loop_1 = function (run) {
+        var size = boxSize(strokeBox({ id: 0, points: run.flatMap(function (i) { return strokes[i].points; }) }));
+        run.forEach(function (i) { return (sizes[i] = size); });
+    };
+    try {
+        for (var runs_1 = __values(runs), runs_1_1 = runs_1.next(); !runs_1_1.done; runs_1_1 = runs_1.next()) {
+            var run = runs_1_1.value;
+            _loop_1(run);
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (runs_1_1 && !runs_1_1.done && (_a = runs_1.return)) _a.call(runs_1);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return sizes;
+}
+var UnionFind = /** @class */ (function () {
+    function UnionFind(n) {
+        this.parent = Array.from({ length: n }, function (_, i) { return i; });
+    }
+    UnionFind.prototype.find = function (i) {
+        while (this.parent[i] !== i) {
+            this.parent[i] = this.parent[this.parent[i]];
+            i = this.parent[i];
+        }
+        return i;
+    };
+    UnionFind.prototype.union = function (a, b) {
+        var ra = this.find(a);
+        var rb = this.find(b);
+        if (ra !== rb)
+            this.parent[ra] = rb;
+    };
+    return UnionFind;
+}());
+/** Joins items whose boxes are within `gap`, using a uniform grid. */
+function clusterBoxes(boxes, gap) {
+    var uf = new UnionFind(boxes.length);
+    var cell = Math.max(gap * 2, 1e-9);
+    var grid = new Map();
+    boxes.forEach(function (box, i) {
+        var e_6, _a;
+        var x0 = Math.floor((box.minX - gap) / cell);
+        var x1 = Math.floor((box.maxX + gap) / cell);
+        var y0 = Math.floor((box.minY - gap) / cell);
+        var y1 = Math.floor((box.maxY + gap) / cell);
+        var seen = new Set();
+        for (var gx = x0; gx <= x1; gx++) {
+            for (var gy = y0; gy <= y1; gy++) {
+                var key = "".concat(gx, ",").concat(gy);
+                var bucket = grid.get(key);
+                if (bucket) {
+                    try {
+                        for (var bucket_1 = (e_6 = void 0, __values(bucket)), bucket_1_1 = bucket_1.next(); !bucket_1_1.done; bucket_1_1 = bucket_1.next()) {
+                            var j = bucket_1_1.value;
+                            if (seen.has(j))
+                                continue;
+                            seen.add(j);
+                            if (boxGap(box, boxes[j]) <= gap)
+                                uf.union(i, j);
+                        }
+                    }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                    finally {
+                        try {
+                            if (bucket_1_1 && !bucket_1_1.done && (_a = bucket_1.return)) _a.call(bucket_1);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                    }
+                    bucket.push(i);
+                }
+                else {
+                    grid.set(key, [i]);
+                }
+            }
+        }
+    });
+    var groups = new Map();
+    boxes.forEach(function (_, i) {
+        var root = uf.find(i);
+        var group = groups.get(root);
+        if (group)
+            group.push(i);
+        else
+            groups.set(root, [i]);
+    });
+    return __spreadArray([], __read(groups.values()), false);
+}
+/**
+ * Baseline direction of a text cluster, in `(-π/2, π/2]`.
+ *
+ * Uses the direction of the minimum-height oriented bounding box (rotating
+ * calipers over the convex hull): along a text line the extent across the
+ * baseline is smallest. Principal axes would be skewed by asymmetric glyphs.
+ * Returns `undefined` when the cluster is not elongated enough to tell.
+ */
+function principalAngle(points) {
+    var e_7, _a;
+    var hull = convexHull(points);
+    if (hull.length < 2)
+        return undefined;
+    var bestAngle = 0;
+    var bestHeight = Infinity;
+    var bestLength = 0;
+    for (var i = 0; i < hull.length; i++) {
+        var a = hull[i];
+        var b = hull[(i + 1) % hull.length];
+        var len = Math.hypot(b.x - a.x, b.y - a.y);
+        if (len === 0)
+            continue;
+        var ux = (b.x - a.x) / len;
+        var uy = (b.y - a.y) / len;
+        var minU = Infinity;
+        var maxU = -Infinity;
+        var minV = Infinity;
+        var maxV = -Infinity;
+        try {
+            for (var hull_1 = (e_7 = void 0, __values(hull)), hull_1_1 = hull_1.next(); !hull_1_1.done; hull_1_1 = hull_1.next()) {
+                var p = hull_1_1.value;
+                var u = p.x * ux + p.y * uy;
+                var v = -p.x * uy + p.y * ux;
+                minU = Math.min(minU, u);
+                maxU = Math.max(maxU, u);
+                minV = Math.min(minV, v);
+                maxV = Math.max(maxV, v);
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (hull_1_1 && !hull_1_1.done && (_a = hull_1.return)) _a.call(hull_1);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        var height = maxV - minV;
+        if (height < bestHeight - 1e-12) {
+            bestHeight = height;
+            bestLength = maxU - minU;
+            bestAngle = Math.atan2(uy, ux);
+        }
+    }
+    // A single glyph or a square block of text has no reliable direction.
+    if (!(bestLength > bestHeight * 1.8))
+        return undefined;
+    return normalizeTextAngle(bestAngle);
+}
+/** Fewest glyph blobs for {@link neighborAngle} to vote on a direction. */
+var NEIGHBOR_MIN_BLOBS = 3;
+/** Width of one direction histogram bin, in radians. */
+var NEIGHBOR_BIN = Math.PI / 180;
+/**
+ * Baseline direction of a phrase from the direction between each glyph and
+ * its nearest neighbor, in `(-π/2, π/2]`.
+ *
+ * Characters of a line are closer to each other than lines are, so the most
+ * common nearest-neighbor direction is the baseline. Unlike the phrase
+ * outline, this also works for blocks taller than wide: a narrow column of
+ * table cells or a paragraph of short lines.
+ *
+ * @returns The direction, or `undefined` when the phrase has fewer than
+ * {@link NEIGHBOR_MIN_BLOBS} glyph blobs.
+ */
+function neighborAngle(strokes, textHeight, wordGap) {
+    var e_8, _a;
+    // Blobs: touching strokes, roughly one glyph or glyph part each.
+    var boxes = strokes.map(strokeBox);
+    var blobs = clusterBoxes(boxes, textHeight * 0.02).map(function (group) {
+        var e_9, _a;
+        var minX = Infinity;
+        var minY = Infinity;
+        var maxX = -Infinity;
+        var maxY = -Infinity;
+        try {
+            for (var group_1 = __values(group), group_1_1 = group_1.next(); !group_1_1.done; group_1_1 = group_1.next()) {
+                var i = group_1_1.value;
+                minX = Math.min(minX, boxes[i].minX);
+                minY = Math.min(minY, boxes[i].minY);
+                maxX = Math.max(maxX, boxes[i].maxX);
+                maxY = Math.max(maxY, boxes[i].maxY);
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (group_1_1 && !group_1_1.done && (_a = group_1.return)) _a.call(group_1);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        return { x: (minX + maxX) / 2, y: (minY + maxY) / 2 };
+    });
+    if (blobs.length < NEIGHBOR_MIN_BLOBS)
+        return undefined;
+    var cell = Math.max(textHeight, 1e-9);
+    var grid = new Map();
+    blobs.forEach(function (blob, i) {
+        var key = "".concat(Math.floor(blob.x / cell), ",").concat(Math.floor(blob.y / cell));
+        var bucket = grid.get(key);
+        if (bucket)
+            bucket.push(i);
+        else
+            grid.set(key, [i]);
+    });
+    var reach = Math.ceil(Math.max(wordGap, 1));
+    var bins = Math.round(Math.PI / NEIGHBOR_BIN);
+    var votes = new Array(bins).fill(0);
+    var angles = [];
+    blobs.forEach(function (blob, i) {
+        var e_10, _a;
+        var _b;
+        var gx = Math.floor(blob.x / cell);
+        var gy = Math.floor(blob.y / cell);
+        var best = -1;
+        var bestDistance = Infinity;
+        for (var dx = -reach; dx <= reach; dx++) {
+            for (var dy = -reach; dy <= reach; dy++) {
+                try {
+                    for (var _c = (e_10 = void 0, __values((_b = grid.get("".concat(gx + dx, ",").concat(gy + dy))) !== null && _b !== void 0 ? _b : [])), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var j = _d.value;
+                        if (j === i)
+                            continue;
+                        var d = Math.hypot(blobs[j].x - blob.x, blobs[j].y - blob.y);
+                        if (d > 0 && d < bestDistance) {
+                            bestDistance = d;
+                            best = j;
+                        }
+                    }
+                }
+                catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                    }
+                    finally { if (e_10) throw e_10.error; }
+                }
+            }
+        }
+        if (best < 0)
+            return;
+        var angle = Math.atan2(blobs[best].y - blob.y, blobs[best].x - blob.x);
+        if (angle < 0)
+            angle += Math.PI;
+        if (angle >= Math.PI)
+            angle -= Math.PI;
+        angles.push(angle);
+        votes[Math.min(bins - 1, Math.floor(angle / NEIGHBOR_BIN))]++;
+    });
+    if (angles.length === 0)
+        return undefined;
+    // Mode of the histogram, smoothed over neighboring bins (circular).
+    var bestBin = 0;
+    var bestScore = -1;
+    for (var b = 0; b < bins; b++) {
+        var score = 0;
+        for (var k = -2; k <= 2; k++)
+            score += votes[(b + k + bins) % bins];
+        if (score > bestScore) {
+            bestScore = score;
+            bestBin = b;
+        }
+    }
+    // Refine: mean of the votes near the mode, unwrapped around it.
+    var center = (bestBin + 0.5) * NEIGHBOR_BIN;
+    var sum = 0;
+    var count = 0;
+    try {
+        for (var angles_1 = __values(angles), angles_1_1 = angles_1.next(); !angles_1_1.done; angles_1_1 = angles_1.next()) {
+            var angle = angles_1_1.value;
+            var delta = angle - center;
+            if (delta > Math.PI / 2)
+                delta -= Math.PI;
+            if (delta < -Math.PI / 2)
+                delta += Math.PI;
+            if (Math.abs(delta) <= 3 * NEIGHBOR_BIN) {
+                sum += delta;
+                count++;
+            }
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (angles_1_1 && !angles_1_1.done && (_a = angles_1.return)) _a.call(angles_1);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    return normalizeTextAngle(center + (count > 0 ? sum / count : 0));
+}
+/** Candidates scoring within this fraction of the best count as a tie. */
+var ANGLE_TIE = 0.05;
+/**
+ * How much better a tilted direction must score than 0° / 90° to be used:
+ * drawings are mostly axis-aligned, and a few glyphs (`Q1`) can make a
+ * slight tilt score marginally better.
+ */
+var TILT_MARGIN = 0.2;
+/** How much better than every other direction a clear direction scores. */
+var ANGLE_CLEAR = 0.25;
+/** Lines shorter than this many times their thickness are not real lines. */
+var MIN_LINE_ASPECT = 1.5;
+/**
+ * Baseline direction of a phrase: among 0°, 90°, the nearest-neighbor vote
+ * and the outline direction, the one whose lines have the tightest glyph
+ * spacing.
+ *
+ * Along the baseline, glyphs of a line are close together. Read across it,
+ * "lines" are columns of characters whose gaps are the line spacing, or
+ * single glyphs / single characters (not elongated) that count as a word
+ * gap. This holds for single lines, paragraphs, widely spaced titles and
+ * narrow table columns alike, where the phrase outline or nearest neighbors
+ * (often parts of one character) fail. Ties keep the earlier candidate, so
+ * horizontal text stays exactly horizontal.
+ *
+ * @returns The direction, and whether it is clear. It is not when the
+ * phrase reads as fewer than three glyphs, or no direction scores clearly
+ * better than the others: short words like `Q1` look the same as one
+ * character read sideways, so only the rest of the drawing can tell.
+ */
+function bestPhraseAngle(strokes, textHeight, wordGap, glyphGap) {
+    var e_11, _a;
+    var candidates = [
+        0,
+        Math.PI / 2,
+        neighborAngle(strokes, textHeight, wordGap),
+        principalAngle(strokes.flatMap(function (stroke) { return stroke.points; }))
+    ].filter(function (angle, i, all) {
+        return angle !== undefined &&
+            all
+                .slice(0, i)
+                .every(function (other) {
+                return other === undefined ||
+                    Math.abs(normalizeTextAngle(other) - normalizeTextAngle(angle)) >
+                        NEIGHBOR_BIN;
+            });
+    });
+    var best = candidates[0];
+    var bestScore = Infinity;
+    var bestGlyphs = 0;
+    var scores = [];
+    var _loop_2 = function (angle) {
+        var e_12, _b, e_13, _c;
+        var gaps = 0;
+        var count = 0;
+        var glyphCount = 0;
+        var local = localStrokes(strokes, angle);
+        try {
+            for (var _d = (e_12 = void 0, __values(splitByGaps(local, 'v', textHeight * 0.1))), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var row = _e.value;
+                var _loop_3 = function (line) {
+                    var glyphs = splitByGaps(line, 'u', glyphGap * textHeight);
+                    glyphCount += glyphs.length;
+                    // One glyph, or one character read sideways (its stacked parts),
+                    // counts as a word gap.
+                    var band = lineBand(line);
+                    if (glyphs.length < 2 ||
+                        band.maxU - band.minU < (band.maxV - band.minV) * MIN_LINE_ASPECT) {
+                        gaps += wordGap * textHeight;
+                        count++;
+                        return "continue";
+                    }
+                    var reach = -Infinity;
+                    glyphs.forEach(function (glyph, i) {
+                        var minU = Math.min.apply(Math, __spreadArray([], __read(glyph.map(function (item) { return item.minU; })), false));
+                        if (i > 0) {
+                            gaps += minU - reach;
+                            count++;
+                        }
+                        reach = Math.max.apply(Math, __spreadArray([], __read(glyph.map(function (item) { return item.maxU; })), false));
+                    });
+                };
+                try {
+                    for (var _f = (e_13 = void 0, __values(splitByGaps(row, 'u', wordGap * textHeight))), _g = _f.next(); !_g.done; _g = _f.next()) {
+                        var line = _g.value;
+                        _loop_3(line);
+                    }
+                }
+                catch (e_13_1) { e_13 = { error: e_13_1 }; }
+                finally {
+                    try {
+                        if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
+                    }
+                    finally { if (e_13) throw e_13.error; }
+                }
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+        var score = count > 0 ? gaps / count : Infinity;
+        scores.push(score);
+        var axis = Math.abs(Math.sin(2 * angle)) < 1e-9;
+        if (score < bestScore * (1 - (axis ? ANGLE_TIE : TILT_MARGIN))) {
+            best = angle;
+            bestScore = score;
+            bestGlyphs = glyphCount;
+        }
+    };
+    try {
+        for (var candidates_1 = __values(candidates), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+            var angle = candidates_1_1.value;
+            _loop_2(angle);
+        }
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (candidates_1_1 && !candidates_1_1.done && (_a = candidates_1.return)) _a.call(candidates_1);
+        }
+        finally { if (e_11) throw e_11.error; }
+    }
+    var runnerUp = Math.min.apply(Math, __spreadArray(__spreadArray([], __read(scores.filter(function (_, i) { return candidates[i] !== best; })), false), [Infinity], false));
+    return {
+        angle: normalizeTextAngle(best),
+        // Two glyphs cannot tell a line from a column.
+        clear: bestGlyphs >= 3 && bestScore <= runnerUp * (1 - ANGLE_CLEAR)
+    };
+}
+/** Andrew's monotone chain convex hull (counterclockwise). */
+function convexHull(points) {
+    var e_14, _a;
+    var pts = __spreadArray([], __read(points), false).sort(function (a, b) { return a.x - b.x || a.y - b.y; });
+    if (pts.length < 3)
+        return pts;
+    var cross = function (o, a, b) {
+        return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+    };
+    var lower = [];
+    try {
+        for (var pts_1 = __values(pts), pts_1_1 = pts_1.next(); !pts_1_1.done; pts_1_1 = pts_1.next()) {
+            var p = pts_1_1.value;
+            while (lower.length >= 2 &&
+                cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
+                lower.pop();
+            }
+            lower.push(p);
+        }
+    }
+    catch (e_14_1) { e_14 = { error: e_14_1 }; }
+    finally {
+        try {
+            if (pts_1_1 && !pts_1_1.done && (_a = pts_1.return)) _a.call(pts_1);
+        }
+        finally { if (e_14) throw e_14.error; }
+    }
+    var upper = [];
+    for (var i = pts.length - 1; i >= 0; i--) {
+        var p = pts[i];
+        while (upper.length >= 2 &&
+            cross(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+            upper.pop();
+        }
+        upper.push(p);
+    }
+    lower.pop();
+    upper.pop();
+    return lower.concat(upper);
+}
+/** Folds an angle into `(-π/2, π/2]` and snaps near-orthogonal angles. */
+function normalizeTextAngle(angle) {
+    var a = angle;
+    while (a <= -Math.PI / 2)
+        a += Math.PI;
+    while (a > Math.PI / 2)
+        a -= Math.PI;
+    var snapped = Math.round(a / (Math.PI / 2)) * (Math.PI / 2);
+    if (Math.abs(a - snapped) < (2 * Math.PI) / 180)
+        a = snapped;
+    if (a <= -Math.PI / 2 + 1e-12)
+        a += Math.PI;
+    return a;
+}
+function toLocal(p, angle) {
+    var c = Math.cos(angle);
+    var s = Math.sin(angle);
+    return { u: p.x * c + p.y * s, v: -p.x * s + p.y * c };
+}
+function toWorld(u, v, angle) {
+    var c = Math.cos(angle);
+    var s = Math.sin(angle);
+    return { x: u * c - v * s, y: u * s + v * c };
+}
+function localStrokes(strokes, angle) {
+    return strokes.map(function (stroke) {
+        var e_15, _a;
+        var minU = Infinity;
+        var maxU = -Infinity;
+        var minV = Infinity;
+        var maxV = -Infinity;
+        try {
+            for (var _b = __values(stroke.points), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var p = _c.value;
+                var _d = toLocal(p, angle), u = _d.u, v = _d.v;
+                minU = Math.min(minU, u);
+                maxU = Math.max(maxU, u);
+                minV = Math.min(minV, v);
+                maxV = Math.max(maxV, v);
+            }
+        }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
+        return { stroke: stroke, minU: minU, maxU: maxU, minV: minV, maxV: maxV };
+    });
+}
+/** Splits strokes into groups separated by gaps along one local axis. */
+function splitByGaps(items, axis, gap) {
+    var e_16, _a;
+    var lo = axis === 'u' ? 'minU' : 'minV';
+    var hi = axis === 'u' ? 'maxU' : 'maxV';
+    var sorted = __spreadArray([], __read(items), false).sort(function (a, b) { return a[lo] - b[lo]; });
+    var groups = [];
+    var current = [];
+    var reach = -Infinity;
+    try {
+        for (var sorted_1 = __values(sorted), sorted_1_1 = sorted_1.next(); !sorted_1_1.done; sorted_1_1 = sorted_1.next()) {
+            var item = sorted_1_1.value;
+            if (current.length > 0 && item[lo] - reach > gap) {
+                groups.push(current);
+                current = [];
+                reach = -Infinity;
+            }
+            current.push(item);
+            reach = Math.max(reach, item[hi]);
+        }
+    }
+    catch (e_16_1) { e_16 = { error: e_16_1 }; }
+    finally {
+        try {
+            if (sorted_1_1 && !sorted_1_1.done && (_a = sorted_1.return)) _a.call(sorted_1);
+        }
+        finally { if (e_16) throw e_16.error; }
+    }
+    if (current.length > 0)
+        groups.push(current);
+    return groups;
+}
+function median(values) {
+    var sorted = __spreadArray([], __read(values), false).sort(function (a, b) { return a - b; });
+    return percentile(sorted, 0.5);
+}
+function lineBand(items) {
+    return {
+        minU: Math.min.apply(Math, __spreadArray([], __read(items.map(function (item) { return item.minU; })), false)),
+        maxU: Math.max.apply(Math, __spreadArray([], __read(items.map(function (item) { return item.maxU; })), false)),
+        minV: Math.min.apply(Math, __spreadArray([], __read(items.map(function (item) { return item.minV; })), false)),
+        maxV: Math.max.apply(Math, __spreadArray([], __read(items.map(function (item) { return item.maxV; })), false))
+    };
+}
+/**
+ * Whether a stroke fits a text line: inside its band (with a quarter-height
+ * margin) and no larger than about the line height.
+ */
+function fitsBand(item, band) {
+    var height = band.maxV - band.minV;
+    var margin = height * 0.25;
+    var size = Math.max(item.maxU - item.minU, item.maxV - item.minV);
+    return (size <= height * 1.5 &&
+        item.minU >= band.minU - margin &&
+        item.maxU <= band.maxU + margin &&
+        item.minV >= band.minV - margin &&
+        item.maxV <= band.maxV + margin);
+}
+/**
+ * Whether a rejected stroke can join a text line taller than the estimated
+ * height: across the baseline inside its band (quarter-height margin), along
+ * it within a word gap, and no larger than about the line height.
+ *
+ * @param size - Size to check: the full straight line a segment belongs to,
+ * so pieces of grid lines next to text are not attached.
+ */
+function joinsBand(item, band, size, wordGap) {
+    var height = band.maxV - band.minV;
+    var margin = height * 0.25;
+    var gap = height * wordGap;
+    return (size <= height * 1.5 &&
+        item.maxU >= band.minU - gap &&
+        item.minU <= band.maxU + gap &&
+        item.minV >= band.minV - margin &&
+        item.maxV <= band.maxV + margin);
+}
+function extendBand(band, item) {
+    band.minU = Math.min(band.minU, item.minU);
+    band.maxU = Math.max(band.maxU, item.maxU);
+    band.minV = Math.min(band.minV, item.minV);
+    band.maxV = Math.max(band.maxV, item.maxV);
+}
+/**
+ * Merges rows lying inside the band of a taller row into it: pieces of a
+ * large glyph that were split off where a long stroke, rejected at first,
+ * joined them to the rest.
+ */
+function mergeFragments(rows) {
+    var height = function (row) {
+        var band = lineBand(row.items);
+        return band.maxV - band.minV;
+    };
+    var order = __spreadArray([], __read(rows), false).sort(function (a, b) { return height(a) - height(b); });
+    var removed = new Set();
+    order.forEach(function (row, i) {
+        var _a;
+        var strokes = row.items.map(function (item) { return item.stroke; });
+        for (var j = order.length - 1; j > i; j--) {
+            var target = order[j];
+            if (!(height(target) > height(row)))
+                continue;
+            var local = localStrokes(strokes, target.angle);
+            if (!fitsBand(lineBand(local), lineBand(target.items)))
+                continue;
+            (_a = target.items).push.apply(_a, __spreadArray([], __read(local), false));
+            removed.add(row);
+            return;
+        }
+    });
+    return rows.filter(function (row) { return !removed.has(row); });
+}
+function buildLine(items, angle, textHeight, glyphGap) {
+    var glyphs = splitByGaps(items, 'u', glyphGap * textHeight).map(function (group) { return ({
+        strokes: group.map(function (item) { return item.stroke; }),
+        minU: Math.min.apply(Math, __spreadArray([], __read(group.map(function (item) { return item.minU; })), false)),
+        maxU: Math.max.apply(Math, __spreadArray([], __read(group.map(function (item) { return item.maxU; })), false)),
+        minV: Math.min.apply(Math, __spreadArray([], __read(group.map(function (item) { return item.minV; })), false)),
+        maxV: Math.max.apply(Math, __spreadArray([], __read(group.map(function (item) { return item.maxV; })), false))
+    }); });
+    // Descenders (g, p, y) hang below the baseline: most glyphs sit on it.
+    var baseline = median(glyphs.map(function (glyph) { return glyph.minV; }));
+    var tops = glyphs.map(function (glyph) { return glyph.maxV; }).sort(function (a, b) { return a - b; });
+    var top = percentile(tops, 0.9);
+    var minU = Math.min.apply(Math, __spreadArray([], __read(glyphs.map(function (glyph) { return glyph.minU; })), false));
+    var maxU = Math.max.apply(Math, __spreadArray([], __read(glyphs.map(function (glyph) { return glyph.maxU; })), false));
+    return {
+        strokes: items.map(function (item) { return item.stroke; }),
+        glyphs: glyphs,
+        rotation: angle,
+        position: toWorld(minU, baseline, angle),
+        height: Math.max(top - baseline, 1e-9),
+        width: maxU - minU
+    };
+}
+/**
+ * Clusters strokes into text line candidates.
+ *
+ * 1. Strokes much larger than text are rejected.
+ * 2. Strokes closer than `wordGap · height` join into phrases.
+ * 3. Each phrase gets a baseline direction (minimum-height bounding box,
+ *    or the dominant direction when the phrase is a single glyph).
+ * 4. Each phrase is split into rows at gaps across the baseline, and rows
+ *    into lines at gaps along it wider than `wordGap · height`.
+ *
+ * @param strokes - Candidate strokes in world coordinates.
+ * @param options - Height hint and gap factors.
+ */
+export function clusterPdfTextStrokes(strokes, options) {
+    var _a, _b, _c;
+    if (options === void 0) { options = {}; }
+    var usable = strokes.filter(function (stroke) { return stroke.points.length > 0; });
+    var textHeight = (_a = options.textHeight) !== null && _a !== void 0 ? _a : estimatePdfTextHeight(usable);
+    var wordGap = (_b = options.wordGap) !== null && _b !== void 0 ? _b : 1.2;
+    var glyphGap = (_c = options.glyphGap) !== null && _c !== void 0 ? _c : 0.04;
+    if (!(textHeight > 0)) {
+        return { lines: [], rejected: usable, textHeight: 0 };
+    }
+    // Straight lines split into short segments (table grids, frames) are
+    // judged by their full length; long strokes of a taller title rejected
+    // here are attached back to their line below.
+    var runSizes = straightRunSizes(usable, textHeight * 0.01);
+    var accepted = [];
+    var rejected = [];
+    var rejectedSize = new Map();
+    usable.forEach(function (stroke, i) {
+        var size = Math.max(boxSize(strokeBox(stroke)), runSizes[i]);
+        if (size > textHeight * 1.5) {
+            rejected.push(stroke);
+            rejectedSize.set(stroke, size);
+        }
+        else {
+            accepted.push(stroke);
+        }
+    });
+    // Phrases: strokes within a word gap. Lines of a paragraph may join into
+    // one phrase; they are split into rows below once the direction is known.
+    var boxes = accepted.map(strokeBox);
+    var phrases = clusterBoxes(boxes, wordGap * textHeight).map(function (group) {
+        return group.map(function (i) { return accepted[i]; });
+    });
+    // Direction per phrase: the candidate with the tightest glyph spacing.
+    // Phrases too small or too ambiguous to tell (one glyph, `Q1`, or a title
+    // whose long strokes are attached only later) borrow the dominant
+    // direction of the clear ones.
+    var judged = phrases.map(function (phrase) {
+        return boxSize(strokeBox({ id: 0, points: phrase.flatMap(function (s) { return s.points; }) })) <
+            textHeight * 2
+            ? undefined
+            : bestPhraseAngle(phrase, textHeight, wordGap, glyphGap);
+    });
+    var known = judged.flatMap(function (result) { return ((result === null || result === void 0 ? void 0 : result.clear) ? [result.angle] : []); });
+    var dominant = known.length > 0 ? median(known) : undefined;
+    var angles = phrases.map(function (phrase, i) {
+        var _a;
+        var result = judged[i];
+        if (result === null || result === void 0 ? void 0 : result.clear)
+            return result.angle;
+        return ((_a = dominant !== null && dominant !== void 0 ? dominant : result === null || result === void 0 ? void 0 : result.angle) !== null && _a !== void 0 ? _a : principalAngle(phrase.flatMap(function (stroke) { return stroke.points; })));
+    });
+    var merged = [];
+    phrases.forEach(function (phrase, i) {
+        var e_17, _a, e_18, _b;
+        var _c;
+        var angle = (_c = angles[i]) !== null && _c !== void 0 ? _c : 0;
+        var local = localStrokes(phrase, angle);
+        try {
+            // Rows: gaps across the baseline. Lines: word gaps along it.
+            for (var _d = __values(splitByGaps(local, 'v', textHeight * 0.1)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var row = _e.value;
+                try {
+                    for (var _f = (e_18 = void 0, __values(splitByGaps(row, 'u', wordGap * textHeight))), _g = _f.next(); !_g.done; _g = _f.next()) {
+                        var line = _g.value;
+                        merged.push({ angle: angle, items: line });
+                    }
+                }
+                catch (e_18_1) { e_18 = { error: e_18_1 }; }
+                finally {
+                    try {
+                        if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                    }
+                    finally { if (e_18) throw e_18.error; }
+                }
+            }
+        }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
+    });
+    // Strokes too long for the estimated height may belong to taller text (a
+    // title above body text): attach those lying in the band of such a line.
+    // Bands grow as strokes join, so repeat until nothing changes.
+    var bands = merged.map(function (row) { return lineBand(row.items); });
+    var stillRejected = rejected;
+    var _loop_4 = function (changed) {
+        changed = false;
+        stillRejected = stillRejected.filter(function (stroke) {
+            var _a;
+            var size = (_a = rejectedSize.get(stroke)) !== null && _a !== void 0 ? _a : 0;
+            for (var i = 0; i < merged.length; i++) {
+                var item = localStrokes([stroke], merged[i].angle)[0];
+                if (!joinsBand(item, bands[i], size, wordGap))
+                    continue;
+                merged[i].items.push(item);
+                extendBand(bands[i], item);
+                changed = true;
+                return false;
+            }
+            return true;
+        });
+        out_changed_1 = changed;
+    };
+    var out_changed_1;
+    for (var changed = true; changed && stillRejected.length > 0;) {
+        _loop_4(changed);
+        changed = out_changed_1;
+    }
+    var rows = mergeFragments(merged);
+    var lines = rows.map(function (row) {
+        return buildLine(row.items, row.angle, textHeight, glyphGap);
+    });
+    // Reading order: top to bottom, then left to right.
+    lines.sort(function (a, b) {
+        var dy = b.position.y - a.position.y;
+        if (Math.abs(dy) > Math.min(a.height, b.height) * 0.5)
+            return dy;
+        return a.position.x - b.position.x;
+    });
+    return { lines: lines, rejected: stillRejected, textHeight: textHeight };
+}
+//# sourceMappingURL=pdfGlyphClustering.js.map