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

package/dist/lib/blockers.js

@@ -1,289 +0,0 @@
-// What a straight run may not cross — walls, outlines of destinations nobody walks through, doorway
-// gaps — indexed by the cells they cover, and the rays and boxes read through the index.
-import { rayVsSegment, ringEdges, segmentsCross } from './geom/primitives.js';
-import { NODE_SNAP } from './graph-types.js';
-/** {@link SegmentGrid} cell side, meters: a booth or two, so a query reads a few cells. */
-const GRID_CELL = 4;
-/** Padding a segment is filed with, so a hit a hair past its end or on a cell border still finds it. */
-const GRID_PAD = 1e-3;
-/** What a blocker segment is. */
-export var BlockerKind;
-(function (BlockerKind) {
-    BlockerKind[BlockerKind["Wall"] = 0] = "Wall";
-    BlockerKind[BlockerKind["Solid"] = 1] = "Solid";
-    BlockerKind[BlockerKind["Gap"] = 2] = "Gap";
-})(BlockerKind || (BlockerKind = {}));
-/**
- * Blocker segments bucketed by the cells their bounds cover. It only narrows the candidates: a segment it
- * leaves out has bounds apart from the query's, so no test could hold for it.
- */
-export class SegmentGrid {
-    /** Every blocker segment, in {@link Blockers} order: walls, then outlines, then gaps. */
-    segs = [];
-    /** What each segment is. */
-    from = [];
-    /** Owning destination of a solid edge; empty for walls and gaps. */
-    owner = [];
-    cells = new Map();
-    seen;
-    stamp = 0;
-    /** Bounds of the filed cells, so a ray knows when it has left them all. */
-    c0 = Infinity;
-    c1 = -Infinity;
-    r0 = Infinity;
-    r1 = -Infinity;
-    constructor(blockers) {
-        const add = (seg, from, owner) => {
-            this.segs.push(seg);
-            this.from.push(from);
-            this.owner.push(owner);
-        };
-        for (const wall of blockers.walls)
-            add(wall, BlockerKind.Wall, '');
-        for (const poi of blockers.solid)
-            for (const edge of poi.edges)
-                add(edge, BlockerKind.Solid, poi.id);
-        for (const gap of blockers.gaps)
-            add(gap, BlockerKind.Gap, '');
-        this.seen = new Int32Array(this.segs.length);
-        // The cells the segments reach: a query looks no farther.
-        for (const seg of this.segs) {
-            this.c0 = Math.min(this.c0, Math.floor((Math.min(seg[0], seg[2]) - GRID_PAD) / GRID_CELL));
-            this.c1 = Math.max(this.c1, Math.floor((Math.max(seg[0], seg[2]) + GRID_PAD) / GRID_CELL));
-            this.r0 = Math.min(this.r0, Math.floor((Math.min(seg[1], seg[3]) - GRID_PAD) / GRID_CELL));
-            this.r1 = Math.max(this.r1, Math.floor((Math.max(seg[1], seg[3]) + GRID_PAD) / GRID_CELL));
-        }
-        this.segs.forEach((seg, i) => this.cover(Math.min(seg[0], seg[2]) - GRID_PAD, Math.min(seg[1], seg[3]) - GRID_PAD, Math.max(seg[0], seg[2]) + GRID_PAD, Math.max(seg[1], seg[3]) + GRID_PAD, (key) => {
-            const list = this.cells.get(key);
-            if (list)
-                list.push(i);
-            else
-                this.cells.set(key, [i]);
-        }));
-    }
-    cover(x0, y0, x1, y1, visit) {
-        const c0 = Math.max(this.c0, Math.floor(x0 / GRID_CELL));
-        const c1 = Math.min(this.c1, Math.floor(x1 / GRID_CELL));
-        const r0 = Math.max(this.r0, Math.floor(y0 / GRID_CELL));
-        const r1 = Math.min(this.r1, Math.floor(y1 / GRID_CELL));
-        for (let c = c0; c <= c1; c++)
-            for (let r = r0; r <= r1; r++)
-                visit(c * 1_000_003 + r);
-    }
-    /**
-     * Walk the cells a ray passes through, nearest first, handing each segment once.
-     * @param ox Ray origin x.
-     * @param oy Ray origin y.
-     * @param nx Ray direction x.
-     * @param ny Ray direction y.
-     * @param from Ray parameter to start at.
-     * @param visit Gets a cell's new segments and the parameter where the ray leaves it; true stops.
-     */
-    alongRay(ox, oy, nx, ny, from, visit) {
-        const sx = ox + nx * from;
-        const sy = oy + ny * from;
-        let c = Math.floor(sx / GRID_CELL);
-        let r = Math.floor(sy / GRID_CELL);
-        const stepC = nx > 0 ? 1 : nx < 0 ? -1 : 0;
-        const stepR = ny > 0 ? 1 : ny < 0 ? -1 : 0;
-        // Ray parameter at the next column/row border, and its growth per cell.
-        const border = (p, d, cell) => d > 0 ? ((cell + 1) * GRID_CELL - p) / d : d < 0 ? (cell * GRID_CELL - p) / d : Infinity;
-        let nextC = from + border(sx, nx, c);
-        let nextR = from + border(sy, ny, r);
-        const perC = nx ? GRID_CELL / Math.abs(nx) : Infinity;
-        const perR = ny ? GRID_CELL / Math.abs(ny) : Infinity;
-        this.stamp++;
-        // A ray going nowhere meets only what its start cell holds.
-        const still = !stepC && !stepR;
-        for (;;) {
-            const fresh = [];
-            for (const i of this.cells.get(c * 1_000_003 + r) ?? []) {
-                if (this.seen[i] === this.stamp)
-                    continue;
-                this.seen[i] = this.stamp;
-                fresh.push(i);
-            }
-            if (visit(fresh, Math.min(nextC, nextR)) || still)
-                return;
-            if (nextC < nextR) {
-                c += stepC;
-                nextC += perC;
-            }
-            else {
-                r += stepR;
-                nextR += perR;
-            }
-            // Past the last filed cell the ray meets nothing more.
-            if ((stepC > 0 && c > this.c1) || (stepC < 0 && c < this.c0))
-                return;
-            if ((stepR > 0 && r > this.r1) || (stepR < 0 && r < this.r0))
-                return;
-            if (!stepC && (c < this.c0 || c > this.c1))
-                return;
-            if (!stepR && (r < this.r0 || r > this.r1))
-                return;
-        }
-    }
-    /**
-     * Segments whose bounds meet a box, each once, in {@link Blockers} order.
-     * @param x0 Box min x.
-     * @param y0 Box min y.
-     * @param x1 Box max x.
-     * @param y1 Box max y.
-     * @returns Their positions in {@link segs}.
-     */
-    near(x0, y0, x1, y1) {
-        const found = [];
-        this.stamp++;
-        this.cover(x0, y0, x1, y1, (key) => {
-            for (const i of this.cells.get(key) ?? []) {
-                if (this.seen[i] === this.stamp)
-                    continue;
-                this.seen[i] = this.stamp;
-                const seg = this.segs[i];
-                if (Math.max(seg[0], seg[2]) >= x0 &&
-                    Math.min(seg[0], seg[2]) <= x1 &&
-                    Math.max(seg[1], seg[3]) >= y0 &&
-                    Math.min(seg[1], seg[3]) <= y1)
-                    found.push(i);
-            }
-        });
-        return found.sort((a, b) => a - b);
-    }
-    /**
-     * Whether a segment crosses any blocker of one kind (exact `segmentsCross` on the candidates).
-     * @param seg The segment.
-     * @param from Blocker kind.
-     * @param except Destination whose own edges do not count.
-     * @returns True when one crosses it.
-     */
-    crosses(seg, from, except) {
-        return this.crossing(seg, from, except).length > 0;
-    }
-    /**
-     * The blockers of one kind a segment crosses (exact `segmentsCross` on the candidates).
-     * @param seg The segment.
-     * @param from Blocker kind.
-     * @param except Destination whose own edges do not count.
-     * @returns The blockers crossed.
-     */
-    crossing(seg, from, except) {
-        return this.near(Math.min(seg[0], seg[2]), Math.min(seg[1], seg[3]), Math.max(seg[0], seg[2]), Math.max(seg[1], seg[3]))
-            .filter((i) => this.from[i] === from &&
-            (except === undefined || this.owner[i] !== except) &&
-            segmentsCross(seg, this.segs[i]))
-            .map((i) => this.segs[i]);
-    }
-}
-/**
- * Walls and outlines whose bounds meet a box.
- * @param blockers The blockers.
- * @param box The box.
- * @returns Each segment with its owning destination; no owner for a wall.
- */
-export function blockersNear(blockers, box) {
-    const grid = blockerGrid(blockers);
-    const [x0, y0, x1, y1] = box;
-    return grid
-        .near(x0, y0, x1, y1)
-        .filter((i) => grid.from[i] !== BlockerKind.Gap)
-        .map((i) => grid.from[i] === BlockerKind.Solid
-        ? { seg: grid.segs[i], owner: grid.owner[i] }
-        : { seg: grid.segs[i] });
-}
-/** One grid per blockers object, built lazily. */
-const grids = new WeakMap();
-/**
- * The index of a blockers object, built once and kept with it.
- * @param blockers The blockers.
- * @returns Their index.
- */
-export function blockerGrid(blockers) {
-    let grid = grids.get(blockers);
-    if (!grid) {
-        grid = new SegmentGrid(blockers);
-        grids.set(blockers, grid);
-    }
-    return grid;
-}
-/**
- * Whether a segment crosses a wall, a closed doorway side or the outline of a destination nobody
- * walks through: the rule every network line keeps.
- * @param blockers The blockers.
- * @param seg The segment.
- * @returns True when it crosses one.
- */
-export function crossesBlocker(blockers, seg) {
-    const grid = blockerGrid(blockers);
-    return grid.crosses(seg, BlockerKind.Wall) || grid.crosses(seg, BlockerKind.Solid);
-}
-/**
- * What a run out of a destination may not cross, read once for the layer.
- * @param destinations Every destination on the layer.
- * @param walls The layer's wall segments.
- * @param doors The layer's doorways.
- * @param drawn The rest of each destination's drawing, by the destination's id.
- * @param walled Destinations entered through doorways: the walls they line stand in for them.
- * @param passes Wall spans an entrance's dock may cross, by the entrance's id.
- * @returns The blockers.
- */
-export function blockersOf(destinations, walls, doors, drawn = [], walled = new Set(), passes) {
-    return {
-        walls,
-        solid: [
-            ...destinations
-                .filter((d) => !d.crossable && d.polygon.length >= 3)
-                .map((d) => ({ id: d.id, edges: ringEdges(d.polygon) })),
-            ...drawn.map((block) => ({ id: block.id, edges: ringEdges(block.ring) })),
-        ],
-        gaps: doors.map((door) => door.gap),
-        walled,
-        ...(passes && { passes }),
-    };
-}
-/**
- * How far a ray runs before it meets a blocker, by exact intersection, and what it met.
- * @param ox Ray origin x.
- * @param oy Ray origin y.
- * @param nx Ray direction x.
- * @param ny Ray direction y.
- * @param ownId Destination the ray leaves.
- * @param own `'skip'` ignores its outline; `'ahead'` counts only the outline ahead of the start.
- * @param withGaps Whether a doorway gap stops the ray.
- * @param blockers What the ray may meet.
- * @returns The distance, or `Infinity` when the ray meets nothing.
- */
-export function freeRun(ox, oy, nx, ny, ownId, own, withGaps, blockers) {
-    let best = Infinity;
-    const hit = [0, 0];
-    // `from`: where hits start to count. A wall along the start face closes the ray; the own outline there
-    // is the face itself and does not.
-    const test = (seg, from) => {
-        if (!rayVsSegment(hit, ox, oy, nx, ny, seg[0], seg[1], seg[2], seg[3]))
-            return;
-        const [t, u] = hit;
-        if (u < -1e-9 || u > 1 + 1e-9 || t <= from)
-            return;
-        if (t < best)
-            best = Math.max(0, t);
-    };
-    const grid = blockerGrid(blockers);
-    // Cell by cell outward: a hit's segment is filed in the hit's cell, so once the best hit is nearer than
-    // the cell being left, no later cell holds a nearer one.
-    grid.alongRay(ox, oy, nx, ny, -2 * NODE_SNAP, (ids, leaves) => {
-        for (const i of ids) {
-            const seg = grid.segs[i];
-            const owner = grid.owner[i];
-            if (grid.from[i] === BlockerKind.Wall)
-                test(seg, -NODE_SNAP);
-            else if (grid.from[i] === BlockerKind.Gap) {
-                if (withGaps)
-                    test(seg, NODE_SNAP);
-            }
-            else if (owner !== ownId || own !== 'skip')
-                test(seg, owner === ownId ? NODE_SNAP : -NODE_SNAP);
-        }
-        return best < leaves - GRID_PAD;
-    });
-    return best;
-}

package/dist/lib/cell-array.d.ts

@@ -1,14 +0,0 @@
-/** The engine refused the memory a floor's raster needs: the floor is too large for this device. */
-export declare class CellsRefusedError extends Error {
-    constructor(length: number);
-}
-/**
- * A raster-sized typed array. An engine refuses a valid length only for want of memory, whatever its
- * message says, so any refusal of one throws {@link CellsRefusedError}; an invalid length is a bug and
- * its error passes through.
- * @param Ctor The typed array class.
- * @param length Its length, in cells.
- * @returns The zeroed array.
- */
-export declare function cellArray<T>(Ctor: new (length: number) => T, length: number): T;
-//# sourceMappingURL=cell-array.d.ts.map

package/dist/lib/cell-array.js

@@ -1,25 +0,0 @@
-/** The engine refused the memory a floor's raster needs: the floor is too large for this device. */
-export class CellsRefusedError extends Error {
-    constructor(length) {
-        super(`the engine refused a raster of ${length} cells`);
-        this.name = 'CellsRefusedError';
-    }
-}
-/**
- * A raster-sized typed array. An engine refuses a valid length only for want of memory, whatever its
- * message says, so any refusal of one throws {@link CellsRefusedError}; an invalid length is a bug and
- * its error passes through.
- * @param Ctor The typed array class.
- * @param length Its length, in cells.
- * @returns The zeroed array.
- */
-export function cellArray(Ctor, length) {
-    try {
-        return new Ctor(length);
-    }
-    catch (error) {
-        if (Number.isSafeInteger(length) && length >= 0)
-            throw new CellsRefusedError(length);
-        throw error;
-    }
-}

package/dist/lib/centering.d.ts

@@ -1,14 +0,0 @@
-/**
- * How far off the middle of its corridor each cell stands: 0 on the middle row, rising to 1 at the
- * walls — `1 - d / dmax`, where `d` is the cell's clearance and `dmax` the clearance of the ridge the
- * cell climbs to, which is half the corridor's width there. A corridor an even number of cells wide
- * has two middle rows; the one with the greater index is charged half the step to the next row, so
- * the minimum is one row.
- * @param width Grid width in cells.
- * @param height Grid height in cells.
- * @param clearance Meters from each cell to the nearest blocker, row-major.
- * @param ok 1 for a walkable cell.
- * @returns The offset per cell; 0 for a cell that is not walkable.
- */
-export declare function offCenter(width: number, height: number, clearance: Float32Array, ok: Uint8Array): Float32Array;
-//# sourceMappingURL=centering.d.ts.map

package/dist/lib/centering.js

@@ -1,88 +0,0 @@
-// Centering: how far off the middle of its corridor each router cell stands, read off the clearance
-// field alone. The middle is one row of cells, so two paths along one corridor lie on one line.
-/** Clearances are compared by the millimeter: chamfer sums differ by float noise only below it. */
-const QUANTUM = 1000;
-/**
- * How far off the middle of its corridor each cell stands: 0 on the middle row, rising to 1 at the
- * walls — `1 - d / dmax`, where `d` is the cell's clearance and `dmax` the clearance of the ridge the
- * cell climbs to, which is half the corridor's width there. A corridor an even number of cells wide
- * has two middle rows; the one with the greater index is charged half the step to the next row, so
- * the minimum is one row.
- * @param width Grid width in cells.
- * @param height Grid height in cells.
- * @param clearance Meters from each cell to the nearest blocker, row-major.
- * @param ok 1 for a walkable cell.
- * @returns The offset per cell; 0 for a cell that is not walkable.
- */
-export function offCenter(width, height, clearance, ok) {
-    const cells = width * height;
-    const level = new Int32Array(cells);
-    let top = 0;
-    for (let cell = 0; cell < cells; cell++) {
-        if (!ok[cell])
-            continue;
-        level[cell] = Math.round(clearance[cell] * QUANTUM);
-        top = Math.max(top, level[cell]);
-    }
-    // Cells from the highest clearance down, index order among equals: a counting sort.
-    const start = new Int32Array(top + 2);
-    for (let cell = 0; cell < cells; cell++)
-        if (ok[cell])
-            start[top - level[cell] + 1]++;
-    for (let i = 1; i < start.length; i++)
-        start[i] += start[i - 1];
-    const order = new Int32Array(start[top + 1]);
-    for (let cell = 0; cell < cells; cell++)
-        if (ok[cell])
-            order[start[top - level[cell]]++] = cell;
-    // Each cell climbs to its highest neighbor, and takes the ridge that one reached.
-    const ridge = new Int32Array(cells);
-    for (const cell of order) {
-        const x = cell % width;
-        const y = (cell - x) / width;
-        let up = -1;
-        for (let dy = -1; dy <= 1; dy++)
-            for (let dx = -1; dx <= 1; dx++) {
-                const nx = x + dx;
-                const ny = y + dy;
-                if ((!dx && !dy) || nx < 0 || ny < 0 || nx >= width || ny >= height)
-                    continue;
-                const near = ny * width + nx;
-                if (ok[near] && level[near] > level[cell] && (up < 0 || level[near] > level[up]))
-                    up = near;
-            }
-        ridge[cell] = up < 0 ? level[cell] : ridge[up];
-    }
-    const off = new Float32Array(cells);
-    // Whether the cell `step` away from `cell`, at `at` along its row or column, stands lower or is no floor.
-    const lower = (cell, at, limit, step) => at < 0 || at >= limit || !ok[cell + step] || level[cell + step] < level[cell];
-    /**
-     * What the second of two equal rows across a corridor is charged: half the step to the next row.
-     * @param cell The cell.
-     * @param at Its place along the axis across the corridor.
-     * @param limit The grid's size along that axis.
-     * @param step The index step along that axis.
-     * @returns The charge, 0 when the cell is not such a row's.
-     */
-    const secondRow = (cell, at, limit, step) => {
-        const twin = cell - step;
-        if (at < 1 || !ok[twin] || level[twin] !== level[cell])
-            return 0;
-        if (!lower(cell, at + 1, limit, step) || !lower(twin, at - 2, limit, -step))
-            return 0;
-        const next = at + 1 < limit && ok[cell + step] ? level[cell + step] : 0;
-        return (0.5 * (level[cell] - next)) / ridge[cell];
-    };
-    for (const cell of order) {
-        if (!ridge[cell])
-            continue;
-        const x = cell % width;
-        const y = (cell - x) / width;
-        off[cell] =
-            1 -
-                level[cell] / ridge[cell] +
-                secondRow(cell, x, width, 1) +
-                secondRow(cell, y, height, width);
-    }
-    return off;
-}

package/dist/lib/compile-layer.d.ts

@@ -1,41 +0,0 @@
-import type { NormalizeFacts } from './diagnostics.js';
-import type { BooleanOps } from './geom/boolean-ops.js';
-import type { RouteNetwork } from './graph-types.js';
-import type { SourceDestination, WayfindingLayerSource } from './types.js';
-import { type WalkableArea } from './walkable.js';
-/** One layer's stage artifacts. */
-interface CompiledLayer {
-    /** Globally unique layer id. */
-    readonly layer: string;
-    /** The destinations as the stages saw them, rings normalized and carved. */
-    readonly destinations: SourceDestination[];
-    /** Walkable area. */
-    readonly walkable: WalkableArea;
-    /** Route network. */
-    readonly network: RouteNetwork;
-    /** What normalization did to the drawing, for the diagnostics. */
-    readonly facts: NormalizeFacts;
-}
-/** Options of one layer's compile. */
-interface CompileLayerOptions {
-    /** A walkable area already built for this layer; the stage is skipped. */
-    readonly walkable?: WalkableArea;
-    /** Called as each stage finishes; `cached` when it was handed its artifact. */
-    readonly onStage?: (stage: 'walkable' | 'network', cached: boolean) => void;
-}
-/**
- * One layer's pipeline: walkable area, then route network.
- * @param source One layer's walls and destinations.
- * @param ops Polygon boolean backend.
- * @param options A ready walkable area and the stage callback.
- * @returns The layer's walkable area and route network.
- */
-export declare function compileLayer(source: WayfindingLayerSource, ops: BooleanOps, options?: CompileLayerOptions): CompiledLayer;
-/**
- * Destinations sorted by id, then outline, so input order does not change the network.
- * @param destinations The destinations as given.
- * @returns A sorted copy.
- */
-export declare function inCanonicalOrder(destinations: readonly SourceDestination[]): SourceDestination[];
-export {};
-//# sourceMappingURL=compile-layer.d.ts.map