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

package/lib/recognition/pdfDimensionPattern.js

@@ -0,0 +1,1023 @@
+/**
+ * Recognizes exploded dimensions (arrowheads or ticks, dimension line,
+ * extension lines and text) in imported PDF geometry.
+ *
+ * Pure geometry: callers describe lines, closed polylines, circles and texts
+ * with plain data, so the recognizer is unit-testable without the data model.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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));
+};
+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.");
+};
+import { cross, dist, dot, sub } from './pdfRecGeometry';
+function unit(v) {
+    var len = Math.hypot(v.x, v.y);
+    return len > 0 ? { x: v.x / len, y: v.y / len } : { x: 0, y: 0 };
+}
+function lerp(a, b, t) {
+    return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+}
+function median(values) {
+    if (values.length === 0)
+        return 0;
+    var sorted = __spreadArray([], __read(values), false).sort(function (a, b) { return a - b; });
+    return sorted[Math.floor(sorted.length / 2)];
+}
+/**
+ * Reads an arrowhead from a closed triangle: the sharpest corner is the tip,
+ * the others form the base. Rejects shapes that are not slender triangles.
+ */
+export function pdfArrowFromPolygon(vertices) {
+    var pts = __spreadArray([], __read(vertices), false);
+    if (pts.length === 4 && dist(pts[0], pts[3]) < 1e-9)
+        pts.pop();
+    if (pts.length !== 3)
+        return undefined;
+    var angleAt = function (i) {
+        var a = sub(pts[(i + 1) % 3], pts[i]);
+        var b = sub(pts[(i + 2) % 3], pts[i]);
+        return Math.atan2(Math.abs(cross(a, b)), dot(a, b));
+    };
+    var angles = [0, 1, 2].map(angleAt);
+    var tipIndex = angles.indexOf(Math.min.apply(Math, __spreadArray([], __read(angles), false)));
+    // Dimension arrows are slender: tip angle typically 15°–40°.
+    if (angles[tipIndex] > (50 * Math.PI) / 180)
+        return undefined;
+    var tip = pts[tipIndex];
+    var baseMid = lerp(pts[(tipIndex + 1) % 3], pts[(tipIndex + 2) % 3], 0.5);
+    var size = dist(tip, baseMid);
+    if (!(size > 0))
+        return undefined;
+    return { tip: tip, direction: unit(sub(tip, baseMid)), size: size };
+}
+/** First number in a dimension text, e.g. `Ø25` → 25, `1,200` → 1200. */
+export function parsePdfDimensionValue(text) {
+    var match = /\d+(?:[.,]\d+)*/.exec(text.replace(/\s+/g, ''));
+    if (!match)
+        return undefined;
+    var raw = match[0];
+    if (/^\d{1,3}(,\d{3})+$/.test(raw))
+        raw = raw.replace(/,/g, '');
+    else
+        raw = raw.replace(',', '.');
+    var value = Number.parseFloat(raw);
+    return Number.isFinite(value) ? value : undefined;
+}
+/** Classifies a dimension text prefix. */
+function radialKind(text) {
+    var t = text.trim();
+    if (/^(Ø|⌀|ø|%%c|%%C|\\U\+2205)/.test(t))
+        return 'diameter';
+    if (/^R\s*\d/i.test(t))
+        return 'radius';
+    return undefined;
+}
+/**
+ * Finds linear, radius and diameter dimensions.
+ *
+ * Linear: two terminators whose tips share their axis (arrows pointing
+ * apart, or together for small dimensions), a value text beside them, and
+ * optional extension lines through each tip. Pairs are taken shortest
+ * first so chained dimensions sharing extension lines stay separate.
+ *
+ * Radial: an arrow whose tip lies on a circle and points along its radius,
+ * with an `R…` or `Ø…` text nearby.
+ *
+ * @param input - Candidate shapes.
+ * @param options - Tolerances.
+ */
+export function recognizePdfDimensions(input, options) {
+    var e_1, _a, e_2, _b, e_3, _c, e_4, _d, e_5, _e, e_6, _f;
+    var _g, _h, _j;
+    if (options === void 0) { options = {}; }
+    var arrows = [];
+    try {
+        for (var _k = __values(input.polygons), _l = _k.next(); !_l.done; _l = _k.next()) {
+            var polygon = _l.value;
+            var arrow = pdfArrowFromPolygon(polygon.vertices);
+            if (arrow)
+                arrows.push(__assign({ ids: [polygon.id] }, arrow));
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_l && !_l.done && (_a = _k.return)) _a.call(_k);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var textHeights = input.texts.map(function (t) { return t.height; }).filter(function (h) { return h > 0; });
+    var refSize = median(arrows.map(function (a) { return a.size; })) || median(textHeights) || 1;
+    var tol = (_g = options.tolerance) !== null && _g !== void 0 ? _g : Math.max(refSize * 0.02, 1e-6);
+    var angleTol = (_h = options.angleTolerance) !== null && _h !== void 0 ? _h : (3 * Math.PI) / 180;
+    var sinTol = Math.sin(angleTol);
+    var usedSegments = new Set();
+    var usedTexts = new Set();
+    var usedArrows = new Set();
+    // Chained dimensions share extension lines, so those may be referenced
+    // again (they are consumed only once).
+    var extensionIds = new Set();
+    var results = [];
+    // Angular dimensions first: an arc with an arrow at each end, pointing
+    // along the arc, and a value text near its middle.
+    var tangentTol = Math.sin((10 * Math.PI) / 180);
+    var _loop_1 = function (arc) {
+        var e_7, _s, e_8, _t;
+        if (usedSegments.has(arc.id))
+            return "continue";
+        var at = function (angle) { return ({
+            x: arc.center.x + arc.radius * Math.cos(angle),
+            y: arc.center.y + arc.radius * Math.sin(angle)
+        }); };
+        var sweep = arc.endAngle - arc.startAngle;
+        if (sweep <= 0)
+            sweep += Math.PI * 2;
+        var ends = [at(arc.startAngle), at(arc.startAngle + sweep)];
+        var endArrows = ends.map(function (end) {
+            return arrows.find(function (a) {
+                if (usedArrows.has(a) || dist(a.tip, end) > tol * 4)
+                    return false;
+                var radial = unit(sub(end, arc.center));
+                return Math.abs(dot(a.direction, radial)) <= tangentTol;
+            });
+        });
+        if (!endArrows[0] || !endArrows[1] || endArrows[0] === endArrows[1]) {
+            return "continue";
+        }
+        var arcPoint = at(arc.startAngle + sweep / 2);
+        var text = nearestText(input.texts, usedTexts, arcPoint, Math.max(arc.radius * 0.8, refSize * 6), function (t) { return parsePdfDimensionValue(t.text) !== undefined; });
+        if (!text)
+            return "continue";
+        var consumed = __spreadArray(__spreadArray(__spreadArray([
+            arc.id
+        ], __read(endArrows[0].ids), false), __read(endArrows[1].ids), false), __read(pdfDimTextIds(text)), false);
+        // Radial extension lines through each end; the end nearer the center
+        // is the object side.
+        var leg = function (end) {
+            var e_9, _a;
+            var radial = unit(sub(end, arc.center));
+            try {
+                for (var _b = (e_9 = void 0, __values(input.segments)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var s = _c.value;
+                    if (usedSegments.has(s.id) || consumed.includes(s.id))
+                        continue;
+                    var su = unit(sub(s.p1, s.p0));
+                    if (Math.abs(cross(su, radial)) > sinTol)
+                        continue;
+                    if (Math.abs(cross(radial, sub(s.p0, arc.center))) > tol * 2)
+                        continue;
+                    if (!pointNearSegment(end, s, refSize * 2))
+                        continue;
+                    consumed.push(s.id);
+                    return dist(s.p0, arc.center) <= dist(s.p1, arc.center) ? s.p0 : s.p1;
+                }
+            }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_9) throw e_9.error; }
+            }
+            return end;
+        };
+        var xLine1 = leg(ends[0]);
+        var xLine2 = leg(ends[1]);
+        usedArrows.add(endArrows[0]);
+        usedArrows.add(endArrows[1]);
+        try {
+            for (var _u = (e_7 = void 0, __values(pdfDimTextIds(text))), _v = _u.next(); !_v.done; _v = _u.next()) {
+                var id = _v.value;
+                usedTexts.add(id);
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_v && !_v.done && (_s = _u.return)) _s.call(_u);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        try {
+            for (var consumed_1 = (e_8 = void 0, __values(consumed)), consumed_1_1 = consumed_1.next(); !consumed_1_1.done; consumed_1_1 = consumed_1.next()) {
+                var id = consumed_1_1.value;
+                usedSegments.add(id);
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (consumed_1_1 && !consumed_1_1.done && (_t = consumed_1.return)) _t.call(consumed_1);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        results.push({
+            kind: 'angular',
+            center: arc.center,
+            xLine1: xLine1,
+            xLine2: xLine2,
+            arcPoint: arcPoint,
+            measured: (sweep * 180) / Math.PI,
+            text: text,
+            arrowSize: endArrows[0].size,
+            consumed: consumed
+        });
+    };
+    try {
+        for (var _m = __values((_j = input.arcs) !== null && _j !== void 0 ? _j : []), _o = _m.next(); !_o.done; _o = _m.next()) {
+            var arc = _o.value;
+            _loop_1(arc);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_o && !_o.done && (_b = _m.return)) _b.call(_m);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    var _loop_2 = function (arrow) {
+        var e_10, _w, e_11, _x, e_12, _y;
+        try {
+            for (var _z = (e_10 = void 0, __values(input.curves)), _0 = _z.next(); !_0.done; _0 = _z.next()) {
+                var curve = _0.value;
+                var radial = sub(arrow.tip, curve.center);
+                var r = Math.hypot(radial.x, radial.y);
+                if (Math.abs(r - curve.radius) > tol * 2 || r === 0)
+                    continue;
+                if (Math.abs(cross(arrow.direction, unit(radial))) > sinTol)
+                    continue;
+                var text = nearestText(input.texts, usedTexts, arrow.tip, refSize * 12, function (t) { return radialKind(t.text) !== undefined; });
+                if (!text)
+                    continue;
+                var kind = radialKind(text.text);
+                var leaders = input.segments.filter(function (s) {
+                    return !usedSegments.has(s.id) &&
+                        (dist(s.p0, arrow.tip) <= tol * 2 ||
+                            dist(s.p1, arrow.tip) <= tol * 2 ||
+                            pointNearSegment(arrow.tip, s, tol * 2));
+                });
+                try {
+                    for (var leaders_1 = (e_11 = void 0, __values(leaders)), leaders_1_1 = leaders_1.next(); !leaders_1_1.done; leaders_1_1 = leaders_1.next()) {
+                        var s = leaders_1_1.value;
+                        usedSegments.add(s.id);
+                    }
+                }
+                catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                finally {
+                    try {
+                        if (leaders_1_1 && !leaders_1_1.done && (_x = leaders_1.return)) _x.call(leaders_1);
+                    }
+                    finally { if (e_11) throw e_11.error; }
+                }
+                try {
+                    for (var _1 = (e_12 = void 0, __values(pdfDimTextIds(text))), _2 = _1.next(); !_2.done; _2 = _1.next()) {
+                        var id = _2.value;
+                        usedTexts.add(id);
+                    }
+                }
+                catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                finally {
+                    try {
+                        if (_2 && !_2.done && (_y = _1.return)) _y.call(_1);
+                    }
+                    finally { if (e_12) throw e_12.error; }
+                }
+                usedArrows.add(arrow);
+                results.push({
+                    kind: kind,
+                    center: curve.center,
+                    chordPoint: arrow.tip,
+                    radius: curve.radius,
+                    leaderLength: dist(arrow.tip, text.center),
+                    measured: kind === 'diameter' ? curve.radius * 2 : curve.radius,
+                    text: text,
+                    arrowSize: arrow.size,
+                    consumed: __spreadArray(__spreadArray(__spreadArray([], __read(arrow.ids), false), __read(leaders.map(function (s) { return s.id; })), false), __read(pdfDimTextIds(text)), false)
+                });
+                break;
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_0 && !_0.done && (_w = _z.return)) _w.call(_z);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+    };
+    try {
+        // Radial dimensions next: their arrows must not pair up as linear ones.
+        for (var arrows_1 = __values(arrows), arrows_1_1 = arrows_1.next(); !arrows_1_1.done; arrows_1_1 = arrows_1.next()) {
+            var arrow = arrows_1_1.value;
+            _loop_2(arrow);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (arrows_1_1 && !arrows_1_1.done && (_c = arrows_1.return)) _c.call(arrows_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    // Ticks: short oblique lines centered near the ends of a longer line.
+    var ticks = [];
+    var shortLimit = Math.max(median(textHeights), refSize) * 1.5;
+    var shorts = input.segments.filter(function (s) { return dist(s.p0, s.p1) <= shortLimit; });
+    try {
+        for (var _p = __values(input.segments), _q = _p.next(); !_q.done; _q = _p.next()) {
+            var line = _q.value;
+            var length_1 = dist(line.p0, line.p1);
+            if (length_1 <= shortLimit)
+                continue;
+            var u = unit(sub(line.p1, line.p0));
+            try {
+                for (var shorts_1 = (e_5 = void 0, __values(shorts)), shorts_1_1 = shorts_1.next(); !shorts_1_1.done; shorts_1_1 = shorts_1.next()) {
+                    var tick = shorts_1_1.value;
+                    var mid = lerp(tick.p0, tick.p1, 0.5);
+                    if (Math.abs(cross(u, sub(mid, line.p0))) > tol * 2)
+                        continue;
+                    var along = dot(sub(mid, line.p0), u);
+                    var nearEnd = Math.min(Math.abs(along), Math.abs(along - length_1));
+                    if (nearEnd > shortLimit)
+                        continue;
+                    var tu = unit(sub(tick.p1, tick.p0));
+                    var angle = Math.acos(Math.min(1, Math.abs(dot(tu, u))));
+                    if (angle < Math.PI / 6 || angle > Math.PI / 3)
+                        continue;
+                    ticks.push({
+                        ids: [tick.id],
+                        tip: mid,
+                        size: dist(tick.p0, tick.p1) / 2,
+                        line: line
+                    });
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (shorts_1_1 && !shorts_1_1.done && (_e = shorts_1.return)) _e.call(shorts_1);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_q && !_q.done && (_d = _p.return)) _d.call(_p);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    var pairs = [];
+    var free = arrows.filter(function (a) { return !usedArrows.has(a); });
+    for (var i = 0; i < free.length; i++) {
+        for (var j = i + 1; j < free.length; j++) {
+            var a = free[i];
+            var b = free[j];
+            if (Math.max(a.size, b.size) > Math.min(a.size, b.size) * 1.5)
+                continue;
+            var d = sub(b.tip, a.tip);
+            var length_2 = Math.hypot(d.x, d.y);
+            if (length_2 <= tol * 4)
+                continue;
+            var u = unit(d);
+            if (Math.abs(cross(a.direction, u)) > sinTol)
+                continue;
+            if (Math.abs(cross(b.direction, u)) > sinTol)
+                continue;
+            // Pointing apart (inside arrows) or toward each other (outside arrows).
+            if (dot(a.direction, u) * dot(b.direction, u) >= 0)
+                continue;
+            pairs.push({ a: a, b: b, length: length_2 });
+        }
+    }
+    // Tick pairs share one dimension line.
+    for (var i = 0; i < ticks.length; i++) {
+        for (var j = i + 1; j < ticks.length; j++) {
+            if (ticks[i].line !== ticks[j].line)
+                continue;
+            var length_3 = dist(ticks[i].tip, ticks[j].tip);
+            if (length_3 <= tol * 4)
+                continue;
+            pairs.push({ a: ticks[i], b: ticks[j], length: length_3 });
+        }
+    }
+    pairs.sort(function (p, q) { return p.length - q.length; });
+    var _loop_3 = function (a, b, length_4) {
+        var e_13, _3, e_14, _4, e_15, _5;
+        if (usedArrows.has(a) || usedArrows.has(b))
+            return "continue";
+        if (a.ids.some(function (id) { return usedSegments.has(id); }) ||
+            b.ids.some(function (id) { return usedSegments.has(id); })) {
+            return "continue";
+        }
+        var u = unit(sub(b.tip, a.tip));
+        var n = { x: -u.y, y: u.x };
+        var mid = lerp(a.tip, b.tip, 0.5);
+        var acceptLinearText = function (t) {
+            if (t.text !== undefined &&
+                parsePdfDimensionValue(t.text) === undefined) {
+                return false;
+            }
+            var rel = sub(t.center, a.tip);
+            var along = dot(rel, u);
+            var across = Math.abs(dot(rel, n));
+            return (across <= t.height * 2.5 &&
+                along >= -length_4 * 0.5 - t.height * 4 &&
+                along <= length_4 * 1.5 + t.height * 4);
+        };
+        var text = nearestText(input.texts, usedTexts, mid, Math.max(length_4 * 0.75, refSize * 6), function (t) { return acceptLinearText(t); });
+        if (!text) {
+            text = claimUnreadText(input.unreadTexts, usedTexts, mid, Math.max(length_4 * 0.75, refSize * 6), length_4, function (t) { return acceptLinearText(t); });
+        }
+        if (!text)
+            return "continue";
+        text = reconcileLinearDimText(text, length_4);
+        // Inside arrows point apart (away from the span centre); outside arrows
+        // point toward each other.
+        var arrowsOut = a.direction !== undefined && dot(a.direction, u) > 0;
+        var consumed = __spreadArray(__spreadArray(__spreadArray([], __read(a.ids), false), __read(b.ids), false), __read(pdfDimTextIds(text)), false);
+        try {
+            // Dimension line pieces: collinear segments overlapping the span.
+            for (var _6 = (e_13 = void 0, __values(input.segments)), _7 = _6.next(); !_7.done; _7 = _6.next()) {
+                var s = _7.value;
+                if (usedSegments.has(s.id) || consumed.includes(s.id))
+                    continue;
+                var r0 = sub(s.p0, a.tip);
+                var r1 = sub(s.p1, a.tip);
+                if (Math.abs(dot(r0, n)) > tol * 2 || Math.abs(dot(r1, n)) > tol * 2)
+                    continue;
+                var lo = Math.min(dot(r0, u), dot(r1, u));
+                var hi = Math.max(dot(r0, u), dot(r1, u));
+                // Overlap the span, or sit entirely in the arrow tails (outside
+                // arrows); merely touching a tip is a neighbouring dimension.
+                var overlap = Math.min(hi, length_4) - Math.max(lo, 0);
+                var inTails = lo >= -refSize * 4 && hi <= length_4 + refSize * 4;
+                if (overlap <= tol * 4 && !inTails)
+                    continue;
+                consumed.push(s.id);
+            }
+        }
+        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+        finally {
+            try {
+                if (_7 && !_7.done && (_3 = _6.return)) _3.call(_6);
+            }
+            finally { if (e_13) throw e_13.error; }
+        }
+        // Extension lines: perpendicular segments through each tip.
+        // Rank 0: tip-near stubs with real object reach (full PDF extension length).
+        // Rank 1: mid-crossing edges — keep the text-side endpoint (object side).
+        // Rank 2: tiny tip-only stubs (DIMEXE overhang) — last resort only.
+        // Never let a 1-unit beyond stub beat a 40-unit object-side edge.
+        var beyond = 0;
+        var maxTipGap = Math.max(refSize * 2, a.size * 2, text.height * 1.5);
+        var minReach = Math.max(a.size * 2, text.height, refSize * 2);
+        var textSide = Math.sign((text.center.x - mid.x) * n.x + (text.center.y - mid.y) * n.y) || 1;
+        var extension = function (tip) {
+            var e_16, _a;
+            var best;
+            try {
+                for (var _b = (e_16 = void 0, __values(input.segments)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var s = _c.value;
+                    var shared = extensionIds.has(s.id);
+                    if ((usedSegments.has(s.id) && !shared) || consumed.includes(s.id)) {
+                        continue;
+                    }
+                    var su = unit(sub(s.p1, s.p0));
+                    if (Math.abs(dot(su, u)) > sinTol)
+                        continue;
+                    if (Math.abs(cross(su, sub(tip, s.p0))) > tol * 2)
+                        continue;
+                    var t0 = dot(sub(s.p0, tip), n);
+                    var t1 = dot(sub(s.p1, tip), n);
+                    // The tip must lie on (or just past) the segment.
+                    if (Math.min(t0, t1) > tol * 2 || Math.max(t0, t1) < -tol * 2) {
+                        if (Math.min(Math.abs(t0), Math.abs(t1)) > maxTipGap)
+                            continue;
+                    }
+                    var d0 = Math.abs(t0);
+                    var d1 = Math.abs(t1);
+                    var tipNear0 = d0 <= maxTipGap;
+                    var tipNear1 = d1 <= maxTipGap;
+                    var origin_1 = void 0;
+                    var nearT = void 0;
+                    var farT = void 0;
+                    var proximity = void 0;
+                    var rank = void 0;
+                    if (tipNear0 || tipNear1) {
+                        // Tip near an end → that end is the dim-line foot; other end is origin.
+                        var nearIs0 = tipNear0 && (!tipNear1 || d0 <= d1);
+                        nearT = nearIs0 ? t0 : t1;
+                        farT = nearIs0 ? t1 : t0;
+                        origin_1 = nearIs0 ? s.p1 : s.p0;
+                        proximity = Math.abs(nearT);
+                        // Tiny tip stubs are overhang only; real extensions reach the object.
+                        rank = Math.abs(farT) >= minReach ? 0 : 2;
+                    }
+                    else {
+                        // Mid-segment long edge: keep the text-side endpoint (object side).
+                        var on0 = Math.sign(t0) === textSide;
+                        var on1 = Math.sign(t1) === textSide;
+                        if (!on0 && !on1)
+                            continue;
+                        var use0 = on0 && (!on1 || d0 >= d1);
+                        origin_1 = use0 ? s.p0 : s.p1;
+                        farT = use0 ? t0 : t1;
+                        nearT = use0 ? t1 : t0;
+                        proximity = Math.abs(nearT);
+                        rank = 1;
+                    }
+                    var reach = Math.abs(farT);
+                    if (!(reach > tol))
+                        continue;
+                    var over = Math.sign(nearT) !== Math.sign(farT) && Math.sign(nearT) !== 0
+                        ? Math.min(Math.abs(nearT), maxTipGap)
+                        : 0;
+                    // Prefer better rank, then longer object reach (match PDF length).
+                    if (!best ||
+                        rank < best.rank ||
+                        (rank === best.rank && reach > best.reach + tol) ||
+                        (rank === best.rank &&
+                            Math.abs(reach - best.reach) <= tol &&
+                            proximity < best.proximity)) {
+                        best = { origin: origin_1, id: s.id, beyond: over, proximity: proximity, reach: reach, rank: rank };
+                    }
+                }
+            }
+            catch (e_16_1) { e_16 = { error: e_16_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_16) throw e_16.error; }
+            }
+            if (!best)
+                return tip;
+            if (!extensionIds.has(best.id))
+                consumed.push(best.id);
+            extensionIds.add(best.id);
+            beyond = Math.max(beyond, best.beyond);
+            return best.origin;
+        };
+        var xLine1 = extension(a.tip);
+        var xLine2 = extension(b.tip);
+        usedArrows.add(a);
+        usedArrows.add(b);
+        try {
+            for (var _8 = (e_14 = void 0, __values(pdfDimTextIds(text))), _9 = _8.next(); !_9.done; _9 = _8.next()) {
+                var id = _9.value;
+                usedTexts.add(id);
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (_9 && !_9.done && (_4 = _8.return)) _4.call(_8);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+        try {
+            for (var consumed_2 = (e_15 = void 0, __values(consumed)), consumed_2_1 = consumed_2.next(); !consumed_2_1.done; consumed_2_1 = consumed_2.next()) {
+                var id = consumed_2_1.value;
+                usedSegments.add(id);
+            }
+        }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (consumed_2_1 && !consumed_2_1.done && (_5 = consumed_2.return)) _5.call(consumed_2);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
+        var rotation = Math.atan2(u.y, u.x);
+        if (rotation < 0)
+            rotation += Math.PI;
+        if (rotation >= Math.PI - 1e-12)
+            rotation -= Math.PI;
+        results.push({
+            kind: 'linear',
+            xLine1: xLine1,
+            xLine2: xLine2,
+            dimLinePoint: a.tip,
+            rotation: rotation,
+            measured: length_4,
+            text: text,
+            arrowSize: a.size,
+            extensionBeyond: beyond,
+            ticks: a.direction === undefined,
+            arrowsOut: arrowsOut,
+            consumed: consumed
+        });
+    };
+    try {
+        for (var pairs_1 = __values(pairs), pairs_1_1 = pairs_1.next(); !pairs_1_1.done; pairs_1_1 = pairs_1.next()) {
+            var _r = pairs_1_1.value, a = _r.a, b = _r.b, length_4 = _r.length;
+            _loop_3(a, b, length_4);
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (pairs_1_1 && !pairs_1_1.done && (_f = pairs_1.return)) _f.call(pairs_1);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    results.push.apply(results, __spreadArray([], __read(recognizeBareLinear(input, usedSegments, usedTexts, refSize, tol, sinTol)), false));
+    return results;
+}
+/**
+ * Linear dimensions drawn without arrowheads or ticks: a dimension line
+ * whose two ends lie inside parallel perpendicular extension lines (which
+ * run past it, as DIMEXE does), with a value text beside it. Requiring the
+ * extension lines to continue past the dimension line keeps rectangle
+ * sides, whose corners are segment ends, from matching.
+ */
+function recognizeBareLinear(input, usedSegments, usedTexts, refSize, tol, sinTol) {
+    var e_17, _a;
+    var results = [];
+    var lines = input.segments
+        .map(function (s) { return ({ s: s, length: dist(s.p0, s.p1) }); })
+        .filter(function (_a) {
+        var length = _a.length;
+        return length > tol * 4;
+    })
+        .sort(function (p, q) { return p.length - q.length; });
+    var _loop_4 = function (line, length_5) {
+        var e_18, _c, e_19, _d;
+        if (usedSegments.has(line.id))
+            return "continue";
+        var u = unit(sub(line.p1, line.p0));
+        var n = { x: -u.y, y: u.x };
+        var extensionAt = function (end) {
+            var e_20, _a;
+            try {
+                for (var _b = (e_20 = void 0, __values(input.segments)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var s = _c.value;
+                    if (s === line || usedSegments.has(s.id))
+                        continue;
+                    var su = unit(sub(s.p1, s.p0));
+                    if (Math.abs(dot(su, u)) > sinTol)
+                        continue;
+                    if (Math.abs(cross(su, sub(end, s.p0))) > tol * 2)
+                        continue;
+                    var t0 = dot(sub(s.p0, end), n);
+                    var t1 = dot(sub(s.p1, end), n);
+                    // Both sides of the end must be covered: the extension runs past.
+                    if (Math.min(t0, t1) >= -tol * 2 || Math.max(t0, t1) <= tol * 2) {
+                        continue;
+                    }
+                    var farIsP0 = Math.abs(t0) >= Math.abs(t1);
+                    return {
+                        id: s.id,
+                        origin: farIsP0 ? s.p0 : s.p1,
+                        side: Math.sign(farIsP0 ? t0 : t1),
+                        beyond: Math.abs(farIsP0 ? t1 : t0)
+                    };
+                }
+            }
+            catch (e_20_1) { e_20 = { error: e_20_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_20) throw e_20.error; }
+            }
+            return undefined;
+        };
+        var e1 = extensionAt(line.p0);
+        var e2 = extensionAt(line.p1);
+        if (!e1 || !e2 || e1.id === e2.id)
+            return "continue";
+        var mid = lerp(line.p0, line.p1, 0.5);
+        var acceptBareText = function (t) {
+            if (t.text !== undefined &&
+                parsePdfDimensionValue(t.text) === undefined) {
+                return false;
+            }
+            var rel = sub(t.center, line.p0);
+            var along = dot(rel, u);
+            return (Math.abs(dot(rel, n)) <= t.height * 2.5 &&
+                along >= -t.height * 4 &&
+                along <= length_5 + t.height * 4);
+        };
+        var text = nearestText(input.texts, usedTexts, mid, Math.max(length_5 * 0.75, refSize * 6), function (t) { return acceptBareText(t); });
+        if (!text) {
+            text = claimUnreadText(input.unreadTexts, usedTexts, mid, Math.max(length_5 * 0.75, refSize * 6), length_5, function (t) { return acceptBareText(t); });
+        }
+        if (!text)
+            return "continue";
+        try {
+            for (var _e = (e_18 = void 0, __values(pdfDimTextIds(text))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var id = _f.value;
+                usedTexts.add(id);
+            }
+        }
+        catch (e_18_1) { e_18 = { error: e_18_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_c = _e.return)) _c.call(_e);
+            }
+            finally { if (e_18) throw e_18.error; }
+        }
+        var consumed = __spreadArray([line.id, e1.id, e2.id], __read(pdfDimTextIds(text)), false);
+        try {
+            for (var consumed_3 = (e_19 = void 0, __values(consumed)), consumed_3_1 = consumed_3.next(); !consumed_3_1.done; consumed_3_1 = consumed_3.next()) {
+                var id = consumed_3_1.value;
+                usedSegments.add(id);
+            }
+        }
+        catch (e_19_1) { e_19 = { error: e_19_1 }; }
+        finally {
+            try {
+                if (consumed_3_1 && !consumed_3_1.done && (_d = consumed_3.return)) _d.call(consumed_3);
+            }
+            finally { if (e_19) throw e_19.error; }
+        }
+        var rotation = Math.atan2(u.y, u.x);
+        if (rotation < 0)
+            rotation += Math.PI;
+        if (rotation >= Math.PI - 1e-12)
+            rotation -= Math.PI;
+        // The object lies on the far side of the extension lines; when they
+        // disagree, keep the dimension line ends as origins.
+        var sameSide = e1.side === e2.side;
+        results.push({
+            kind: 'linear',
+            xLine1: sameSide ? e1.origin : line.p0,
+            xLine2: sameSide ? e2.origin : line.p1,
+            dimLinePoint: line.p0,
+            rotation: rotation,
+            measured: length_5,
+            text: reconcileLinearDimText(text, length_5),
+            arrowSize: 0,
+            extensionBeyond: sameSide ? Math.max(e1.beyond, e2.beyond) : 0,
+            ticks: false,
+            arrowsOut: false,
+            consumed: consumed
+        });
+    };
+    try {
+        for (var lines_1 = __values(lines), lines_1_1 = lines_1.next(); !lines_1_1.done; lines_1_1 = lines_1.next()) {
+            var _b = lines_1_1.value, line = _b.s, length_5 = _b.length;
+            _loop_4(line, length_5);
+        }
+    }
+    catch (e_17_1) { e_17 = { error: e_17_1 }; }
+    finally {
+        try {
+            if (lines_1_1 && !lines_1_1.done && (_a = lines_1.return)) _a.call(lines_1);
+        }
+        finally { if (e_17) throw e_17.error; }
+    }
+    return results;
+}
+function pointNearSegment(p, s, tol) {
+    var d = sub(s.p1, s.p0);
+    var len2 = dot(d, d);
+    if (len2 === 0)
+        return dist(p, s.p0) <= tol;
+    var t = Math.max(0, Math.min(1, dot(sub(p, s.p0), d) / len2));
+    return dist(p, lerp(s.p0, s.p1, t)) <= tol;
+}
+function nearestText(texts, used, near, maxDistance, accept) {
+    var e_21, _a;
+    var best;
+    var bestDistance = maxDistance;
+    try {
+        for (var texts_1 = __values(texts), texts_1_1 = texts_1.next(); !texts_1_1.done; texts_1_1 = texts_1.next()) {
+            var text = texts_1_1.value;
+            if (used.has(text.id) || !accept(text))
+                continue;
+            var d = dist(text.center, near);
+            if (d <= bestDistance) {
+                bestDistance = d;
+                best = text;
+            }
+        }
+    }
+    catch (e_21_1) { e_21 = { error: e_21_1 }; }
+    finally {
+        try {
+            if (texts_1_1 && !texts_1_1.done && (_a = texts_1.return)) _a.call(texts_1);
+        }
+        finally { if (e_21) throw e_21.error; }
+    }
+    return best;
+}
+/**
+ * Claims the nearest unread stroke-text cluster and turns it into a
+ * dimension text whose value is the measured length (paper 1:1 fallback
+ * when OCR / the glyph dictionary could not read the strokes).
+ */
+function claimUnreadText(unread, used, near, maxDistance, measured, accept) {
+    var e_22, _a, e_23, _b;
+    if (!unread || unread.length === 0)
+        return undefined;
+    var best;
+    var bestDistance = maxDistance;
+    try {
+        for (var unread_1 = __values(unread), unread_1_1 = unread_1.next(); !unread_1_1.done; unread_1_1 = unread_1.next()) {
+            var text = unread_1_1.value;
+            if (used.has(text.id) || !accept(text))
+                continue;
+            var d = dist(text.center, near);
+            if (d <= bestDistance) {
+                bestDistance = d;
+                best = text;
+            }
+        }
+    }
+    catch (e_22_1) { e_22 = { error: e_22_1 }; }
+    finally {
+        try {
+            if (unread_1_1 && !unread_1_1.done && (_a = unread_1.return)) _a.call(unread_1);
+        }
+        finally { if (e_22) throw e_22.error; }
+    }
+    if (!best)
+        return undefined;
+    used.add(best.id);
+    try {
+        for (var _c = __values(best.extraIds), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var id = _d.value;
+            used.add(id);
+        }
+    }
+    catch (e_23_1) { e_23 = { error: e_23_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+        }
+        finally { if (e_23) throw e_23.error; }
+    }
+    return {
+        id: best.id,
+        text: formatMeasuredLength(measured),
+        center: best.center,
+        height: best.height,
+        extraIds: best.extraIds
+    };
+}
+/** Entity ids that a dimension value text replaces. */
+export function pdfDimTextIds(text) {
+    return text.extraIds && text.extraIds.length > 0
+        ? __spreadArray([text.id], __read(text.extraIds), false) : [text.id];
+}
+/** Compact decimal for a measured length used as a stroke-text fallback. */
+function formatMeasuredLength(length) {
+    if (!Number.isFinite(length) || length <= 0)
+        return '0';
+    var rounded = Math.round(length);
+    if (Math.abs(length - rounded) <= Math.max(length * 1e-6, 1e-6)) {
+        return String(rounded);
+    }
+    var text = length.toFixed(4).replace(/\.?0+$/, '');
+    return text.length > 0 ? text : String(length);
+}
+/**
+ * Keeps a stroke-read value only when it agrees with the measured length or
+ * a clear drawing scale. Over-segmented outline digits often read as "111"
+ * and must not become DIMLFAC = 2.
+ */
+function reconcileLinearDimText(text, measured) {
+    if (!(measured > 0))
+        return text;
+    // Leave annotated values alone (`44mm`, tolerances, …); only rewrite plain
+    // numeric / R / Ø / ° readings that look like a bad stroke OCR.
+    if (!/^[Øø⌀R]?\s*\d+([.,]\d+)?\s*°?$/i.test(text.text.trim()))
+        return text;
+    var value = parsePdfDimensionValue(text.text);
+    var digits = text.text.replace(/\D/g, '');
+    if (value === undefined || (digits.length >= 2 && /^1+$/.test(digits))) {
+        return __assign(__assign({}, text), { text: formatMeasuredLength(measured) });
+    }
+    var ratio = value / measured;
+    if (Math.abs(ratio - 1) <= 0.05)
+        return text;
+    if (isNiceScaleRatio(ratio))
+        return text;
+    return __assign(__assign({}, text), { text: formatMeasuredLength(measured) });
+}
+/** Whether `ratio` is within 1 % of 1, 2, 2.5 or 5 × 10ⁿ. */
+function isNiceScaleRatio(ratio) {
+    var e_24, _a, e_25, _b;
+    if (!(ratio > 0))
+        return false;
+    var exponent = Math.floor(Math.log10(ratio));
+    try {
+        for (var _c = __values([exponent - 1, exponent, exponent + 1]), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var e = _d.value;
+            try {
+                for (var _e = (e_25 = void 0, __values([1, 2, 2.5, 5])), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var m = _f.value;
+                    var nice = m * Math.pow(10, e);
+                    if (Math.abs(nice - ratio) <= ratio * 0.01)
+                        return true;
+                }
+            }
+            catch (e_25_1) { e_25 = { error: e_25_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_25) throw e_25.error; }
+            }
+        }
+    }
+    catch (e_24_1) { e_24 = { error: e_24_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_24) throw e_24.error; }
+    }
+    return false;
+}
+/**
+ * Most common text-value / measured-length ratio, i.e. the drawing scale the
+ * PDF was printed at. Uses linear dimensions when there are any. Returns `undefined` when
+ * no dimension has a numeric text.
+ */
+export function suggestPdfDimensionScale(dimensions) {
+    var e_26, _a;
+    // Linear dimensions are the reliable signal; radial texts are often
+    // annotated independently of the drawing scale.
+    var linear = dimensions.filter(function (d) { return d.kind === 'linear'; });
+    var radial = dimensions.filter(function (d) { return d.kind === 'radius' || d.kind === 'diameter'; });
+    // Angles do not scale with the drawing, so they never vote.
+    var ratios = (linear.length > 0 ? linear : radial)
+        .map(function (d) {
+        var value = parsePdfDimensionValue(d.text.text);
+        return value !== undefined && d.measured > 0 ? value / d.measured : NaN;
+    })
+        .filter(function (r) { return Number.isFinite(r) && r > 0; });
+    if (ratios.length === 0)
+        return undefined;
+    // Cluster ratios within 1 % and take the biggest cluster's median.
+    var best = [];
+    var _loop_5 = function (r) {
+        var cluster = ratios.filter(function (x) { return Math.abs(x - r) <= r * 0.01; });
+        if (cluster.length > best.length)
+            best = cluster;
+    };
+    try {
+        for (var ratios_1 = __values(ratios), ratios_1_1 = ratios_1.next(); !ratios_1_1.done; ratios_1_1 = ratios_1.next()) {
+            var r = ratios_1_1.value;
+            _loop_5(r);
+        }
+    }
+    catch (e_26_1) { e_26 = { error: e_26_1 }; }
+    finally {
+        try {
+            if (ratios_1_1 && !ratios_1_1.done && (_a = ratios_1.return)) _a.call(ratios_1);
+        }
+        finally { if (e_26) throw e_26.error; }
+    }
+    return median(best);
+}
+//# sourceMappingURL=pdfDimensionPattern.js.map