@mlightcad/cad-simple-viewer 1.8.0-preview.2 → 1.8.0-preview.4

package/lib/smartBlock/AcEdShapeMatcher.js

@@ -0,0 +1,749 @@
+/**
+ * Finds repeated copies of a group of shapes ("block instances") under a
+ * similarity transform: translation, rotation, optional uniform scale and
+ * optional mirroring.
+ *
+ * Pure geometry: shapes are described by {@link AcEdShapeFeature}s so the
+ * algorithm is testable without the data model.
+ */
+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));
+};
+// Math.hypot is several times slower than sqrt in V8, and matching calls
+// this in its innermost loops.
+function dist(a, b) {
+    var dx = a.x - b.x;
+    var dy = a.y - b.y;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+/**
+ * Opaque store of spatial indexes for {@link AcEdShapeMatchOptions.gridCache}.
+ * Create one per unchanged candidate set, e.g. per detection run.
+ */
+var AcEdShapeGridCache = /** @class */ (function () {
+    function AcEdShapeGridCache() {
+    }
+    return AcEdShapeGridCache;
+}());
+export { AcEdShapeGridCache };
+var gridStores = new WeakMap();
+function gridStoreOf(cache) {
+    var store = gridStores.get(cache);
+    if (!store)
+        gridStores.set(cache, (store = new Map()));
+    return store;
+}
+function groupByKind(features) {
+    var e_1, _a;
+    var map = new Map();
+    try {
+        for (var features_1 = __values(features), features_1_1 = features_1.next(); !features_1_1.done; features_1_1 = features_1.next()) {
+            var f = features_1_1.value;
+            var list = map.get(f.kind);
+            if (list)
+                list.push(f);
+            else
+                map.set(f.kind, [f]);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (features_1_1 && !features_1_1.done && (_a = features_1.return)) _a.call(features_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return map;
+}
+/** Applies an affine map to a point. */
+export function acedApplyAffine2d(t, p) {
+    return { x: t.a * p.x + t.c * p.y + t.e, y: t.b * p.x + t.d * p.y + t.f };
+}
+/**
+ * Similarity mapping `p0 → q0` and `p1 → q1`. With `mirror`, the template is
+ * reflected across its local x axis first (`y → -y`).
+ */
+function similarityFrom(p0, p1, q0, q1, mirror) {
+    var sign = mirror ? -1 : 1;
+    var vx = p1.x - p0.x;
+    var vy = (p1.y - p0.y) * sign;
+    var wx = q1.x - q0.x;
+    var wy = q1.y - q0.y;
+    var len = Math.hypot(vx, vy);
+    if (len === 0)
+        return undefined;
+    var scale = Math.hypot(wx, wy) / len;
+    var rotation = Math.atan2(wy, wx) - Math.atan2(vy, vx);
+    var cos = Math.cos(rotation) * scale;
+    var sin = Math.sin(rotation) * scale;
+    // M = R(θ)·s·diag(1, sign)
+    var a = cos;
+    var b = sin;
+    var c = -sin * sign;
+    var d = cos * sign;
+    var t = {
+        a: a,
+        b: b,
+        c: c,
+        d: d,
+        e: q0.x - (a * p0.x + c * p0.y),
+        f: q0.y - (b * p0.x + d * p0.y)
+    };
+    return { t: t, rotation: rotation, scale: scale };
+}
+/**
+ * Uniform grid over feature centers, one per shape kind so a lookup only
+ * touches shapes that can match. Cells are nested numeric maps: no string
+ * keys and no overflow for far-away coordinates.
+ */
+var KindGrid = /** @class */ (function () {
+    function KindGrid(features, cell) {
+        var e_2, _a;
+        this.cell = cell;
+        this.cells = new Map();
+        this.size = features.length;
+        this.sizes = Float64Array.from(features, function (f) { return f.size; }).sort();
+        try {
+            for (var features_2 = __values(features), features_2_1 = features_2.next(); !features_2_1.done; features_2_1 = features_2.next()) {
+                var feature = features_2_1.value;
+                var gx = Math.floor(feature.center.x / cell);
+                var gy = Math.floor(feature.center.y / cell);
+                var column = this.cells.get(gx);
+                if (!column)
+                    this.cells.set(gx, (column = new Map()));
+                var bucket = column.get(gy);
+                if (bucket)
+                    bucket.push(feature);
+                else
+                    column.set(gy, [feature]);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (features_2_1 && !features_2_1.done && (_a = features_2.return)) _a.call(features_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    }
+    /** Number of features whose size is within `tol` of `size`. */
+    KindGrid.prototype.countSizes = function (size, tol) {
+        return (lowerBound(this.sizes, size + tol, true) -
+            lowerBound(this.sizes, size - tol, false));
+    };
+    /** Calls `visit` for features whose center is within `radius` of `p`. */
+    KindGrid.prototype.forEachNear = function (p, radius, visit) {
+        var e_3, _a;
+        var x0 = Math.floor((p.x - radius) / this.cell);
+        var x1 = Math.floor((p.x + radius) / this.cell);
+        var y0 = Math.floor((p.y - radius) / this.cell);
+        var y1 = Math.floor((p.y + radius) / this.cell);
+        var r2 = radius * radius;
+        for (var gx = x0; gx <= x1; gx++) {
+            var column = this.cells.get(gx);
+            if (!column)
+                continue;
+            for (var gy = y0; gy <= y1; gy++) {
+                var bucket = column.get(gy);
+                if (!bucket)
+                    continue;
+                try {
+                    for (var bucket_1 = (e_3 = void 0, __values(bucket)), bucket_1_1 = bucket_1.next(); !bucket_1_1.done; bucket_1_1 = bucket_1.next()) {
+                        var f = bucket_1_1.value;
+                        var dx = f.center.x - p.x;
+                        var dy = f.center.y - p.y;
+                        // `visit` returns true to stop the search.
+                        if (dx * dx + dy * dy <= r2 && visit(f))
+                            return true;
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (bucket_1_1 && !bucket_1_1.done && (_a = bucket_1.return)) _a.call(bucket_1);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+        }
+        return false;
+    };
+    return KindGrid;
+}());
+/**
+ * First index whose value is `>= value` (or `> value` with `after`) in an
+ * ascending array.
+ */
+function lowerBound(values, value, after) {
+    var lo = 0;
+    var hi = values.length;
+    while (lo < hi) {
+        var mid = (lo + hi) >> 1;
+        if (values[mid] < value || (after && values[mid] === value))
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+function extentOf(features) {
+    var e_4, _a, e_5, _b;
+    var minX = Infinity;
+    var minY = Infinity;
+    var maxX = -Infinity;
+    var maxY = -Infinity;
+    try {
+        for (var features_3 = __values(features), features_3_1 = features_3.next(); !features_3_1.done; features_3_1 = features_3.next()) {
+            var f = features_3_1.value;
+            try {
+                for (var _c = (e_5 = void 0, __values(__spreadArray([f.center], __read(f.points), false))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var p = _d.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_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            minX = Math.min(minX, f.center.x - f.size);
+            maxX = Math.max(maxX, f.center.x + f.size);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (features_3_1 && !features_3_1.done && (_a = features_3.return)) _a.call(features_3);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return Math.max(maxX - minX, maxY - minY, 0);
+}
+/**
+ * True when `from`, mapped by `t`, lands on `to` within `tol`: their
+ * outlines lie on each other when both have one ({@link AcEdShapeFeature.path}),
+ * otherwise their characteristic points coincide as sets. Center, size,
+ * kind and label are not checked here.
+ *
+ * @param from - Shape to map.
+ * @param to - Shape it should land on.
+ * @param t - Map from `from`'s coordinates to `to`'s.
+ * @param tol - Absolute tolerance in `to`'s coordinates.
+ */
+export function acedShapeLandsOn(from, to, t, tol) {
+    if (from.path && to.path) {
+        var mapped = from.path.map(function (p) { return acedApplyAffine2d(t, p); });
+        return pathWithin(mapped, to.path, tol) && pathWithin(to.path, mapped, tol);
+    }
+    if (from.points.length !== to.points.length)
+        return false;
+    return pointSetsMatch(from.points.map(function (p) { return acedApplyAffine2d(t, p); }), to.points, tol);
+}
+/** True when every vertex of `path` lies within `tol` of `outline`. */
+function pathWithin(path, outline, tol) {
+    var e_6, _a;
+    var _b;
+    var tol2 = tol * tol;
+    try {
+        for (var path_1 = __values(path), path_1_1 = path_1.next(); !path_1_1.done; path_1_1 = path_1.next()) {
+            var p = path_1_1.value;
+            var near = false;
+            for (var i = 0; i < outline.length && !near; i++) {
+                var a = outline[i];
+                var b = (_b = outline[i + 1]) !== null && _b !== void 0 ? _b : a;
+                near = segmentDistance2(p, a, b) <= tol2;
+            }
+            if (!near)
+                return false;
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (path_1_1 && !path_1_1.done && (_a = path_1.return)) _a.call(path_1);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    return true;
+}
+/** Squared distance from `p` to the segment `ab`. */
+function segmentDistance2(p, a, b) {
+    var vx = b.x - a.x;
+    var vy = b.y - a.y;
+    var len2 = vx * vx + vy * vy;
+    var t = len2 > 0 ? ((p.x - a.x) * vx + (p.y - a.y) * vy) / len2 : 0;
+    t = Math.max(0, Math.min(1, t));
+    var dx = a.x + vx * t - p.x;
+    var dy = a.y + vy * t - p.y;
+    return dx * dx + dy * dy;
+}
+/** True when `points` (already transformed) coincide with `target` as sets. */
+function pointSetsMatch(points, target, tol) {
+    var e_7, _a;
+    if (points.length !== target.length)
+        return false;
+    var used = new Array(target.length).fill(false);
+    var tol2 = tol * tol;
+    try {
+        for (var points_1 = __values(points), points_1_1 = points_1.next(); !points_1_1.done; points_1_1 = points_1.next()) {
+            var p = points_1_1.value;
+            var best = -1;
+            var bestDist = tol2;
+            for (var i = 0; i < target.length; i++) {
+                if (used[i])
+                    continue;
+                var dx = p.x - target[i].x;
+                var dy = p.y - target[i].y;
+                var d = dx * dx + dy * dy;
+                if (d <= bestDist) {
+                    bestDist = d;
+                    best = i;
+                }
+            }
+            if (best < 0)
+                return false;
+            used[best] = true;
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (points_1_1 && !points_1_1.done && (_a = points_1.return)) _a.call(points_1);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return true;
+}
+/**
+ * Finds copies of `template` among `candidates`.
+ *
+ * Each copy is located through an anchor pair that fixes the similarity
+ * transform:
+ *
+ * - Anchor 0 is the template shape whose kind is rarest among the
+ *   candidates (fewest seeds to try); among equals, the largest.
+ * - Anchor 1 is the shape whose center is farthest from anchor 0. When all
+ *   shapes share one center (a single polyline, concentric shapes), the
+ *   farthest characteristic point of anchor 0 fixes rotation and mirroring
+ *   instead; shapes without any orientation (circles) match by translation
+ *   (and scale) only.
+ *
+ * Every template shape must then land on a free candidate of the same kind,
+ * label, size and point set. Shapes are checked rarest kind first, so a
+ * wrong transform is rejected early. Matches never share shapes and never
+ * reuse template shapes.
+ *
+ * Cost is roughly `seeds × partners × template size` grid lookups, where
+ * seeds are the candidates of the first anchor kind; candidate grids are per
+ * kind so dense drawings do not slow down unrelated lookups.
+ *
+ * @param template - Shapes of one instance (at least one).
+ * @param candidates - Shapes to search, typically the rest of the drawing.
+ * @param options - Tolerance and allowed transform types.
+ */
+export function acedFindShapeMatches(template, candidates, options) {
+    var e_8, _a, e_9, _b, e_10, _c, e_11, _d, e_12, _e, e_13, _f, e_14, _g;
+    var _h, _j, _k, _l, _m;
+    if (options === void 0) { options = {}; }
+    if (template.length === 0)
+        return [];
+    var extent = extentOf(template);
+    var tol = (_h = options.tolerance) !== null && _h !== void 0 ? _h : Math.max(extent * 0.002, 1e-9);
+    var allowRotation = (_j = options.allowRotation) !== null && _j !== void 0 ? _j : true;
+    var allowMirror = (_k = options.allowMirror) !== null && _k !== void 0 ? _k : true;
+    var allowScale = (_l = options.allowScale) !== null && _l !== void 0 ? _l : false;
+    var ignoreLabels = (_m = options.ignoreLabels) !== null && _m !== void 0 ? _m : false;
+    var labelOk = function (a, b) { var _a, _b; return ignoreLabels || ((_a = a.label) !== null && _a !== void 0 ? _a : '') === ((_b = b.label) !== null && _b !== void 0 ? _b : ''); };
+    // Absolute tolerance grows with the copy so scaled copies are judged
+    // relative to their own size.
+    var tolAt = function (scale) { return tol * Math.max(1, scale); };
+    var sizeOk = function (expected, actual, scale) {
+        return Math.abs(expected - actual) <= tolAt(scale);
+    };
+    var templateKinds = new Set(template.map(function (f) { return f.kind; }));
+    var templateIds = new Set(template.map(function (f) { return f.id; }));
+    var byKind = new Map();
+    try {
+        for (var candidates_1 = __values(candidates), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+            var f = candidates_1_1.value;
+            if (templateIds.has(f.id) || !templateKinds.has(f.kind))
+                continue;
+            var list = byKind.get(f.kind);
+            if (list)
+                list.push(f);
+            else
+                byKind.set(f.kind, [f]);
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (candidates_1_1 && !candidates_1_1.done && (_a = candidates_1.return)) _a.call(candidates_1);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    try {
+        // A kind without candidates cannot be matched at all.
+        for (var templateKinds_1 = __values(templateKinds), templateKinds_1_1 = templateKinds_1.next(); !templateKinds_1_1.done; templateKinds_1_1 = templateKinds_1.next()) {
+            var kind = templateKinds_1_1.value;
+            if (!byKind.has(kind))
+                return [];
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (templateKinds_1_1 && !templateKinds_1_1.done && (_b = templateKinds_1.return)) _b.call(templateKinds_1);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+    var cell = Math.max(extent, tol * 10, 1e-9);
+    var grids = new Map();
+    var store = options.gridCache && gridStoreOf(options.gridCache);
+    if (store) {
+        // Power-of-two cells let templates of similar size share grids. Cached
+        // grids hold every candidate, template shapes included; lookups skip
+        // those.
+        cell = Math.pow(2, Math.ceil(Math.log2(cell)));
+        var all = void 0;
+        try {
+            for (var _o = __values(byKind.keys()), _p = _o.next(); !_p.done; _p = _o.next()) {
+                var kind = _p.value;
+                var key = "".concat(cell, "|").concat(kind);
+                var grid = store.get(key);
+                if (!grid) {
+                    all !== null && all !== void 0 ? all : (all = groupByKind(candidates));
+                    grid = new KindGrid(all.get(kind), cell);
+                    store.set(key, grid);
+                }
+                grids.set(kind, grid);
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_p && !_p.done && (_c = _o.return)) _c.call(_o);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+    }
+    else {
+        try {
+            for (var byKind_1 = __values(byKind), byKind_1_1 = byKind_1.next(); !byKind_1_1.done; byKind_1_1 = byKind_1.next()) {
+                var _q = __read(byKind_1_1.value, 2), kind = _q[0], list = _q[1];
+                grids.set(kind, new KindGrid(list, cell));
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (byKind_1_1 && !byKind_1_1.done && (_d = byKind_1.return)) _d.call(byKind_1);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+    }
+    // Without scaling only equally sized shapes can match, so rarity is
+    // counted by size too: one kind (lines of a layer) can hold thousands of
+    // shapes while few have the anchor's length.
+    var countOf = function (f) {
+        var grid = grids.get(f.kind);
+        return allowScale ? grid.size : grid.countSizes(f.size, tolAt(1));
+    };
+    // Anchor 0: rarest kind, then largest size (a zero-size anchor cannot
+    // give the scale).
+    var a0 = template.reduce(function (best, f) {
+        if (best.size <= 0 && f.size > 0)
+            return f;
+        if (f.size <= 0 && best.size > 0)
+            return best;
+        var cf = countOf(f);
+        var cb = countOf(best);
+        if (cf !== cb)
+            return cf < cb ? f : best;
+        return f.size > best.size ? f : best;
+    });
+    var a1 = a0;
+    try {
+        for (var template_1 = __values(template), template_1_1 = template_1.next(); !template_1_1.done; template_1_1 = template_1.next()) {
+            var f = template_1_1.value;
+            if (dist(f.center, a0.center) > dist(a1.center, a0.center))
+                a1 = f;
+        }
+    }
+    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+    finally {
+        try {
+            if (template_1_1 && !template_1_1.done && (_e = template_1.return)) _e.call(template_1);
+        }
+        finally { if (e_12) throw e_12.error; }
+    }
+    var span = dist(a0.center, a1.center);
+    // Orientation point of anchor 0 for templates without a second center.
+    var orient;
+    var orientRadius = 0;
+    try {
+        for (var _r = __values(a0.points), _s = _r.next(); !_s.done; _s = _r.next()) {
+            var p = _s.value;
+            var r = dist(p, a0.center);
+            if (r > orientRadius) {
+                orientRadius = r;
+                orient = p;
+            }
+        }
+    }
+    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    finally {
+        try {
+            if (_s && !_s.done && (_f = _r.return)) _f.call(_r);
+        }
+        finally { if (e_13) throw e_13.error; }
+    }
+    var lever = Math.max(span, orientRadius, 1e-9);
+    var mirrors = allowMirror ? [false, true] : [false];
+    // Check order: anchors first, then rarest kinds, so wrong transforms fail
+    // fast. Results are still reported in template order.
+    var rank = function (f) {
+        return f === a0 ? -2 : f === a1 ? -1 : countOf(f);
+    };
+    var order = template
+        .map(function (f, index) { return ({ f: f, index: index }); })
+        .sort(function (x, y) { return rank(x.f) - rank(y.f); });
+    var claimed = new Set();
+    var tryTransform = function (t, scale) {
+        var e_15, _a;
+        var ids = new Array(template.length);
+        var taken = new Set();
+        var pointTol = tolAt(scale);
+        var _loop_2 = function (f, index) {
+            var c = acedApplyAffine2d(t, f.center);
+            var hit;
+            grids.get(f.kind).forEachNear(c, pointTol, function (g) {
+                if (claimed.has(g.id) || taken.has(g.id))
+                    return false;
+                if (templateIds.has(g.id))
+                    return false;
+                if (!labelOk(f, g) || !sizeOk(f.size * scale, g.size, scale)) {
+                    return false;
+                }
+                if (!acedShapeLandsOn(f, g, t, pointTol))
+                    return false;
+                hit = g;
+                return true;
+            });
+            if (!hit)
+                return { value: undefined };
+            ids[index] = hit.id;
+            taken.add(hit.id);
+        };
+        try {
+            for (var order_1 = __values(order), order_1_1 = order_1.next(); !order_1_1.done; order_1_1 = order_1.next()) {
+                var _b = order_1_1.value, f = _b.f, index = _b.index;
+                var state_1 = _loop_2(f, index);
+                if (typeof state_1 === "object")
+                    return state_1.value;
+            }
+        }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (order_1_1 && !order_1_1.done && (_a = order_1.return)) _a.call(order_1);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
+        return ids;
+    };
+    var accept = function (t, rotation, scale, mirrored) {
+        var r = Math.atan2(Math.sin(rotation), Math.cos(rotation));
+        if (!allowScale && Math.abs(scale - 1) * lever > tol * 2)
+            return undefined;
+        if (!allowRotation && Math.abs(r) * lever > tol)
+            return undefined;
+        var ids = tryTransform(t, scale);
+        if (!ids)
+            return undefined;
+        var match = { transform: t, rotation: r, scale: scale, mirrored: mirrored, ids: ids };
+        return !options.accept || options.accept(match) ? match : undefined;
+    };
+    var matches = [];
+    var seeds = byKind
+        .get(a0.kind)
+        .filter(function (f) {
+        return labelOk(a0, f) &&
+            (allowScale ? f.size > 0 || a0.size <= 0 : sizeOk(a0.size, f.size, 1));
+    });
+    var _loop_1 = function (c0) {
+        var e_16, _t, e_17, _u, e_18, _v, e_19, _w, e_20, _x;
+        if (claimed.has(c0.id))
+            return "continue";
+        var scale0 = allowScale && a0.size > 0 ? c0.size / a0.size : 1;
+        var found = void 0;
+        if (span > tol) {
+            // Second anchor: a free shape of the anchor 1 kind at the right
+            // distance from the seed.
+            var reach_1 = span * scale0;
+            var ringTol_1 = tolAt(scale0) * 2;
+            var partners_2 = [];
+            grids.get(a1.kind).forEachNear(c0.center, reach_1 + ringTol_1, function (g) {
+                if (g.id === c0.id || claimed.has(g.id) || !labelOk(a1, g))
+                    return;
+                if (templateIds.has(g.id))
+                    return;
+                if (!sizeOk(a1.size * scale0, g.size, scale0))
+                    return;
+                if (Math.abs(dist(g.center, c0.center) - reach_1) <= ringTol_1) {
+                    partners_2.push(g);
+                }
+            });
+            try {
+                outer: for (var partners_1 = (e_16 = void 0, __values(partners_2)), partners_1_1 = partners_1.next(); !partners_1_1.done; partners_1_1 = partners_1.next()) {
+                    var c1 = partners_1_1.value;
+                    try {
+                        for (var mirrors_1 = (e_17 = void 0, __values(mirrors)), mirrors_1_1 = mirrors_1.next(); !mirrors_1_1.done; mirrors_1_1 = mirrors_1.next()) {
+                            var mirror = mirrors_1_1.value;
+                            var sim = similarityFrom(a0.center, a1.center, c0.center, c1.center, mirror);
+                            if (!sim)
+                                continue;
+                            found = accept(sim.t, sim.rotation, sim.scale, mirror);
+                            if (found)
+                                break outer;
+                        }
+                    }
+                    catch (e_17_1) { e_17 = { error: e_17_1 }; }
+                    finally {
+                        try {
+                            if (mirrors_1_1 && !mirrors_1_1.done && (_u = mirrors_1.return)) _u.call(mirrors_1);
+                        }
+                        finally { if (e_17) throw e_17.error; }
+                    }
+                }
+            }
+            catch (e_16_1) { e_16 = { error: e_16_1 }; }
+            finally {
+                try {
+                    if (partners_1_1 && !partners_1_1.done && (_t = partners_1.return)) _t.call(partners_1);
+                }
+                finally { if (e_16) throw e_16.error; }
+            }
+        }
+        else if (orient && orientRadius > tol) {
+            // One center only: the farthest point of anchor 0 fixes the
+            // orientation. Try each seed point at the right radius (symmetric
+            // shapes offer several; any that maps the whole template is valid).
+            var reach = orientRadius * scale0;
+            var ringTol = tolAt(scale0) * 2;
+            try {
+                outer: for (var _y = (e_18 = void 0, __values(c0.points)), _z = _y.next(); !_z.done; _z = _y.next()) {
+                    var q = _z.value;
+                    if (Math.abs(dist(q, c0.center) - reach) > ringTol)
+                        continue;
+                    try {
+                        for (var mirrors_2 = (e_19 = void 0, __values(mirrors)), mirrors_2_1 = mirrors_2.next(); !mirrors_2_1.done; mirrors_2_1 = mirrors_2.next()) {
+                            var mirror = mirrors_2_1.value;
+                            var sim = similarityFrom(a0.center, orient, c0.center, q, mirror);
+                            if (!sim)
+                                continue;
+                            found = accept(sim.t, sim.rotation, sim.scale, mirror);
+                            if (found)
+                                break outer;
+                        }
+                    }
+                    catch (e_19_1) { e_19 = { error: e_19_1 }; }
+                    finally {
+                        try {
+                            if (mirrors_2_1 && !mirrors_2_1.done && (_w = mirrors_2.return)) _w.call(mirrors_2);
+                        }
+                        finally { if (e_19) throw e_19.error; }
+                    }
+                }
+            }
+            catch (e_18_1) { e_18 = { error: e_18_1 }; }
+            finally {
+                try {
+                    if (_z && !_z.done && (_v = _y.return)) _v.call(_y);
+                }
+                finally { if (e_18) throw e_18.error; }
+            }
+        }
+        else {
+            // No orientation at all (circles, points): translation and scale only.
+            var t = {
+                a: scale0,
+                b: 0,
+                c: 0,
+                d: scale0,
+                e: c0.center.x - scale0 * a0.center.x,
+                f: c0.center.y - scale0 * a0.center.y
+            };
+            found = accept(t, 0, scale0, false);
+        }
+        if (found) {
+            try {
+                for (var _0 = (e_20 = void 0, __values(found.ids)), _1 = _0.next(); !_1.done; _1 = _0.next()) {
+                    var id = _1.value;
+                    claimed.add(id);
+                }
+            }
+            catch (e_20_1) { e_20 = { error: e_20_1 }; }
+            finally {
+                try {
+                    if (_1 && !_1.done && (_x = _0.return)) _x.call(_0);
+                }
+                finally { if (e_20) throw e_20.error; }
+            }
+            matches.push(found);
+        }
+    };
+    try {
+        for (var seeds_1 = __values(seeds), seeds_1_1 = seeds_1.next(); !seeds_1_1.done; seeds_1_1 = seeds_1.next()) {
+            var c0 = seeds_1_1.value;
+            _loop_1(c0);
+        }
+    }
+    catch (e_14_1) { e_14 = { error: e_14_1 }; }
+    finally {
+        try {
+            if (seeds_1_1 && !seeds_1_1.done && (_g = seeds_1.return)) _g.call(seeds_1);
+        }
+        finally { if (e_14) throw e_14.error; }
+    }
+    return matches;
+}
+//# sourceMappingURL=AcEdShapeMatcher.js.map