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

package/dist/lib/router.js

@@ -1,388 +0,0 @@
-// The axis router: a four-heading walk over the mask with turn and proximity costs — one grid per
-// drawn direction, walked as one.
-import { cellArray } from './cell-array.js';
-import { fromFrame, linesMeet, nearestFrame, toFrame } from './geom/frames.js';
-import { MinHeap } from './min-heap.js';
-import { MIN_PASS } from './network-sizes.js';
-const NEAR_PENALTY = 1.5;
-const TIGHT_PENALTY = 8;
-const DIRS = [
-    [1, 0],
-    [-1, 0],
-    [0, 1],
-    [0, -1],
-];
-/**
- * Build the router. Per grid: coarse cells free when any mask cell is, seam flags so a thin wall still
- * blocks a step, and a cost that keeps off walls. A roomy cell may step onto another grid at the cost of a
- * turn; along an aisle its own grid runs straight while the others zigzag, so the walk picks it naturally.
- * @param grids The floor per direction, plan axes first; a direction may have several grids.
- * @param cfg Network sizes.
- * @returns The router.
- */
-export function makeRouter(grids, cfg) {
-    const f = Math.max(1, Math.round(cfg.pitch / grids[0].ctx.cs));
-    const pitch = f * grids[0].ctx.cs;
-    const layout = grids.map(({ ctx }) => ({
-        w2: Math.max(2, Math.floor(ctx.w / f)),
-        h2: Math.max(2, Math.floor(ctx.h / f)),
-        offset: 0,
-    }));
-    let cells = 0;
-    for (const grid of layout) {
-        grid.offset = cells;
-        cells += grid.w2 * grid.h2;
-    }
-    const ok = cellArray(Uint8Array, cells);
-    const stepCost = cellArray(Float32Array, cells);
-    // A router cell is free when ANY of its mask cells is (keeps narrow doorways), which alone would let a
-    // step cross a thin wall. These flag whether the shared edge of two neighbors has a free mask-cell pair
-    // across it, so a wall along the seam blocks the step.
-    const passX = cellArray(Uint8Array, cells);
-    const passY = cellArray(Uint8Array, cells);
-    /** 1 where a cell has clearance to turn in (including onto another grid). */
-    const roomy = cellArray(Uint8Array, cells);
-    /** Which grid a cell belongs to. */
-    const gridOf = cellArray(Int32Array, cells);
-    grids.forEach(({ ctx }, g) => {
-        const { w2, h2, offset } = layout[g];
-        const maskFree = (i) => ctx.mask[i] === 1 && ctx.dist[i] >= MIN_PASS;
-        gridOf.fill(g, offset, offset + w2 * h2);
-        for (let y = 0; y < h2; y++)
-            for (let x = 0; x < w2; x++) {
-                const c = offset + y * w2 + x;
-                let any = 0;
-                let dmax = 0;
-                for (let dy = 0; dy < f; dy++)
-                    for (let dx = 0; dx < f; dx++) {
-                        const i = (y * f + dy) * ctx.w + (x * f + dx);
-                        if (maskFree(i))
-                            any = 1;
-                        dmax = Math.max(dmax, ctx.dist[i]);
-                    }
-                ok[c] = any;
-                roomy[c] = dmax < cfg.clear ? 0 : 1;
-                stepCost[c] =
-                    pitch *
-                        (1 +
-                            Math.max(0, NEAR_PENALTY - dmax) * NEAR_PENALTY +
-                            (dmax < cfg.clear ? TIGHT_PENALTY : 0));
-                if (x + 1 < w2) {
-                    const xa = x * f + f - 1;
-                    const xb = (x + 1) * f;
-                    let open = 0;
-                    for (let dy = 0; dy < f && !open; dy++) {
-                        const row = (y * f + dy) * ctx.w;
-                        if (maskFree(row + xa) && maskFree(row + xb))
-                            open = 1;
-                    }
-                    passX[c] = open;
-                }
-                if (y + 1 < h2) {
-                    const ya = (y * f + f - 1) * ctx.w;
-                    const yb = (y + 1) * f * ctx.w;
-                    let open = 0;
-                    for (let dx = 0; dx < f && !open; dx++) {
-                        const col = x * f + dx;
-                        if (maskFree(ya + col) && maskFree(yb + col))
-                            open = 1;
-                    }
-                    passY[c] = open;
-                }
-            }
-    });
-    // A grid with no roomy cell would be an island; there the walk may change grids from any cell.
-    const turnsAnywhere = grids.map((_, g) => {
-        const { w2, h2, offset } = layout[g];
-        for (let c = offset; c < offset + w2 * h2; c++)
-            if (ok[c] && roomy[c])
-                return false;
-        return true;
-    });
-    const canTurn = (c) => roomy[c] === 1 || turnsAnywhere[gridOf[c]];
-    const states = cells * 4;
-    const dist = cellArray(Float32Array, states);
-    const seen = cellArray(Int32Array, states);
-    const parent = cellArray(Int32Array, states);
-    let epoch = 0;
-    /**
-     * A point's cell on one grid.
-     * @param g The grid.
-     * @param x Point x.
-     * @param y Point y.
-     * @returns The cell, or -1 off that grid.
-     */
-    const cellOn = (g, x, y) => {
-        const { ctx, frame } = grids[g];
-        const { w2, h2, offset } = layout[g];
-        const [u, v] = toFrame(frame, x, y);
-        const gx = Math.floor((u - ctx.ox) / pitch);
-        const gy = Math.floor((v - ctx.oy) / pitch);
-        return gx >= 0 && gy >= 0 && gx < w2 && gy < h2 ? offset + gy * w2 + gx : -1;
-    };
-    const cellsOf = (x, y) => {
-        const out = [];
-        for (let g = 0; g < grids.length; g++) {
-            const c = cellOn(g, x, y);
-            if (c >= 0)
-                out.push(c);
-        }
-        return out;
-    };
-    // A direction may have several grids over different ground.
-    const frames = grids.map((grid) => grid.frame);
-    const sameFrame = grids.map((grid) => grids.flatMap((other, g) => (other.frame === grid.frame ? [g] : [])));
-    const gridsAlong = (dx, dy) => sameFrame[nearestFrame(frames, dx, dy)];
-    const cellIn = (x, y, frame) => {
-        for (const g of sameFrame[frames.indexOf(frame)] ?? []) {
-            const c = cellOn(g, x, y);
-            if (c >= 0)
-                return c;
-        }
-        return -1;
-    };
-    const cellOf = (x, y, dx, dy) => cellIn(x, y, frames[nearestFrame(frames, dx, dy)]);
-    /**
-     * Exact center of a cell.
-     * @param c The cell.
-     * @returns The center in plan coordinates.
-     */
-    const centerOf = (c) => {
-        const g = gridOf[c];
-        const { ctx, frame } = grids[g];
-        const { w2, offset } = layout[g];
-        const i = c - offset;
-        return fromFrame(frame, ctx.ox + ((i % w2) + 0.5) * pitch, ctx.oy + (Math.floor(i / w2) + 0.5) * pitch);
-    };
-    const worldOf = (c) => {
-        const [x, y] = centerOf(c);
-        return [+x.toFixed(2), +y.toFixed(2)];
-    };
-    const cellsAlong = (x0, y0, x1, y1, own = false) => {
-        const out = [];
-        const len = Math.hypot(x1 - x0, y1 - y0);
-        const n = Math.max(1, Math.ceil(len / (pitch * 0.5)));
-        const only = own ? gridsAlong(x1 - x0, y1 - y0) : null;
-        for (let g = 0; g < grids.length; g++)
-            for (let k = 0; k <= n && (!only || only.includes(g)); k++) {
-                const c = cellOn(g, x0 + ((x1 - x0) * k) / n, y0 + ((y1 - y0) * k) / n);
-                if (c >= 0)
-                    out.push(c);
-            }
-        // Not reached by its own grids: fall back to every grid.
-        return out.length || !own ? out : cellsAlong(x0, y0, x1, y1);
-    };
-    const stepTo = (c, nd) => {
-        const { w2, h2, offset } = layout[gridOf[c]];
-        const i = c - offset;
-        const x = (i % w2) + DIRS[nd][0];
-        const y = Math.floor(i / w2) + DIRS[nd][1];
-        if (x < 0 || y < 0 || x >= w2 || y >= h2)
-            return -1;
-        const nc = offset + y * w2 + x;
-        if (!ok[nc])
-            return -1;
-        const step = DIRS[nd][0] === 1
-            ? passX[c]
-            : DIRS[nd][0] === -1
-                ? passX[nc]
-                : DIRS[nd][1] === 1
-                    ? passY[c]
-                    : passY[nc];
-        return step ? nc : -1;
-    };
-    /**
-     * Cells from a reached state back to its seed, reached first.
-     * @param s The reached state.
-     * @returns The cells, consecutive repeats removed.
-     */
-    const pathTo = (s) => {
-        const cells = [];
-        let cur = s;
-        while (cur >= 0) {
-            const cc = Math.floor(cur / 4);
-            if (!cells.length || cells[cells.length - 1] !== cc)
-                cells.push(cc);
-            cur = parent[cur];
-        }
-        return cells;
-    };
-    /**
-     * Offer one step to the search.
-     * @param s State stepped from.
-     * @param nc Cell stepped onto.
-     * @param nd Heading there.
-     * @param ncost Cost there.
-     * @param heap The heap.
-     */
-    const offer = (s, nc, nd, ncost, heap) => {
-        const ns = nc * 4 + nd;
-        if (seen[ns] !== epoch || ncost < dist[ns]) {
-            seen[ns] = epoch;
-            dist[ns] = ncost;
-            parent[ns] = s;
-            // Push the Float32-rounded cost: the stale check `du > dist[s]` compares against it.
-            heap.push(dist[ns], ns);
-        }
-    };
-    /**
-     * Offer every step out of a state: four along its grid, and onto the other grids.
-     * @param s State just popped.
-     * @param du Its cost.
-     * @param heap The heap.
-     */
-    const relax = (s, du, heap) => {
-        const c = Math.floor(s / 4);
-        const d = s % 4;
-        for (let nd = 0; nd < 4; nd++) {
-            const nc = stepTo(c, nd);
-            if (nc >= 0)
-                offer(s, nc, nd, du + stepCost[nc] + (nd !== d ? cfg.turn : 0), heap);
-        }
-        // Change grids only where roomy: in a tight aisle the grids' costs differ over one spot, and the walk
-        // would hop between them for the cheaper reading.
-        if (grids.length < 2 || !canTurn(c))
-            return;
-        const [x, y] = centerOf(c);
-        for (let g = 0; g < grids.length; g++) {
-            if (g === gridOf[c])
-                continue;
-            const nc = cellOn(g, x, y);
-            if (nc >= 0 && ok[nc] && canTurn(nc))
-                offer(s, nc, d, du + cfg.turn, heap);
-        }
-    };
-    // A cell starts the search in all four headings at cost 0.
-    const seed = (c, heap) => {
-        for (let d = 0; d < 4; d++) {
-            const s = c * 4 + d;
-            dist[s] = 0;
-            seen[s] = epoch;
-            parent[s] = -1;
-            heap.push(0, s);
-        }
-    };
-    const route = (seeds, isTarget) => {
-        epoch++;
-        const heap = new MinHeap();
-        for (const c of seeds)
-            if (c >= 0 && ok[c])
-                seed(c, heap);
-        while (heap.size) {
-            const s = heap.pop();
-            const du = heap.poppedKey;
-            if (seen[s] !== epoch || du > dist[s])
-                continue;
-            if (isTarget[Math.floor(s / 4)])
-                return pathTo(s);
-            relax(s, du, heap);
-        }
-        return null;
-    };
-    const grow = (seeds, group, reseed, onJoin) => {
-        // One epoch for the whole growth: settled states stay settled across targets.
-        epoch++;
-        const heap = new MinHeap();
-        const tree = new Set();
-        const join = (c) => {
-            if (tree.has(c) || !ok[c])
-                return;
-            tree.add(c);
-            seed(c, heap);
-        };
-        for (const c of seeds)
-            join(c);
-        for (;;) {
-            if (!heap.size) {
-                const next = reseed();
-                if (!next)
-                    break;
-                for (const c of next)
-                    join(c);
-                continue;
-            }
-            const s = heap.pop();
-            const du = heap.poppedKey;
-            if (seen[s] !== epoch || du > dist[s])
-                continue;
-            const c = Math.floor(s / 4);
-            if (group[c] >= 0) {
-                const cells = pathTo(s);
-                const reached = group[c];
-                group[c] = -1;
-                const rest = onJoin(cells, reached);
-                for (const cell of cells)
-                    join(cell);
-                for (const cell of rest)
-                    join(cell);
-                continue;
-            }
-            relax(s, du, heap);
-        }
-        return tree;
-    };
-    const segmentsAlong = (cells) => {
-        const floor = grids[0].ctx;
-        // Straight runs: consecutive same-grid steps with one cell offset. Compared by offset, since rounded
-        // centers on a turned grid are not exactly collinear.
-        const runs = [];
-        for (let i = 0; i + 1 < cells.length; i++) {
-            const same = gridOf[cells[i]] === gridOf[cells[i + 1]];
-            const grid = same ? gridOf[cells[i]] : -1;
-            const step = same ? cells[i + 1] - cells[i] : 0;
-            const to = worldOf(cells[i + 1]);
-            const last = runs[runs.length - 1];
-            if (last && grid >= 0 && last.grid === grid && last.step === step)
-                last.to = to;
-            else
-                runs.push({ grid, step, from: worldOf(cells[i]), to });
-        }
-        const poly = runs.length ? [runs[0].from] : [];
-        for (let r = 0; r < runs.length; r++) {
-            const run = runs[r];
-            const before = runs[r - 1];
-            const after = runs[r + 1];
-            // A grid change between two runs: lay it through the corner where the two runs' lines meet.
-            if (run.grid < 0 && before && after && before.grid >= 0 && after.grid >= 0) {
-                const met = linesMeet(before.from, [before.to[0] - before.from[0], before.to[1] - before.from[1]], after.from, [after.to[0] - after.from[0], after.to[1] - after.from[1]]);
-                // Only within a cell of the switch: near-parallel directions meet far off the walked path.
-                if (met &&
-                    met.ta >= 0 &&
-                    met.tb <= 1 &&
-                    Math.hypot(met.at[0] - before.to[0], met.at[1] - before.to[1]) <= pitch &&
-                    floor.lineFree(before.from[0], before.from[1], met.at[0], met.at[1]) &&
-                    floor.lineFree(met.at[0], met.at[1], after.to[0], after.to[1])) {
-                    poly[poly.length - 1] = met.at;
-                    poly.push(after.to);
-                    after.from = met.at;
-                    r++;
-                    continue;
-                }
-            }
-            poly.push(run.to);
-        }
-        const out = [];
-        for (let i = 0; i + 1 < poly.length; i++) {
-            const [x0, y0] = poly[i];
-            const [x1, y1] = poly[i + 1];
-            if (Math.hypot(x1 - x0, y1 - y0) >= 0.01)
-                out.push([x0, y0, x1, y1]);
-        }
-        return out;
-    };
-    return {
-        cells,
-        ok,
-        pitch,
-        route,
-        grow,
-        stepTo,
-        cellsOf,
-        cellOf,
-        cellIn,
-        frameOf: (c) => grids[gridOf[c]].frame,
-        worldOf,
-        cellsAlong,
-        segmentsAlong,
-    };
-}

package/dist/lib/runs.d.ts

@@ -1,92 +0,0 @@
-import { type AisleAxis } from './axes.js';
-import { type Blockers } from './blockers.js';
-import type { Doorway } from './doorways.js';
-import { type Frame } from './geom/frames.js';
-import type { Segment, Vec2 } from './geom/types.js';
-import type { NetworkSizes } from './network-sizes.js';
-import type { Router } from './router.js';
-/** The floor a path's ends and runs must keep to. */
-export interface Placement {
-    /** The directions the layer is drawn in, the plan's first. */
-    readonly frames: readonly Frame[];
-    /** The aisle axes the stub tips define. */
-    readonly axes: readonly AisleAxis[];
-    /** The layer's doorways. */
-    readonly doors: readonly Doorway[];
-    /** Walls and solid outlines: a corridor's sides. */
-    readonly blockers: Blockers;
-    /** Whether a line may be laid: on the floor, across nothing blocked. */
-    readonly mayLay: (seg: Segment) => boolean;
-}
-/** One straight run of a path: consecutive cells of one grid stepping the same way. */
-export interface Run {
-    /** The frame of the run's grid. */
-    frame: Frame;
-    /** The run lies along the frame's first axis. */
-    horiz: boolean;
-    /** Across coordinate the run was walked at: its cells' centers. */
-    walked: number;
-    /** Across coordinate the run is laid at. */
-    c: number;
-    /** Along coordinate of the first cell's center. */
-    lo: number;
-    /** Along coordinate of the last cell's center. */
-    hi: number;
-    /** Sign of the walk along. */
-    sign: number;
-    /** The cells walked. */
-    cells: number[];
-}
-/**
- * How far across a run may be pulled onto a line: a tip stands within the clearance of its aisle's
- * axis, and a run's cells are centered within half a pitch of what they pass.
- * @param cfg Network sizes.
- * @returns The distance.
- */
-export declare function pullOf(cfg: NetworkSizes): number;
-/**
- * A point in a run's coordinates.
- * @param run The run.
- * @param x Plan x.
- * @param y Plan y.
- * @returns Along the run, and across it.
- */
-export declare function runCoords(run: Run, x: number, y: number): [number, number];
-/**
- * The point at a run's coordinates, on the centimeter grid.
- * @param run The run.
- * @param along Coordinate along the run.
- * @param across Coordinate across it.
- * @returns The point.
- */
-export declare function onRun(run: Run, along: number, across: number): Vec2;
-/**
- * The run's line at an across coordinate, from its first cell's center to its last's.
- * @param run The run.
- * @param c The across coordinate.
- * @returns The segment.
- */
-export declare function runLine(run: Run, c: number): Segment;
-/**
- * The unit direction the run was walked in.
- * @param run The run.
- * @returns The direction.
- */
-export declare function runDirection(run: Run): Vec2;
-/**
- * The straight runs of a path: consecutive cells of one grid stepping the same way.
- * @param router The raster router the path was walked on.
- * @param cells The path.
- * @returns The runs.
- */
-export declare function runsOf(router: Router, cells: readonly number[]): Run[];
-/**
- * Lays a run where its place says: a doorway's middle, its aisle's axis, its corridor's middle,
- * else where it was walked.
- * @param run The run; `c` is set.
- * @param place What the runs are laid on.
- * @param cfg Network sizes.
- * @param mayLay Whether a line may be laid.
- */
-export declare function placeRun(run: Run, place: Placement, cfg: NetworkSizes, mayLay: (seg: Segment) => boolean): void;
-//# sourceMappingURL=runs.d.ts.map