@expofp/wayfinding-compiler 0.0.0-bootstrap.0

package/dist/lib/network-sizes.d.ts

@@ -0,0 +1,29 @@
+/** The sizes every route-network stage reads, all in meters. */
+export interface NetworkSizes {
+    /** Mask cell size. */
+    readonly cs: number;
+    /** Comfortable clearance; tighter floor is passable at a steep cost. */
+    readonly clear: number;
+    /** Router cell size, coarser than {@link NetworkSizes.cs}. */
+    readonly pitch: number;
+    /** Cost of a turn, as a length. */
+    readonly turn: number;
+    /** A face is open when nothing stands within this distance in front of it. */
+    readonly open: number;
+    /** A stub's own length, with open floor ahead; across an aisle it runs to the middle. */
+    readonly stub: number;
+}
+/** The route-network sizes every stage reads, in meters (`scale.ts` scales the plan first). */
+export declare const NETWORK_SIZES: NetworkSizes;
+/**
+ * Least clearance the router passes (half a person's width): a doorway. Cells under `clear` cost ~9×, so a
+ * tight slot is taken only when no wider path exists.
+ */
+export declare const MIN_PASS = 0.3;
+/**
+ * Max ratio of a walk along the network to the walk across open floor. A tree has no way round, so
+ * above this ratio a shortcut link is cut in; and a row's stubs run out to an aisle's middle only while
+ * two neighbors along it stay within it.
+ */
+export declare const MAX_STRETCH = 2;
+//# sourceMappingURL=network-sizes.d.ts.map

package/dist/lib/network-sizes.js

@@ -0,0 +1,22 @@
+// The sizes every route-network stage reads, in meters, and the one ratio the stubs and the shortcut
+// pass share. `scale.ts` brings the plan to meters first.
+/** The route-network sizes every stage reads, in meters (`scale.ts` scales the plan first). */
+export const NETWORK_SIZES = {
+    cs: 0.25,
+    clear: 0.8,
+    pitch: 0.5,
+    turn: 3,
+    open: 1.5,
+    stub: 2,
+};
+/**
+ * Least clearance the router passes (half a person's width): a doorway. Cells under `clear` cost ~9×, so a
+ * tight slot is taken only when no wider path exists.
+ */
+export const MIN_PASS = 0.3;
+/**
+ * Max ratio of a walk along the network to the walk across open floor. A tree has no way round, so
+ * above this ratio a shortcut link is cut in; and a row's stubs run out to an aisle's middle only while
+ * two neighbors along it stay within it.
+ */
+export const MAX_STRETCH = 2;

package/dist/lib/network-store.d.ts

@@ -0,0 +1,173 @@
+import type { Segment, Vec2 } from './geom/types.js';
+/**
+ * The route network under construction: nodes by centimeter key, segments between them.
+ *
+ * Ids are insertion order and every walk goes in id order; a cut segment's halves are added at the
+ * end. Passes break ties by this order, so it keeps the output deterministic.
+ *
+ * Invariants: no self-loops; no two live segments join the same nodes; every coordinate is on the
+ * centimeter grid, and shared ends share exact coordinates.
+ *
+ * Segments are indexed by uniform grid cells; a removed one stays in its cells, skipped, until
+ * reset.
+ */
+export declare class NetworkStore {
+    private readonly nodeId;
+    private readonly nodeX;
+    private readonly nodeY;
+    private readonly nodeKeys;
+    private readonly nodeSegs;
+    private readonly segA;
+    private readonly segB;
+    private readonly live;
+    private readonly edges;
+    private readonly cells;
+    private readonly visited;
+    private liveCount;
+    private visitStamp;
+    private minCx;
+    private minCy;
+    private maxCx;
+    private maxCy;
+    /** Live segments. */
+    get size(): number;
+    /**
+     * Add a segment; its ends are snapped to the centimeter.
+     * @param x0 Start x.
+     * @param y0 Start y.
+     * @param x1 End x.
+     * @param y1 End y.
+     * @returns The segment id, or -1 when both ends share a key or the same two nodes are already
+     * joined.
+     */
+    add(x0: number, y0: number, x1: number, y1: number): number;
+    /**
+     * Remove a live segment; a node left without segments goes with it.
+     * @param id The segment.
+     */
+    remove(id: number): void;
+    /**
+     * Cut a live segment at a point; its halves are added at the end, start half first. A point on
+     * one of its ends changes nothing.
+     * @param id The segment.
+     * @param x Cut x.
+     * @param y Cut y.
+     */
+    splitAt(id: number, x: number, y: number): void;
+    /**
+     * The first live segment, in id order, that carries a point away from both its ends.
+     * @param x Point x.
+     * @param y Point y.
+     * @returns The segment id, or -1 when none does.
+     */
+    segmentAt(x: number, y: number): number;
+    /**
+     * The nearest segment point a lawful way reaches from a point: segments come nearest first by the
+     * millimeter, ties in id order, so equidistant points come deterministically.
+     * @param x Point x.
+     * @param y Point y.
+     * @param lawful Whether the way from the point to a projection is lawful.
+     * @returns The segment, its point and the distance, or null when none is reachable.
+     */
+    nearestLawful(x: number, y: number, lawful: (id: number, qx: number, qy: number) => boolean): {
+        id: number;
+        at: Vec2;
+        away: number;
+    } | null;
+    /**
+     * Visit live segments nearest first, by the distance to the point's projection rounded to the
+     * centimeter (where a caller splits); ties in id order.
+     * @param x Point x.
+     * @param y Point y.
+     * @param rank Maps a distance to the value compared (the distance or a coarser one).
+     * @param visit Gets the id, rounded projection and distance; returning true stops the walk.
+     */
+    visitNearest(x: number, y: number, rank: (away: number) => number, visit: (id: number, qx: number, qy: number, away: number) => boolean): void;
+    /**
+     * The live segment nearest to a point, by rounded projection; lowest id among equals.
+     * @param x Point x.
+     * @param y Point y.
+     * @returns The segment, the rounded projection and the distance, or null for an empty store.
+     */
+    nearest(x: number, y: number): {
+        id: number;
+        at: Vec2;
+        away: number;
+    } | null;
+    /**
+     * A segment's ends.
+     * @param id The segment.
+     * @returns A fresh `[x0, y0, x1, y1]`.
+     */
+    coords(id: number): Segment;
+    /**
+     * Visit every live segment in id order.
+     * @param visit Called with the segment id and its ends.
+     */
+    forEach(visit: (id: number, x0: number, y0: number, x1: number, y1: number) => void): void;
+    /**
+     * Visit the live segments in the cells a box overlaps, in id order: a superset of those whose
+     * bounds meet the box.
+     * @param x0 Box min x.
+     * @param y0 Box min y.
+     * @param x1 Box max x.
+     * @param y1 Box max y.
+     * @param visit Called with the segment id and its ends.
+     */
+    forEachNear(x0: number, y0: number, x1: number, y1: number, visit: (id: number, x0: number, y0: number, x1: number, y1: number) => void): void;
+    /**
+     * The live segments.
+     * @returns Fresh tuples, in id order.
+     */
+    toArray(): Segment[];
+    /**
+     * Drop everything and add the given segments in order; ids restart from 0.
+     * @param segments The new network.
+     */
+    reset(segments: readonly Segment[]): void;
+    /**
+     * Make every meeting a node: segments that cross, end on another or run along one are cut there,
+     * and ends closer than `eps` become one.
+     * @param fixed Points that stay exactly where they are; near ends join them, and fixed points
+     * that near each other become the first of them.
+     * @param eps How close two ends or an end and a segment must be to meet.
+     * @returns Each fixed point that joined another, by its key, and where it went.
+     */
+    node(fixed: readonly Vec2[], eps?: number): Map<string, Vec2>;
+    /**
+     * Whether a live segment ends at the point.
+     * @param x Point x.
+     * @param y Point y.
+     * @returns True when the point keys to a node.
+     */
+    hasNode(x: number, y: number): boolean;
+    /**
+     * The connected pieces of the network.
+     * @returns A label per live segment id: the smallest node index in its piece.
+     */
+    components(): Map<number, number>;
+    /**
+     * Put a segment into every cell its bounds overlap.
+     * @param id The segment.
+     */
+    private index;
+    /**
+     * Live segment ids indexed within a distance of a point, each once, in no particular order.
+     * @param x Point x.
+     * @param y Point y.
+     * @param radius How far around the point to look.
+     * @returns The ids.
+     */
+    private idsNear;
+    /**
+     * Live segment ids indexed in the cells a box overlaps, each once, in no particular order.
+     * @param x0 Box min x.
+     * @param y0 Box min y.
+     * @param x1 Box max x.
+     * @param y1 Box max y.
+     * @returns The ids.
+     */
+    private idsIn;
+    private createNode;
+}
+//# sourceMappingURL=network-store.d.ts.map

package/dist/lib/network-store.js

@@ -0,0 +1,430 @@
+import { POINT_EPS, pointKey, snapCm } from './geom/point-key.js';
+import { pointSegmentDistance, segmentParam } from './geom/primitives.js';
+import { splitCrossings } from './geom/split-crossings.js';
+/** Side of an index cell, in meters. */
+const CELL = 4;
+/**
+ * Slack for the projection's centimeter rounding (up to 1 cm · √2 / 2) in the nearest-first bound.
+ */
+const ROUNDING = POINT_EPS;
+/**
+ * Cell coordinates packed into one number; room for ±32768 cells either way.
+ * @param cx Cell x.
+ * @param cy Cell y.
+ * @returns The key.
+ */
+const cellKey = (cx, cy) => (cx + 32768) * 65536 + (cy + 32768);
+/**
+ * The route network under construction: nodes by centimeter key, segments between them.
+ *
+ * Ids are insertion order and every walk goes in id order; a cut segment's halves are added at the
+ * end. Passes break ties by this order, so it keeps the output deterministic.
+ *
+ * Invariants: no self-loops; no two live segments join the same nodes; every coordinate is on the
+ * centimeter grid, and shared ends share exact coordinates.
+ *
+ * Segments are indexed by uniform grid cells; a removed one stays in its cells, skipped, until
+ * reset.
+ */
+export class NetworkStore {
+    nodeId = new Map();
+    nodeX = [];
+    nodeY = [];
+    nodeKeys = [];
+    nodeSegs = [];
+    segA = [];
+    segB = [];
+    live = [];
+    edges = new Set();
+    cells = new Map();
+    visited = [];
+    liveCount = 0;
+    visitStamp = 0;
+    minCx = Infinity;
+    minCy = Infinity;
+    maxCx = -Infinity;
+    maxCy = -Infinity;
+    /** Live segments. */
+    get size() {
+        return this.liveCount;
+    }
+    /**
+     * Add a segment; its ends are snapped to the centimeter.
+     * @param x0 Start x.
+     * @param y0 Start y.
+     * @param x1 End x.
+     * @param y1 End y.
+     * @returns The segment id, or -1 when both ends share a key or the same two nodes are already
+     * joined.
+     */
+    add(x0, y0, x1, y1) {
+        const ka = pointKey(x0, y0);
+        const kb = pointKey(x1, y1);
+        if (ka === kb)
+            return -1;
+        const known = this.nodeId.get(ka);
+        const other = this.nodeId.get(kb);
+        if (known !== undefined && other !== undefined && this.edges.has(edgeKey(known, other)))
+            return -1;
+        const a = known ?? this.createNode(ka, x0, y0);
+        const b = other ?? this.createNode(kb, x1, y1);
+        const id = this.live.length;
+        this.segA.push(a);
+        this.segB.push(b);
+        this.live.push(true);
+        this.edges.add(edgeKey(a, b));
+        this.nodeSegs[a].add(id);
+        this.nodeSegs[b].add(id);
+        this.visited.push(0);
+        this.liveCount++;
+        this.index(id);
+        return id;
+    }
+    /**
+     * Remove a live segment; a node left without segments goes with it.
+     * @param id The segment.
+     */
+    remove(id) {
+        if (!this.live[id])
+            return;
+        const a = this.segA[id];
+        const b = this.segB[id];
+        this.live[id] = false;
+        this.edges.delete(edgeKey(a, b));
+        this.liveCount--;
+        for (const node of [a, b]) {
+            this.nodeSegs[node].delete(id);
+            if (!this.nodeSegs[node].size)
+                this.nodeId.delete(this.nodeKeys[node]);
+        }
+    }
+    /**
+     * Cut a live segment at a point; its halves are added at the end, start half first. A point on
+     * one of its ends changes nothing.
+     * @param id The segment.
+     * @param x Cut x.
+     * @param y Cut y.
+     */
+    splitAt(id, x, y) {
+        if (!this.live[id])
+            return;
+        const [ax, ay, bx, by] = this.coords(id);
+        const key = pointKey(x, y);
+        if (key === pointKey(ax, ay) || key === pointKey(bx, by))
+            return;
+        this.remove(id);
+        this.add(ax, ay, x, y);
+        this.add(x, y, bx, by);
+    }
+    /**
+     * The first live segment, in id order, that carries a point away from both its ends.
+     * @param x Point x.
+     * @param y Point y.
+     * @returns The segment id, or -1 when none does.
+     */
+    segmentAt(x, y) {
+        const key = pointKey(x, y);
+        let found = -1;
+        for (const id of this.idsNear(x, y, POINT_EPS)) {
+            if (found >= 0 && id > found)
+                continue;
+            const a = this.segA[id];
+            const b = this.segB[id];
+            if (key === this.nodeKeys[a] || key === this.nodeKeys[b])
+                continue;
+            const distance = pointSegmentDistance(x, y, this.nodeX[a], this.nodeY[a], this.nodeX[b], this.nodeY[b]);
+            if (distance < POINT_EPS)
+                found = id;
+        }
+        return found;
+    }
+    /**
+     * The nearest segment point a lawful way reaches from a point: segments come nearest first by the
+     * millimeter, ties in id order, so equidistant points come deterministically.
+     * @param x Point x.
+     * @param y Point y.
+     * @param lawful Whether the way from the point to a projection is lawful.
+     * @returns The segment, its point and the distance, or null when none is reachable.
+     */
+    nearestLawful(x, y, lawful) {
+        let found = null;
+        this.visitNearest(x, y, (away) => Math.round(away * 1000), (id, qx, qy, away) => {
+            if (!lawful(id, qx, qy))
+                return false;
+            found = { id, at: [qx, qy], away };
+            return true;
+        });
+        return found;
+    }
+    /**
+     * Visit live segments nearest first, by the distance to the point's projection rounded to the
+     * centimeter (where a caller splits); ties in id order.
+     * @param x Point x.
+     * @param y Point y.
+     * @param rank Maps a distance to the value compared (the distance or a coarser one).
+     * @param visit Gets the id, rounded projection and distance; returning true stops the walk.
+     */
+    visitNearest(x, y, rank, visit) {
+        if (!this.liveCount)
+            return;
+        const stamp = ++this.visitStamp;
+        const cx = Math.floor(x / CELL);
+        const cy = Math.floor(y / CELL);
+        const pending = [];
+        const take = (key) => {
+            for (const id of this.cells.get(key) ?? []) {
+                if (!this.live[id] || this.visited[id] === stamp)
+                    continue;
+                this.visited[id] = stamp;
+                const a = this.segA[id];
+                const b = this.segB[id];
+                const x0 = this.nodeX[a];
+                const y0 = this.nodeY[a];
+                const x1 = this.nodeX[b];
+                const y1 = this.nodeY[b];
+                const t = segmentParam(x, y, x0, y0, x1, y1);
+                const qx = +(x0 + t * (x1 - x0)).toFixed(2);
+                const qy = +(y0 + t * (y1 - y0)).toFixed(2);
+                const away = Math.hypot(qx - x, qy - y);
+                pending.push({ id, qx, qy, away, rank: rank(away) });
+            }
+        };
+        for (let r = 0;; r++) {
+            // The ring of cells r steps out, clipped to the cells anything was ever indexed in.
+            const x0 = Math.max(cx - r, this.minCx);
+            const x1 = Math.min(cx + r, this.maxCx);
+            for (const gy of [cy - r, cy + r]) {
+                if (gy < this.minCy || gy > this.maxCy || (r === 0 && gy !== cy))
+                    continue;
+                for (let gx = x0; gx <= x1; gx++)
+                    take(cellKey(gx, gy));
+                if (r === 0)
+                    break;
+            }
+            for (const gx of r ? [cx - r, cx + r] : []) {
+                if (gx < this.minCx || gx > this.maxCx)
+                    continue;
+                for (let gy = Math.max(cy - r + 1, this.minCy); gy <= Math.min(cy + r - 1, this.maxCy); gy++)
+                    take(cellKey(gx, gy));
+            }
+            const covered = cx - r <= this.minCx &&
+                cx + r >= this.maxCx &&
+                cy - r <= this.minCy &&
+                cy + r >= this.maxCy;
+            // Every segment not met yet lies wholly outside the square read so far.
+            const reach = covered
+                ? Infinity
+                : Math.min(x - (cx - r) * CELL, (cx + r + 1) * CELL - x, y - (cy - r) * CELL, (cy + r + 1) * CELL - y) - ROUNDING;
+            const limit = rank(reach);
+            pending.sort((p, q) => q.rank - p.rank || q.id - p.id);
+            while (pending.length && pending[pending.length - 1].rank < limit) {
+                const next = pending.pop();
+                if (visit(next.id, next.qx, next.qy, next.away))
+                    return;
+            }
+            if (covered)
+                return;
+        }
+    }
+    /**
+     * The live segment nearest to a point, by rounded projection; lowest id among equals.
+     * @param x Point x.
+     * @param y Point y.
+     * @returns The segment, the rounded projection and the distance, or null for an empty store.
+     */
+    nearest(x, y) {
+        let found = null;
+        this.visitNearest(x, y, (away) => away, (id, qx, qy, away) => {
+            found = { id, at: [qx, qy], away };
+            return true;
+        });
+        return found;
+    }
+    /**
+     * A segment's ends.
+     * @param id The segment.
+     * @returns A fresh `[x0, y0, x1, y1]`.
+     */
+    coords(id) {
+        const a = this.segA[id];
+        const b = this.segB[id];
+        return [this.nodeX[a], this.nodeY[a], this.nodeX[b], this.nodeY[b]];
+    }
+    /**
+     * Visit every live segment in id order.
+     * @param visit Called with the segment id and its ends.
+     */
+    forEach(visit) {
+        for (let id = 0; id < this.live.length; id++) {
+            if (!this.live[id])
+                continue;
+            const a = this.segA[id];
+            const b = this.segB[id];
+            visit(id, this.nodeX[a], this.nodeY[a], this.nodeX[b], this.nodeY[b]);
+        }
+    }
+    /**
+     * Visit the live segments in the cells a box overlaps, in id order: a superset of those whose
+     * bounds meet the box.
+     * @param x0 Box min x.
+     * @param y0 Box min y.
+     * @param x1 Box max x.
+     * @param y1 Box max y.
+     * @param visit Called with the segment id and its ends.
+     */
+    forEachNear(x0, y0, x1, y1, visit) {
+        for (const id of [...this.idsIn(x0, y0, x1, y1)].sort((a, b) => a - b)) {
+            const a = this.segA[id];
+            const b = this.segB[id];
+            visit(id, this.nodeX[a], this.nodeY[a], this.nodeX[b], this.nodeY[b]);
+        }
+    }
+    /**
+     * The live segments.
+     * @returns Fresh tuples, in id order.
+     */
+    toArray() {
+        const out = [];
+        this.forEach((_, x0, y0, x1, y1) => out.push([x0, y0, x1, y1]));
+        return out;
+    }
+    /**
+     * Drop everything and add the given segments in order; ids restart from 0.
+     * @param segments The new network.
+     */
+    reset(segments) {
+        this.nodeId.clear();
+        this.nodeX.length = 0;
+        this.nodeY.length = 0;
+        this.nodeKeys.length = 0;
+        this.nodeSegs.length = 0;
+        this.segA.length = 0;
+        this.segB.length = 0;
+        this.live.length = 0;
+        this.edges.clear();
+        this.cells.clear();
+        this.visited.length = 0;
+        this.liveCount = 0;
+        this.minCx = Infinity;
+        this.minCy = Infinity;
+        this.maxCx = -Infinity;
+        this.maxCy = -Infinity;
+        for (const [x0, y0, x1, y1] of segments)
+            this.add(x0, y0, x1, y1);
+    }
+    /**
+     * Make every meeting a node: segments that cross, end on another or run along one are cut there,
+     * and ends closer than `eps` become one.
+     * @param fixed Points that stay exactly where they are; near ends join them, and fixed points
+     * that near each other become the first of them.
+     * @param eps How close two ends or an end and a segment must be to meet.
+     * @returns Each fixed point that joined another, by its key, and where it went.
+     */
+    node(fixed, eps = POINT_EPS) {
+        const moved = new Map();
+        this.reset(splitCrossings(this.toArray(), eps, fixed, moved));
+        return moved;
+    }
+    /**
+     * Whether a live segment ends at the point.
+     * @param x Point x.
+     * @param y Point y.
+     * @returns True when the point keys to a node.
+     */
+    hasNode(x, y) {
+        return this.nodeId.has(pointKey(x, y));
+    }
+    /**
+     * The connected pieces of the network.
+     * @returns A label per live segment id: the smallest node index in its piece.
+     */
+    components() {
+        const parent = this.nodeX.map((_, i) => i);
+        const find = (i) => {
+            while (parent[i] !== i) {
+                parent[i] = parent[parent[i]];
+                i = parent[i];
+            }
+            return i;
+        };
+        this.forEach((id) => {
+            const ra = find(this.segA[id]);
+            const rb = find(this.segB[id]);
+            if (ra !== rb)
+                parent[Math.max(ra, rb)] = Math.min(ra, rb);
+        });
+        const labels = new Map();
+        this.forEach((id) => labels.set(id, find(this.segA[id])));
+        return labels;
+    }
+    /**
+     * Put a segment into every cell its bounds overlap.
+     * @param id The segment.
+     */
+    index(id) {
+        const [x0, y0, x1, y1] = this.coords(id);
+        const lx = Math.floor(Math.min(x0, x1) / CELL);
+        const hx = Math.floor(Math.max(x0, x1) / CELL);
+        const ly = Math.floor(Math.min(y0, y1) / CELL);
+        const hy = Math.floor(Math.max(y0, y1) / CELL);
+        for (let gx = lx; gx <= hx; gx++)
+            for (let gy = ly; gy <= hy; gy++) {
+                const key = cellKey(gx, gy);
+                const list = this.cells.get(key);
+                if (list)
+                    list.push(id);
+                else
+                    this.cells.set(key, [id]);
+            }
+        this.minCx = Math.min(this.minCx, lx);
+        this.minCy = Math.min(this.minCy, ly);
+        this.maxCx = Math.max(this.maxCx, hx);
+        this.maxCy = Math.max(this.maxCy, hy);
+    }
+    /**
+     * Live segment ids indexed within a distance of a point, each once, in no particular order.
+     * @param x Point x.
+     * @param y Point y.
+     * @param radius How far around the point to look.
+     * @returns The ids.
+     */
+    idsNear(x, y, radius) {
+        return this.idsIn(x - radius, y - radius, x + radius, y + radius);
+    }
+    /**
+     * Live segment ids indexed in the cells a box overlaps, each once, in no particular order.
+     * @param x0 Box min x.
+     * @param y0 Box min y.
+     * @param x1 Box max x.
+     * @param y1 Box max y.
+     * @returns The ids.
+     */
+    idsIn(x0, y0, x1, y1) {
+        // Own set, not visit stamps, so it works inside a `visitNearest` walk.
+        const ids = new Set();
+        for (let gx = Math.floor(x0 / CELL); gx <= Math.floor(x1 / CELL); gx++)
+            for (let gy = Math.floor(y0 / CELL); gy <= Math.floor(y1 / CELL); gy++)
+                for (const id of this.cells.get(cellKey(gx, gy)) ?? [])
+                    if (this.live[id])
+                        ids.add(id);
+        return ids;
+    }
+    createNode(key, x, y) {
+        const node = this.nodeX.length;
+        this.nodeId.set(key, node);
+        this.nodeX.push(snapCm(x));
+        this.nodeY.push(snapCm(y));
+        this.nodeKeys.push(key);
+        this.nodeSegs.push(new Set());
+        return node;
+    }
+}
+/**
+ * The key of an undirected edge between two nodes.
+ * @param a One node.
+ * @param b The other.
+ * @returns The key.
+ */
+function edgeKey(a, b) {
+    return a < b ? `${a}|${b}` : `${b}|${a}`;
+}