@expofp/wayfinding-compiler 0.0.0-bootstrap.0 → 0.0.0-stage

package/dist/lib/grid-network.js

@@ -1,349 +0,0 @@
-// The "grid" route-network generator: one tree of cheapest paths over the plan's raster. A stub per
-// open face ends on a router cell; a single growing search then joins the tips, nearest first, each
-// path laid along the cell centers and free to walk from then on. What shapes the lines is the cost
-// of a cell alone — a corridor's middle row is the cheapest, a turn costs a length — and a staircase
-// along one corridor is cut to a straight line. On request, links are cut into the tree where it
-// sends a route the long way round. Produces the {@link RouteNetwork} for `emit-v1`.
-import { crossesBlocker } from './blockers.js';
-import { createConnector } from './connect.js';
-import { emitNetwork, turnDoorwayDocks } from './emit-network.js';
-import { dockFor, followTips, tipPoints } from './entries.js';
-import { floorGrids } from './floor-grids.js';
-import { POINT_EPS, pointKey } from './geom/point-key.js';
-import { pointSegmentDistance } from './geom/primitives.js';
-import { chainSegments, chainsFromEdges } from './network-graph.js';
-import { setUpNetwork } from './network-setup.js';
-import { MIN_PASS } from './network-sizes.js';
-import { NetworkStore } from './network-store.js';
-import { shortcutDetours } from './post-passes.js';
-import { makeRouter } from './router.js';
-import { planStubs, sideOf } from './stubs.js';
-/** What a cell at a corridor's wall costs over one on its middle row, as a share of its length. */
-const CENTERING = 1;
-/** The sine of the angle under which a stub counts as running along a line rather than across it. */
-const ALONG = 0.2;
-/**
- * Cuts each staircase to a straight line: along a chain, the farthest vertex a free straight line
- * reaches while every vertex between stays within a lane of it. A stub's tip on the staircase moves
- * along the stub onto the line, so a corridor between two meetings is one line however many stubs
- * end on it; where a dock from there would be unlawful the tip stays, and the line ends at it. A
- * corner with legs longer than the lane stays a corner.
- * @param store The network, every meeting a node; rebuilt in place.
- * @param whiskers The attached stubs; a tip on a cut staircase moves onto the line.
- * @param lane How far off the straight line a staircase's vertices may stand.
- * @param free Whether a straight line may be laid.
- * @param lawful Whether a stub may dock from a point.
- */
-function cutStairs(store, whiskers, lane, free, lawful) {
-    const tipsAt = new Map();
-    for (const stub of whiskers) {
-        const key = pointKey(stub.tx, stub.ty);
-        tipsAt.set(key, [...(tipsAt.get(key) ?? []), stub]);
-    }
-    const chains = chainsFromEdges(store.toArray(), new Set(tipsAt.keys()));
-    for (const chain of chains) {
-        const { pts } = chain;
-        const kept = [pts[0]];
-        /**
-         * Reads the vertices between two of the chain's as a staircase.
-         * @param from Index of the vertex the line starts at.
-         * @param to Index of the vertex it ends at.
-         * @returns The tips between them moved onto the line, or null when a line may not replace them.
-         */
-        const stairs = (from, to) => {
-            const [ax, ay] = pts[from];
-            const [bx, by] = pts[to];
-            const dx = bx - ax;
-            const dy = by - ay;
-            const length = Math.hypot(dx, dy);
-            const moved = [];
-            // A chain that closes on itself has no line between its ends.
-            if (length < POINT_EPS)
-                return null;
-            for (let k = from + 1; k < to; k++)
-                if (pointSegmentDistance(pts[k][0], pts[k][1], ax, ay, bx, by) > lane)
-                    return null;
-            for (let k = from + 1; k < to; k++) {
-                const [px, py] = pts[k];
-                for (const stub of tipsAt.get(pointKey(px, py)) ?? []) {
-                    // Where the stub's own line meets the straight line; a stub running along the line keeps
-                    // its place along it.
-                    const cross = dx * stub.ny - dy * stub.nx;
-                    const along = Math.abs(cross) > ALONG * length
-                        ? ((stub.mx - ax) * stub.ny - (stub.my - ay) * stub.nx) / cross
-                        : ((px - ax) * dx + (py - ay) * dy) / (length * length);
-                    const at = [+(ax + along * dx).toFixed(2), +(ay + along * dy).toFixed(2)];
-                    const run = (at[0] - stub.mx) * stub.nx + (at[1] - stub.my) * stub.ny;
-                    if (along < 0 || along > 1 || run < MIN_PASS || !lawful(stub, at))
-                        return null;
-                    moved.push({ stub, along, at });
-                }
-            }
-            return free([ax, ay, bx, by]) ? moved : null;
-        };
-        // The edge to the next vertex is the network's own: it stays as it is.
-        const cut = (from, to) => to > from + 1 ? stairs(from, to) : [];
-        let from = 0;
-        while (from < pts.length - 1) {
-            let to = pts.length - 1;
-            let moved = cut(from, to);
-            while (!moved)
-                moved = cut(from, --to);
-            for (const { stub, at } of moved.sort((a, b) => a.along - b.along)) {
-                [stub.tx, stub.ty] = at;
-                kept.push([at[0], at[1]]);
-            }
-            kept.push(pts[to]);
-            from = to;
-        }
-        chain.pts = kept;
-    }
-    store.reset(chainSegments(chains));
-}
-/**
- * Builds the grid route network for one layer.
- * @param walkableRings The layer's walkable polygon (outer rings + holes).
- * @param destinations Footprints the network must reach.
- * @param walls Raw wall polylines as flat `[x0, y0, …]` runs, for exact thin-wall blocking.
- * @param prepared The same walls already prepared, when the caller has them.
- * @param drawn The rest of each destination's drawing; ways in may not cross it.
- * @param openings The openings the entrances make: the ways in they own, through the walls.
- * @param shortcuts Whether links are cut into the tree where it sends a route the long way round.
- * @returns Paths, docks and stats for `emit-v1`.
- */
-export function buildGridNetwork(walkableRings, destinations, walls, prepared, drawn = [], openings = [], shortcuts = false) {
-    const { cfg, wallLines, doors, owners, opened, floor, unservedFloorPieces, doorSides, blockers, destinationOf, failed, note, } = setUpNetwork(walkableRings, destinations, walls, prepared, drawn, openings);
-    // One grid, the plan's: a hall turned its own way is walked on it too.
-    const { grids, frames, frameOfDest } = floorGrids(floor, doorSides, destinations, wallLines, doors, cfg, false);
-    const ctx = grids[0].ctx;
-    const router = makeRouter(grids, cfg, CENTERING);
-    const store = new NetworkStore();
-    const build = { cfg, frames, blockers, destinationOf, note };
-    const mayLay = (seg) => ctx.lineFree(seg[0], seg[1], seg[2], seg[3]) && !crossesBlocker(blockers, seg);
-    /* ---- stubs: one per open side of each destination, as the steiner network plans them ---- */
-    const plan = planStubs({ ...build, destinations, owners, ctx, frameOfDest, opened });
-    const whiskers = [];
-    const anchors = [];
-    /** Sides of each destination a whisker already serves. */
-    const servedSides = new Map();
-    const attach = (stub) => {
-        whiskers.push(stub);
-        if (stub.kind === 'face')
-            servedSides.set(stub.id, (servedSides.get(stub.id) ?? new Set()).add(sideOf(stub.way)));
-    };
-    /**
-     * Moves a stub's tip onto a router cell: the planned tip's, or one a step nearer or farther along
-     * the stub — the cheapest to stand on from which the dock is lawful, the planned one among equals.
-     * Where the floor around the planned tip is too tight to walk, the nearest such cell along the
-     * stub, toward the foot first.
-     * @param stub The stub; its tip moves to the cell's center.
-     * @returns The cell, or -1 when the stub has none (noted).
-     */
-    const seat = (stub) => {
-        const destination = destinationOf.get(stub.id);
-        const farthest = Math.min(stub.way.depth - MIN_PASS, stub.reach + 2 * cfg.stub);
-        let onFloor = false;
-        /**
-         * The cell a number of steps along the stub from its planned tip, when a dock from it is lawful.
-         * @param steps Cells along the stub, toward the foot when negative.
-         * @returns The cell, or -1.
-         */
-        const cellAt = (steps) => {
-            const run = steps * router.pitch;
-            if (stub.reach + run < MIN_PASS || stub.reach + run > farthest)
-                return -1;
-            const cell = router.cellIn(stub.tx + stub.nx * run, stub.ty + stub.ny * run, frames[0]);
-            if (cell < 0 || !router.ok[cell])
-                return -1;
-            onFloor = true;
-            return dockFor(destination, stub.way, router.worldOf(cell), blockers) ? cell : -1;
-        };
-        let best = cellAt(0);
-        for (const steps of [-1, 1]) {
-            const cell = cellAt(steps);
-            if (cell >= 0 && (best < 0 || router.stepCost[cell] < router.stepCost[best]))
-                best = cell;
-        }
-        for (const sign of [-1, 1])
-            for (let steps = 2; best < 0 && Math.abs(steps * router.pitch) <= farthest; steps++)
-                best = cellAt(sign * steps);
-        if (best < 0) {
-            note(stub.id, onFloor ? 'way-in-blocked' : 'no-floor', { at: [stub.tx, stub.ty] });
-            return -1;
-        }
-        [stub.tx, stub.ty] = router.worldOf(best);
-        anchors.push({ id: stub.id, at: [stub.tx, stub.ty] });
-        return best;
-    };
-    const around = Math.round(cfg.stub / router.pitch);
-    /**
-     * How much floor lies around a cell: the walkable cells within a stub's length of it.
-     * @param cell The cell.
-     * @returns The count.
-     */
-    const roomAround = (cell) => {
-        const [x, y] = router.worldOf(cell);
-        let room = 0;
-        for (let dy = -around; dy <= around; dy++)
-            for (let dx = -around; dx <= around; dx++) {
-                const near = router.cellIn(x + dx * router.pitch, y + dy * router.pitch, frames[0]);
-                if (near >= 0 && router.ok[near])
-                    room++;
-            }
-        return room;
-    };
-    /* ---- the tree: every tip joined to the network laid so far, nearest first ---- */
-    /** 1 for each cell a laid path passes. */
-    const laid = new Uint8Array(router.cells);
-    const network = [];
-    /** Stubs whose tip stands on floor no other tip shares. */
-    const stranded = [];
-    let trees = 0;
-    /**
-     * One growth over the stubs: each tip is joined by the cheapest path from the network laid so
-     * far; with no network, or floor it cannot reach, a tree starts from the roomiest tip left.
-     * @param stubs The stubs to join.
-     * @returns The stubs that could not be: no cell to stand on, or alone on their floor.
-     */
-    const grow = (stubs) => {
-        const group = new Int32Array(router.cells).fill(-1);
-        const targets = [];
-        const lost = [];
-        for (const stub of stubs) {
-            const cell = seat(stub);
-            if (cell < 0) {
-                lost.push(stub);
-                continue;
-            }
-            // Already on a laid line: the tip becomes a node of it.
-            if (laid[cell]) {
-                store.splitAt(store.segmentAt(stub.tx, stub.ty), stub.tx, stub.ty);
-                attach(stub);
-                continue;
-            }
-            if (group[cell] < 0) {
-                group[cell] = targets.length;
-                targets.push({ cell, stubs: [], room: roomAround(cell) });
-            }
-            targets[group[cell]].stubs.push(stub);
-        }
-        // Trees start from the tip with most floor around it; the stubs' own order among equals.
-        const order = targets
-            .map((_, index) => index)
-            .sort((a, b) => targets[b].room - targets[a].room || a - b);
-        /** The target a tree started from, by its cell, while nothing has joined it. */
-        const lone = new Map();
-        let next = 0;
-        const reseed = () => {
-            while (next < order.length && group[targets[order[next]].cell] < 0)
-                next++;
-            if (next >= order.length)
-                return null;
-            const { cell } = targets[order[next]];
-            group[cell] = -1;
-            lone.set(cell, order[next]);
-            return [cell];
-        };
-        router.grow(network.length ? network : (reseed() ?? []), group, reseed, (cells, reached) => {
-            const root = cells[cells.length - 1];
-            const seed = lone.get(root);
-            // The first path of a tree: the tip it started from is on the network now.
-            if (seed !== undefined) {
-                lone.delete(root);
-                trees++;
-                targets[seed].stubs.forEach(attach);
-            }
-            for (const [x0, y0, x1, y1] of router.segmentsAlong(cells))
-                store.add(x0, y0, x1, y1);
-            for (const cell of cells) {
-                if (laid[cell])
-                    continue;
-                laid[cell] = 1;
-                network.push(cell);
-            }
-            targets[reached].stubs.forEach(attach);
-            return [];
-        });
-        for (const target of lone.values())
-            for (const stub of targets[target].stubs) {
-                note(stub.id, 'cut-off', { at: [stub.tx, stub.ty] });
-                stranded.push(stub);
-                lost.push(stub);
-            }
-        return lost;
-    };
-    let pending = plan.stubs;
-    // A stub that could not be joined is retried from its destination's next way in.
-    while (pending.length)
-        pending = grow(pending).flatMap((stub) => plan.retry(stub, servedSides, whiskers) ?? []);
-    // No network at all (a plan with one destination): a stub's own run is its line.
-    if (!store.size) {
-        const own = stranded.find((stub) => mayLay([stub.mx, stub.my, stub.tx, stub.ty]));
-        if (own) {
-            store.add(own.mx, own.my, own.tx, own.ty);
-            attach(own);
-        }
-    }
-    followTips(whiskers, store.node(tipPoints(whiskers)));
-    /* ---- shortcuts: links across where the tree sends a route the long way round ---- */
-    let linked = 0;
-    if (shortcuts) {
-        const connector = createConnector(store, router, cfg, {
-            frames,
-            axes: [],
-            doors,
-            blockers,
-            mayLay,
-        });
-        const tree = store.toArray();
-        // Through the connector, so a link ends on the line that claims its last cell.
-        store.reset([]);
-        for (const seg of tree)
-            connector.add(seg);
-        linked = shortcutDetours(store, router, connector);
-        followTips(whiskers, store.node(tipPoints(whiskers)));
-    }
-    /* ---- straighten: every meeting a node, then each staircase one line ---- */
-    cutStairs(store, whiskers, cfg.stub / 2, 
-    // Over cells the router walks, so the line keeps a person's clearance.
-    (seg) => mayLay(seg) && router.cellsAlong(...seg).every((cell) => router.ok[cell] === 1), (stub, at) => dockFor(destinationOf.get(stub.id), stub.way, at, blockers) !== null);
-    turnDoorwayDocks(whiskers, build, store);
-    /* ---- emit the RouteNetwork artifact ---- */
-    const emitted = emitNetwork({ ...build, store, whiskers, destinations, failed, doors });
-    const ways = [];
-    for (const [id, list] of plan.ways)
-        for (const way of list)
-            ways.push({ id, kind: way.kind, foot: [way.mx, way.my], normal: [way.nx, way.ny] });
-    return {
-        paths: emitted.paths,
-        docks: emitted.docks,
-        anatomy: {
-            doors: doors.map((door) => ({
-                gap: [
-                    [door.gap[0], door.gap[1]],
-                    [door.gap[2], door.gap[3]],
-                ],
-                mid: [door.mid[0], door.mid[1]],
-            })),
-            anchors,
-            ways,
-            whiskers: whiskers.map((stub) => ({
-                id: stub.id,
-                kind: stub.kind,
-                foot: [stub.mx, stub.my],
-                tip: [stub.tx, stub.ty],
-            })),
-            frames: [],
-            loose: [],
-            axes: [],
-        },
-        stats: {
-            unreached: emitted.unreached,
-            components: emitted.components,
-            doorways: doors.length,
-            shortcuts: linked,
-            ...(trees > 1 && { untiedPieces: trees - 1 }),
-            ...(unservedFloorPieces > 0 && { unservedFloorPieces }),
-        },
-    };
-}

package/dist/lib/lattice-map.d.ts

@@ -1,19 +0,0 @@
-import type { Lattice, RouteNetworkDock } from './graph-types.js';
-import type { WfGridFloor } from './types.js';
-/**
- * Bytes packed as runs: the value, then the run's length as a little-endian base-128 number, and
- * the whole as base64. A floor's map is long stretches of one value.
- * @param bytes The bytes.
- * @returns The packed text.
- */
-export declare function packRuns(bytes: Uint8Array): string;
-/**
- * One floor's lattice and docks as the map handed to the runtime, in plan units.
- * @param layer The floor's layer id.
- * @param lattice The lattice, in meters.
- * @param docks The docks leaving it, in meters, in the lattice's own order.
- * @param unitsPerMeter Plan coordinates in one meter.
- * @returns The floor's map.
- */
-export declare function latticeMap(layer: string, lattice: Lattice, docks: readonly RouteNetworkDock[], unitsPerMeter: number): WfGridFloor;
-//# sourceMappingURL=lattice-map.d.ts.map

package/dist/lib/lattice-map.js

@@ -1,92 +0,0 @@
-// The lattice as it is handed out: a map of each floor in the plan's own units — where the grid
-// stands, how its cells are spaced, a byte of links per cell — and the docks that leave it.
-import { PLAN_DECIMALS } from './scale.js';
-/** How near a blocker a route starts to pay more to walk, in meters: a wide aisle's half. */
-const NEAR = 1.5;
-const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-/**
- * Bytes as base64 text.
- * @param bytes The bytes.
- * @returns The text, padded.
- */
-function toBase64(bytes) {
-    const chunks = [];
-    let chunk = '';
-    for (let i = 0; i < bytes.length; i += 3) {
-        const triple = (bytes[i] << 16) | ((bytes[i + 1] ?? 0) << 8) | (bytes[i + 2] ?? 0);
-        chunk +=
-            ALPHABET[triple >> 18] +
-                ALPHABET[(triple >> 12) & 63] +
-                (i + 1 < bytes.length ? ALPHABET[(triple >> 6) & 63] : '=') +
-                (i + 2 < bytes.length ? ALPHABET[triple & 63] : '=');
-        // In pieces: one string grown a character at a time over a whole floor is slow to build.
-        if (chunk.length >= 8192) {
-            chunks.push(chunk);
-            chunk = '';
-        }
-    }
-    return chunks.join('') + chunk;
-}
-/**
- * Bytes packed as runs: the value, then the run's length as a little-endian base-128 number, and
- * the whole as base64. A floor's map is long stretches of one value.
- * @param bytes The bytes.
- * @returns The packed text.
- */
-export function packRuns(bytes) {
-    const runs = [];
-    for (let start = 0; start < bytes.length;) {
-        let end = start + 1;
-        while (end < bytes.length && bytes[end] === bytes[start])
-            end++;
-        runs.push(bytes[start]);
-        for (let length = end - start;; length >>>= 7) {
-            if (length < 128) {
-                runs.push(length);
-                break;
-            }
-            runs.push((length & 127) | 128);
-        }
-        start = end;
-    }
-    return toBase64(Uint8Array.from(runs));
-}
-/**
- * One floor's lattice and docks as the map handed to the runtime, in plan units.
- * @param layer The floor's layer id.
- * @param lattice The lattice, in meters.
- * @param docks The docks leaving it, in meters, in the lattice's own order.
- * @param unitsPerMeter Plan coordinates in one meter.
- * @returns The floor's map.
- */
-export function latticeMap(layer, lattice, docks, unitsPerMeter) {
-    const at = (v) => +(v * unitsPerMeter).toFixed(PLAN_DECIMALS);
-    const nodeX = (cell) => lattice.origin[0] + (cell % lattice.width) * lattice.pitch;
-    const nodeY = (cell) => lattice.origin[1] + Math.floor(cell / lattice.width) * lattice.pitch;
-    const turns = [];
-    docks.forEach((dock, index) => {
-        const cell = lattice.dockCells[index];
-        // A dock that leaves from elsewhere than its node turns there on its way: a doorway's middle.
-        if (at(dock.from[0]) !== at(nodeX(cell)) || at(dock.from[1]) !== at(nodeY(cell)))
-            turns.push(index, at(dock.from[0]), at(dock.from[1]));
-    });
-    return {
-        layer,
-        x: at(lattice.origin[0]),
-        y: at(lattice.origin[1]),
-        pitch: +(lattice.pitch * unitsPerMeter).toFixed(6),
-        width: lattice.width,
-        height: lattice.height,
-        links: packRuns(lattice.links),
-        near: +(NEAR * unitsPerMeter).toFixed(6),
-        ...(lattice.sparseFrom !== undefined && {
-            sparseFrom: +(lattice.sparseFrom * unitsPerMeter).toFixed(6),
-        }),
-        docks: docks.flatMap((dock, index) => [
-            at(dock.to[0]),
-            at(dock.to[1]),
-            lattice.dockCells[index],
-        ]),
-        ...(turns.length && { turns }),
-    };
-}

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

@@ -1,32 +0,0 @@
-import type { Ring } from './geom/types.js';
-import type { PreparedWalls } from './geom/walls.js';
-import { type NetworkVariant, type RouteNetwork, type RouteNetworkDestination } from './graph-types.js';
-import type { Opening } from './openings.js';
-/** How a lattice is spaced. */
-export interface LatticeSpacing {
-    /** Distance between neighboring nodes, in meters. */
-    readonly pitch: number;
-    /**
-     * How far from the nearest cell nobody can stand in open floor begins, in meters: there the
-     * reader stands its nodes two cells apart. Absent, a node stands in every cell.
-     */
-    readonly sparseFrom?: number;
-}
-/** The spacing of each lattice network. */
-export declare const LATTICE_SPACING: Readonly<Record<Exclude<NetworkVariant, 'steiner'>, LatticeSpacing>>;
-/**
- * Builds the lattice route network for one layer.
- * @param walkableRings The layer's walkable polygon (outer rings + holes).
- * @param destinations Footprints the network must reach.
- * @param walls Raw wall polylines as flat `[x0, y0, …]` runs, for exact thin-wall blocking.
- * @param prepared The same walls already prepared, when the caller has them.
- * @param drawn The rest of each destination's drawing; ways in may not cross it.
- * @param openings The openings the entrances make: the ways in they own, through the walls.
- * @param spacing How the lattice is spaced.
- * @returns The docks, the lattice they stand on, and stats.
- */
-export declare function buildLatticeNetwork(walkableRings: readonly Ring[], destinations: readonly RouteNetworkDestination[], walls: readonly (readonly number[])[], prepared: PreparedWalls | undefined, drawn: readonly {
-    readonly id: string;
-    readonly ring: Ring;
-}[], openings: readonly Opening[], spacing: LatticeSpacing): RouteNetwork;
-//# sourceMappingURL=lattice-network.d.ts.map