@expofp/wayfinding-compiler 0.0.0-bootstrap.0

package/dist/lib/openings.d.ts

@@ -0,0 +1,54 @@
+import { type Doorway } from './doorways.js';
+import type { Ring, Segment, Vec2 } from './geom/types.js';
+import type { PreparedWalls } from './geom/walls.js';
+import type { RouteNetworkDestination, Unreached } from './graph-types.js';
+/** How far from a wall an entrance outside the building still opens it, in meters. */
+export declare const ENTRANCE_REACH = 10;
+/** One opening: where an entrance's dock goes through a wall, and the way in it makes. */
+export interface Opening {
+    /** The entrance's id. */
+    readonly id: string;
+    /** Where the dock crosses the wall: the middle of the span, on the wall's line. */
+    readonly at: Vec2;
+    /** The wall span the dock may cross, jamb to jamb. */
+    readonly span: Segment;
+    /**
+     * The way in as the network sees it: a doorway standing on the floor just past the wall, its
+     * normal out of the entrance onto the floor.
+     */
+    readonly door: Doorway;
+    /**
+     * Inside the entrance's bounds; or, for an entrance outside the building, a doorway the walls leave
+     * in reach, else the nearest wall.
+     */
+    readonly by: 'crossing' | 'doorway' | 'nearby';
+    /** `doorway` and `nearby` only: how far the entrance stands from it, in meters. */
+    readonly distance?: number;
+}
+/** The entrances' openings, and the entrances outside the building that got none. */
+interface EntranceOpenings {
+    /** The openings made, in destination order; one per side of a wall with floor on both. */
+    readonly openings: Opening[];
+    /** Entrances outside the building that got no opening, with what was found. */
+    readonly unreached: Unreached[];
+}
+/**
+ * The openings the entrances make. The walls stay whole; an opening says where an entrance's dock
+ * may go through one.
+ *
+ * An entrance across a wall opens every wall piece inside its bounds, through its middle: pieces on
+ * one line are one opening, and it opens onto each side with floor behind the wall. An entrance
+ * outside the building with no such piece goes in through the doorway the walls leave nearest its
+ * middle within {@link ENTRANCE_REACH}, with floor behind it and no wall between; with none, it opens
+ * the nearest wall in reach — nearest to its middle, with floor and a person's clearance behind it,
+ * and no other wall between — where its bounds project onto the wall. An opening narrower than a
+ * person is not made.
+ * @param prepared The layer's walls, read once.
+ * @param outline The building's outline.
+ * @param destinations The layer's destinations, rings as given.
+ * @param outside Whether a destination stands outside the building.
+ * @returns The openings, and the entrances outside that got none.
+ */
+export declare function entranceOpenings(prepared: PreparedWalls, outline: readonly Ring[], destinations: readonly RouteNetworkDestination[], outside: (d: RouteNetworkDestination) => boolean): EntranceOpenings;
+export {};
+//# sourceMappingURL=openings.d.ts.map

package/dist/lib/openings.js

@@ -0,0 +1,387 @@
+// Entrance openings: where an entrance's dock goes through a wall — the wall pieces inside its bounds,
+// or the nearest wall with floor behind it when the entrance stands outside the building. The walls
+// stay whole: each opening is a doorway the entrance owns, standing on the floor just past the wall,
+// and the dock from it crosses the wall only inside the opening's span.
+import { ON_WALL_LINE } from './doorways.js';
+import { cleanRing } from './geom/normalize.js';
+import { pointInRing, pointSegmentDistance, rayVsSegment, ringEdges, segmentsCross, vertexMean, } from './geom/primitives.js';
+import { MIN_PASS, NETWORK_SIZES } from './network-sizes.js';
+import { inBuilding, WALL_HALF_WIDTH } from './walkable.js';
+/** How far from a wall an entrance outside the building still opens it, in meters. */
+export const ENTRANCE_REACH = 10;
+/** How far behind a wall the floor is looked for: past the wall's thickness, half a person in. */
+const BEHIND = WALL_HALF_WIDTH + MIN_PASS;
+/**
+ * The shares of a segment that lie inside a ring: cut at every edge crossing, a share is inside when
+ * its middle is.
+ * @param a Segment start.
+ * @param b Segment end.
+ * @param ring The ring.
+ * @returns The inside shares as `[t0, t1]` along the segment.
+ */
+function insideShares(a, b, ring) {
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const cuts = [0, 1];
+    const hit = [0, 0];
+    for (const [x0, y0, x1, y1] of ringEdges(ring)) {
+        if (!rayVsSegment(hit, a[0], a[1], dx, dy, x0, y0, x1, y1))
+            continue;
+        const [t, u] = hit;
+        if (t > 0 && t < 1 && u >= 0 && u <= 1)
+            cuts.push(t);
+    }
+    cuts.sort((p, q) => p - q);
+    const shares = [];
+    for (let i = 0; i + 1 < cuts.length; i++) {
+        const [t0, t1] = [cuts[i], cuts[i + 1]];
+        if (t1 - t0 < 1e-9)
+            continue;
+        const t = (t0 + t1) / 2;
+        if (pointInRing(ring, [a[0] + dx * t, a[1] + dy * t]))
+            shares.push([t0, t1]);
+    }
+    return shares;
+}
+/**
+ * The pieces grouped by the line they lie on: a wall drawn with many vertices, or twice, is one line.
+ * @param pieces The pieces inside one entrance's bounds.
+ * @returns The groups, each led by its longest piece.
+ */
+function byLine(pieces) {
+    const groups = [];
+    const onLine = (lead, piece) => [piece.a, piece.b].every(([x, y]) => distanceToLine(x, y, lead.a, lead.b) <= ON_WALL_LINE);
+    for (const piece of [...pieces].sort((p, q) => length(q) - length(p))) {
+        const group = groups.find((g) => onLine(g[0], piece));
+        if (group)
+            group.push(piece);
+        else
+            groups.push([piece]);
+    }
+    return groups;
+}
+/**
+ * How far the wall a segment is part of runs along the segment's line, both ways: the pieces on that
+ * line meeting end to end are one wall, however many vertices draw it.
+ * @param line The segment's line, from its first end.
+ * @param len The segment's length.
+ * @param segments Every wall segment of the floor.
+ * @returns The wall's ends, as distances along the line.
+ */
+function spanAlong(line, len, segments) {
+    const [ox, oy] = line.origin;
+    const onLine = ([x, y]) => Math.abs(line.ux * (y - oy) - line.uy * (x - ox)) <= ON_WALL_LINE;
+    const along = ([x, y]) => (x - ox) * line.ux + (y - oy) * line.uy;
+    const pieces = [];
+    for (const [x0, y0, x1, y1] of segments) {
+        if (!onLine([x0, y0]) || !onLine([x1, y1]))
+            continue;
+        const a = along([x0, y0]);
+        const b = along([x1, y1]);
+        pieces.push([Math.min(a, b), Math.max(a, b)]);
+    }
+    let [lo, hi] = [0, len];
+    for (let grown = true; grown;) {
+        grown = false;
+        for (const [a, b] of pieces) {
+            if (a > hi + ON_WALL_LINE || b < lo - ON_WALL_LINE || (a >= lo && b <= hi))
+                continue;
+            lo = Math.min(lo, a);
+            hi = Math.max(hi, b);
+            grown = true;
+        }
+    }
+    return [lo, hi];
+}
+/**
+ * Distance from a point to the line through two points.
+ * @param x Point x.
+ * @param y Point y.
+ * @param a One point on the line.
+ * @param b Another.
+ * @returns The distance.
+ */
+function distanceToLine(x, y, a, b) {
+    const len = Math.hypot(b[0] - a[0], b[1] - a[1]) || 1;
+    return Math.abs(((b[0] - a[0]) * (y - a[1]) - (b[1] - a[1]) * (x - a[0])) / len);
+}
+/**
+ * A piece's length.
+ * @param piece The piece.
+ * @returns Its length.
+ */
+function length(piece) {
+    return Math.hypot(piece.b[0] - piece.a[0], piece.b[1] - piece.a[1]);
+}
+/**
+ * An opening on a wall's line, from `lo` to `hi` along it, onto the side the sign names.
+ * @param id The entrance's id.
+ * @param line The wall's line.
+ * @param lo Where the span starts along the line.
+ * @param hi Where it ends.
+ * @param side Which side of the line the floor is on: the sign of the line's left normal.
+ * @param by How the wall was found.
+ * @param distance `nearby` only: how far the entrance stands from the wall.
+ * @returns The opening.
+ */
+function opening(id, line, lo, hi, side, by, distance) {
+    const { origin, ux, uy } = line;
+    const mid = (lo + hi) / 2;
+    const at = (t) => [origin[0] + ux * t, origin[1] + uy * t];
+    const nx = -uy * side;
+    const ny = ux * side;
+    const shift = ([x, y]) => [
+        +(x + nx * BEHIND).toFixed(2),
+        +(y + ny * BEHIND).toFixed(2),
+    ];
+    const [a, b, m] = [at(lo), at(hi), at(mid)];
+    const [ga, gb] = [shift(a), shift(b)];
+    return {
+        id,
+        at: [+m[0].toFixed(2), +m[1].toFixed(2)],
+        span: [a[0], a[1], b[0], b[1]],
+        door: { gap: [ga[0], ga[1], gb[0], gb[1]], mid: shift(m), nx, ny },
+        by,
+        ...(distance !== undefined && { distance }),
+    };
+}
+/**
+ * Distance between a ring and a segment that do not cross: from the nearer of the ring's vertices to
+ * the segment, or of the segment's ends to the ring's edges.
+ * @param ring The ring.
+ * @param seg The segment.
+ * @returns The distance.
+ */
+function ringSegmentDistance(ring, seg) {
+    let best = Infinity;
+    for (const [x, y] of ring)
+        best = Math.min(best, pointSegmentDistance(x, y, ...seg));
+    for (const edge of ringEdges(ring))
+        for (const [x, y] of [
+            [seg[0], seg[1]],
+            [seg[2], seg[3]],
+        ])
+            best = Math.min(best, pointSegmentDistance(x, y, ...edge));
+    return best;
+}
+/**
+ * Whether two segments are the same piece of wall, by their ends.
+ * @param a One segment.
+ * @param b The other.
+ * @returns True when the ends coincide.
+ */
+function sameSegment(a, b) {
+    return a.every((v, i) => v === b[i]);
+}
+/**
+ * How far a ray from a point on a wall runs before it meets another wall: the wall it leaves, and
+ * anything within the wall's own thickness, does not count.
+ * @param from Where the ray starts.
+ * @param dx Ray direction x.
+ * @param dy Ray direction y.
+ * @param segments What it may meet.
+ * @param skip The wall the ray leaves.
+ * @returns The distance, or `Infinity`.
+ */
+function freeAhead(from, dx, dy, segments, skip) {
+    const hit = [0, 0];
+    let best = Infinity;
+    for (const seg of segments) {
+        if (sameSegment(seg, skip) || !rayVsSegment(hit, from[0], from[1], dx, dy, ...seg))
+            continue;
+        const [t, u] = hit;
+        if (u >= 0 && u <= 1 && t > WALL_HALF_WIDTH && t < best)
+            best = t;
+    }
+    return best;
+}
+/**
+ * The doorways the walls leave in the building outlines: the stretches of an outline's edges no wall
+ * runs along, at least a person wide.
+ * @param outline The building's outline.
+ * @param segments The walls.
+ * @returns The gaps, edge by edge.
+ */
+function outlineGaps(outline, segments) {
+    const gaps = [];
+    for (const ring of outline) {
+        for (const edge of ringEdges(ring)) {
+            const len = Math.hypot(edge[2] - edge[0], edge[3] - edge[1]);
+            if (len < 2 * MIN_PASS)
+                continue;
+            const line = {
+                origin: [edge[0], edge[1]],
+                ux: (edge[2] - edge[0]) / len,
+                uy: (edge[3] - edge[1]) / len,
+            };
+            const along = (x, y) => (x - line.origin[0]) * line.ux + (y - line.origin[1]) * line.uy;
+            const off = (x, y) => Math.abs((x - line.origin[0]) * line.uy - (y - line.origin[1]) * line.ux);
+            const at = (t) => [line.origin[0] + line.ux * t, line.origin[1] + line.uy * t];
+            const covered = [];
+            for (const [x0, y0, x1, y1] of segments) {
+                if (off(x0, y0) > ON_WALL_LINE || off(x1, y1) > ON_WALL_LINE)
+                    continue;
+                const [a, b] = [along(x0, y0), along(x1, y1)].sort((p, q) => p - q);
+                if (b > 0 && a < len)
+                    covered.push([Math.max(0, a), Math.min(len, b)]);
+            }
+            covered.sort((p, q) => p[0] - q[0] || p[1] - q[1]);
+            let from = 0;
+            for (const [start, end] of [...covered, [len, len]]) {
+                if (start - from >= 2 * MIN_PASS) {
+                    const [a, b] = [at(from), at(start)];
+                    gaps.push({ line, lo: from, hi: start, segment: [a[0], a[1], b[0], b[1]] });
+                }
+                from = Math.max(from, end);
+            }
+        }
+    }
+    return gaps;
+}
+/**
+ * The openings the entrances make. The walls stay whole; an opening says where an entrance's dock
+ * may go through one.
+ *
+ * An entrance across a wall opens every wall piece inside its bounds, through its middle: pieces on
+ * one line are one opening, and it opens onto each side with floor behind the wall. An entrance
+ * outside the building with no such piece goes in through the doorway the walls leave nearest its
+ * middle within {@link ENTRANCE_REACH}, with floor behind it and no wall between; with none, it opens
+ * the nearest wall in reach — nearest to its middle, with floor and a person's clearance behind it,
+ * and no other wall between — where its bounds project onto the wall. An opening narrower than a
+ * person is not made.
+ * @param prepared The layer's walls, read once.
+ * @param outline The building's outline.
+ * @param destinations The layer's destinations, rings as given.
+ * @param outside Whether a destination stands outside the building.
+ * @returns The openings, and the entrances outside that got none.
+ */
+export function entranceOpenings(prepared, outline, destinations, outside) {
+    const openings = [];
+    const unreached = [];
+    const floorAt = ({ door }) => inBuilding(outline, door.mid);
+    let gaps = null;
+    for (const d of destinations) {
+        if (!d.entrance)
+            continue;
+        const ring = cleanRing(d.dock ?? d.polygon);
+        if (ring.length < 3)
+            continue;
+        const pieces = [];
+        for (const [x0, y0, x1, y1] of prepared.segments)
+            for (const [t0, t1] of insideShares([x0, y0], [x1, y1], ring))
+                pieces.push({
+                    a: [x0 + (x1 - x0) * t0, y0 + (y1 - y0) * t0],
+                    b: [x0 + (x1 - x0) * t1, y0 + (y1 - y0) * t1],
+                });
+        let made = 0;
+        for (const group of byLine(pieces)) {
+            const lead = group[0];
+            const len = length(lead);
+            const line = {
+                origin: lead.a,
+                ux: (lead.b[0] - lead.a[0]) / len,
+                uy: (lead.b[1] - lead.a[1]) / len,
+            };
+            const along = group.flatMap((p) => [p.a, p.b].map(([x, y]) => (x - lead.a[0]) * line.ux + (y - lead.a[1]) * line.uy));
+            const lo = Math.min(...along);
+            const hi = Math.max(...along);
+            if (hi - lo < 2 * MIN_PASS)
+                continue;
+            for (const side of [1, -1]) {
+                const onto = opening(d.id, line, lo, hi, side, 'crossing');
+                if (!floorAt(onto))
+                    continue;
+                openings.push(onto);
+                made++;
+            }
+        }
+        if (made || !outside(d))
+            continue;
+        const center = vertexMean(ring);
+        // Outside the building and across no wall: through the doorway the walls leave first, so a route
+        // goes through a wall only where there is no way past it.
+        let doorway;
+        gaps ??= outlineGaps(outline, prepared.segments);
+        for (const { line, lo, hi, segment } of gaps) {
+            const distance = ringSegmentDistance(ring, segment);
+            if (distance > ENTRANCE_REACH)
+                continue;
+            const fromMiddle = pointSegmentDistance(center[0], center[1], ...segment);
+            const side = -line.uy * (center[0] - line.origin[0]) + line.ux * (center[1] - line.origin[1]) > 0
+                ? -1
+                : 1;
+            const candidate = opening(d.id, line, lo, hi, side, 'doorway', +distance.toFixed(2));
+            const sight = [candidate.at[0], candidate.at[1], center[0], center[1]];
+            if ((doorway && fromMiddle >= doorway.fromMiddle) ||
+                !floorAt(candidate) ||
+                prepared.segments.some((wall) => segmentsCross(sight, wall)))
+                continue;
+            doorway = { opening: candidate, fromMiddle };
+        }
+        if (doorway) {
+            openings.push(doorway.opening);
+            continue;
+        }
+        // With no doorway in reach: the nearest wall with floor behind it.
+        const candidates = [];
+        let nearest = Infinity;
+        for (const seg of prepared.segments) {
+            const distance = ringSegmentDistance(ring, seg);
+            nearest = Math.min(nearest, distance);
+            if (distance <= ENTRANCE_REACH)
+                candidates.push({
+                    seg,
+                    distance,
+                    fromMiddle: pointSegmentDistance(center[0], center[1], ...seg),
+                    index: candidates.length,
+                });
+        }
+        // The wall under the entrance's middle first: a wide entrance may touch a side wall with a corner.
+        // Ties keep the walls' order, which is canonical.
+        candidates.sort((p, q) => p.fromMiddle - q.fromMiddle || p.index - q.index);
+        let found;
+        for (const { seg, distance } of candidates) {
+            const origin = [seg[0], seg[1]];
+            const len = Math.hypot(seg[2] - seg[0], seg[3] - seg[1]);
+            if (!len)
+                continue;
+            const line = { origin, ux: (seg[2] - seg[0]) / len, uy: (seg[3] - seg[1]) / len };
+            const project = ([x, y]) => (x - origin[0]) * line.ux + (y - origin[1]) * line.uy;
+            // The whole wall the segment is part of: a wall drawn with many vertices is one.
+            const [first, last] = spanAlong(line, len, prepared.segments);
+            const clamp = (v) => Math.max(first, Math.min(last, v));
+            const c = clamp(project(center));
+            const along = ring.map(project);
+            // The bounds' shadow on the wall, at least a person wide around the entrance's middle.
+            const lo = clamp(Math.min(...along, c - BEHIND));
+            const hi = clamp(Math.max(...along, c + BEHIND));
+            if (hi - lo < 2 * MIN_PASS)
+                continue;
+            // The side away from the entrance: the left normal's sign that points from the entrance over
+            // the wall.
+            const side = -line.uy * (center[0] - origin[0]) + line.ux * (center[1] - origin[1]) > 0 ? -1 : 1;
+            const candidate = opening(d.id, line, lo, hi, side, 'nearby', +distance.toFixed(2));
+            const { at, door } = candidate;
+            // Floor with room for a person behind the wall, and no other wall between the entrance and the
+            // opening.
+            const sight = [at[0], at[1], center[0], center[1]];
+            if (!floorAt(candidate) ||
+                freeAhead(at, door.nx, door.ny, prepared.segments, seg) < NETWORK_SIZES.clear ||
+                prepared.segments.some((other) => !sameSegment(other, seg) && segmentsCross(sight, other)))
+                continue;
+            found = candidate;
+            break;
+        }
+        if (found)
+            openings.push(found);
+        else
+            unreached.push({
+                id: d.id,
+                reason: 'no-floor',
+                outside: true,
+                ...(isFinite(nearest) && { nearestWall: +nearest.toFixed(2) }),
+                ...(candidates.length > 0 && { floorBehind: false }),
+            });
+    }
+    return { openings, unreached };
+}

package/dist/lib/place-path.d.ts

@@ -0,0 +1,47 @@
+import { type Frame } from './geom/frames.js';
+import type { Segment, Vec2 } from './geom/types.js';
+import type { NetworkSizes } from './network-sizes.js';
+import type { NetworkStore } from './network-store.js';
+import type { Router } from './router.js';
+import { type Placement } from './runs.js';
+/** A stub tip a path ends at: the point and the stub's direction. */
+export interface TipTarget {
+    /** The tip. */
+    readonly at: Vec2;
+    /** Unit direction of the stub, out of its destination. */
+    readonly normal: Vec2;
+    /** The direction the stub's destination is drawn in. */
+    readonly frame: Frame;
+}
+/** What laying a path shares with the growth: the network, the raster, and where the tips stand. */
+interface PathLaying {
+    /** The network; extended in place. */
+    readonly store: NetworkStore;
+    /** The raster router the paths were walked on. */
+    readonly router: Router;
+    /** Network sizes. */
+    readonly cfg: NetworkSizes;
+    /** What the runs are laid on. */
+    readonly place: Placement;
+    /** The tip standing at a cell a path may end at. */
+    readonly tipAt: ReadonlyMap<number, TipTarget>;
+    /** 1 for each router cell a network line passes: where a raster path may end. */
+    readonly onNetwork: Uint8Array;
+    /** Adds a segment to the network and claims the cells it passes. */
+    readonly add: (seg: Segment) => void;
+    /** Claims cells for a segment, so a path ending in one of them ties to it; its own cells by default. */
+    readonly claim: (seg: Segment, cells?: Iterable<number>) => void;
+}
+/**
+ * Lays a path of cells, `head` first, its ends tied to what stands at them: the tip given, or the
+ * network line claiming the cell. False when an end could not be tied; nothing is laid then.
+ */
+export type LayPath = (cells: readonly number[], head: TipTarget | null, free?: (seg: Segment) => boolean) => boolean;
+/**
+ * Builds the function that lays one path.
+ * @param shared What it shares with the growth.
+ * @returns The function.
+ */
+export declare function createPathPlacer(shared: PathLaying): LayPath;
+export {};
+//# sourceMappingURL=place-path.d.ts.map