@pascal-app/core 1.0.6 → 1.1.0

package/dist/agent-operations/wall-face-defaults.js

@@ -0,0 +1,229 @@
+import { getLevelDisplayName } from '../lib/level-name.js';
+import { resolveWallExteriorSide, wallAssemblyExposedStructure, wallAssemblyFinishRef, } from '../systems/wall/wall-assembly.js';
+import { getWallCurveFrameAt, isCurvedWall } from '../systems/wall/wall-curve.js';
+import { describeWallFaceFinishes, getWallLevelZones, getWallZoneSpans, } from '../systems/wall/wall-finish.js';
+import { calculateLevelMiters, DEFAULT_WALL_HEIGHT, getWallPlanFootprint, } from '../systems/wall/wall-footprint.js';
+import { getWallFaceOffsets } from '../systems/wall/wall-frame.js';
+import { distanceToSegment, pointInPolygon } from './plan-geometry.js';
+import { levelRole, levelsOf, nodesOnLevel } from './scene-queries.js';
+/** A default stretch shorter than this is a sliver at a join, not a face. */
+const MIN_STRETCH_M = 0.1;
+/** A point of a face this far inside another wall's outline is in its body; closer is on its surface. */
+const BURIED_MARGIN_M = 0.01;
+/** How far in front of a face a probe looks for the room it stands in. */
+const LOOK_AHEAD_M = 0.05;
+/** Another wall buries a face only when it is not lower than the wall by more than this. */
+const HEIGHT_SLACK_M = 0.05;
+const length = (stretches) => stretches.reduce((sum, [u0, u1]) => sum + u1 - u0, 0);
+function merged(intervals) {
+    const out = [];
+    for (const [u0, u1] of [...intervals].sort((p, q) => p[0] - q[0])) {
+        const last = out.at(-1);
+        if (last && u0 <= last[1] + 1e-9)
+            last[1] = Math.max(last[1], u1);
+        else
+            out.push([u0, u1]);
+    }
+    return out;
+}
+/** `from` less every `cut`, as intervals longer than `MIN_STRETCH_M`. */
+function subtract(from, cut) {
+    const holes = merged(cut);
+    const out = [];
+    for (const [a, b] of from) {
+        let reach = a;
+        for (const [h0, h1] of holes) {
+            if (h1 <= reach || h0 >= b)
+                continue;
+            if (h0 > reach)
+                out.push([reach, h0]);
+            reach = Math.max(reach, h1);
+        }
+        if (reach < b)
+            out.push([reach, b]);
+    }
+    return out.filter(([u0, u1]) => u1 - u0 >= MIN_STRETCH_M);
+}
+function bodiesOf(walls) {
+    const usable = walls.filter((wall) => Array.isArray(wall.start) &&
+        Array.isArray(wall.end) &&
+        wall.wallType !== 'curtain' &&
+        wall.visible !== false);
+    let miters;
+    try {
+        miters = calculateLevelMiters(usable);
+    }
+    catch {
+        return [];
+    }
+    return usable.flatMap((wall) => {
+        const ring = getWallPlanFootprint(wall, miters).map((point) => [point.x, point.y]);
+        if (ring.length < 3)
+            return [];
+        const xs = ring.map(([x]) => x);
+        const zs = ring.map(([, z]) => z);
+        return [
+            { wall, ring, bounds: [Math.min(...xs), Math.min(...zs), Math.max(...xs), Math.max(...zs)] },
+        ];
+    });
+}
+const heightOf = (wall) => wall.height ?? DEFAULT_WALL_HEIGHT;
+/** Whether a point is in a ring's body: inside it and more than `BURIED_MARGIN_M` from its surface. */
+function inBody(point, ring) {
+    if (!pointInPolygon(point, [...ring], false))
+        return false;
+    for (let index = 0; index < ring.length; index += 1)
+        if (distanceToSegment(point, ring[index], ring[(index + 1) % ring.length]) < BURIED_MARGIN_M)
+            return false;
+    return true;
+}
+/**
+ * The stretches of a straight wall's face line (metres along the wall) that lie inside the body of
+ * another wall of the level, one at least as high: a face there is covered, not seen.
+ */
+function buriedStretches(wall, offset, bodies) {
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const run = Math.hypot(dx, dz);
+    if (run < 1e-9)
+        return [];
+    const nx = -dz / run;
+    const nz = dx / run;
+    const p0 = [wall.start[0] + nx * offset, wall.start[1] + nz * offset];
+    const d = [dx, dz];
+    const box = [
+        Math.min(p0[0], p0[0] + dx),
+        Math.min(p0[1], p0[1] + dz),
+        Math.max(p0[0], p0[0] + dx),
+        Math.max(p0[1], p0[1] + dz),
+    ];
+    const cross = (ax, ay, bx, by) => ax * by - ay * bx;
+    const buried = [];
+    for (const body of bodies) {
+        if (body.wall.id === wall.id || heightOf(body.wall) < heightOf(wall) - HEIGHT_SLACK_M)
+            continue;
+        const [x0, z0, x1, z1] = body.bounds;
+        if (x1 < box[0] - BURIED_MARGIN_M || x0 > box[2] + BURIED_MARGIN_M)
+            continue;
+        if (z1 < box[1] - BURIED_MARGIN_M || z0 > box[3] + BURIED_MARGIN_M)
+            continue;
+        const cuts = [0, 1];
+        for (let index = 0; index < body.ring.length; index += 1) {
+            const q0 = body.ring[index];
+            const q1 = body.ring[(index + 1) % body.ring.length];
+            const e = [q1[0] - q0[0], q1[1] - q0[1]];
+            const denominator = cross(d[0], d[1], e[0], e[1]);
+            if (Math.abs(denominator) < 1e-12)
+                continue;
+            const w = [q0[0] - p0[0], q0[1] - p0[1]];
+            const t = cross(w[0], w[1], e[0], e[1]) / denominator;
+            const s = cross(w[0], w[1], d[0], d[1]) / denominator;
+            if (s >= 0 && s <= 1 && t > 0 && t < 1)
+                cuts.push(t);
+        }
+        cuts.sort((p, q) => p - q);
+        for (let index = 0; index + 1 < cuts.length; index += 1) {
+            const [t0, t1] = [cuts[index], cuts[index + 1]];
+            if ((t1 - t0) * run < 1e-4)
+                continue;
+            const middle = [p0[0] + d[0] * ((t0 + t1) / 2), p0[1] + d[1] * ((t0 + t1) / 2)];
+            if (inBody(middle, body.ring))
+                buried.push([t0 * run, t1 * run]);
+        }
+    }
+    return merged(buried);
+}
+const rounded = (value) => Math.round(value * 100) / 100;
+function pointAlong(wall, u) {
+    const run = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+    const { point } = getWallCurveFrameAt(wall, run > 0 ? u / run : 0);
+    return [rounded(point.x), rounded(point.y)];
+}
+const FACES = ['a', 'b'];
+/**
+ * Every wall face of the scene read for the default finish. Walls that are hidden, curtain walls and
+ * walls on a roof level are left out; a scene whose walls cannot be walked reads as no faces.
+ */
+export function readWallFaces(nodes) {
+    const reading = { faces: 0, metres: 0, defaults: [] };
+    for (const level of levelsOf(nodes)) {
+        if (levelRole(nodes, level).role === 'roof')
+            continue;
+        const walls = nodesOnLevel(nodes, level.id).filter((node) => node.type === 'wall' &&
+            node.visible !== false &&
+            node.wallType !== 'curtain' &&
+            Array.isArray(node.start) &&
+            Array.isArray(node.end));
+        if (!walls.length)
+            continue;
+        const bodies = bodiesOf(walls);
+        const rooms = getWallLevelZones({ parentId: level.id }, nodes).filter((zone) => zone.spaceRole === 'room' && zone.polygon.length >= 3);
+        const levelName = getLevelDisplayName(level);
+        for (const wall of walls) {
+            const run = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+            if (run < MIN_STRETCH_M)
+                continue;
+            const finishes = describeWallFaceFinishes(wall, nodes);
+            const offsets = getWallFaceOffsets(wall);
+            const spans = getWallZoneSpans(wall, rooms);
+            const exteriorSide = resolveWallExteriorSide(wall);
+            const clad = wallAssemblyFinishRef(wall) !== null || wallAssemblyExposedStructure(wall) !== null;
+            for (const face of FACES) {
+                const buried = isCurvedWall(wall) ? [] : buriedStretches(wall, offsets[face], bodies);
+                const visible = subtract([[0, run]], buried);
+                const seen = length(visible);
+                if (seen < MIN_STRETCH_M)
+                    continue;
+                reading.faces += 1;
+                reading.metres += seen;
+                const written = wall.finishScripts?.[face] !== undefined ||
+                    (clad && exteriorSide !== null && (exteriorSide === 1 ? 'a' : 'b') === face);
+                if (written)
+                    continue;
+                const own = finishes[face].stretches
+                    .filter((stretch) => stretch.source === 'wall_face' && stretch.chain === 'default')
+                    .map((stretch) => [stretch.u0, stretch.u1]);
+                const painted = finishes[face].paintRegions.map((region) => [region.u0 ?? 0, region.u1 ?? run]);
+                const stretches = subtract(subtract(own, painted), buried);
+                if (!stretches.length)
+                    continue;
+                const first = stretches[0][0];
+                const last = stretches.at(-1)[1];
+                const faceSpans = spans.filter((span) => span.face === face &&
+                    stretches.some(([u0, u1]) => span.t1 * run > u0 + 0.02 && span.t0 * run < u1 - 0.02));
+                const facing = [...new Set(faceSpans.map((span) => nodes[span.zoneId].name))];
+                const standsIn = facing.length
+                    ? []
+                    : roomsStoodIn(wall, face, offsets[face], stretches, rooms);
+                reading.defaults.push({
+                    wallId: wall.id,
+                    wallName: wall.name ?? wall.id,
+                    levelId: level.id,
+                    levelName,
+                    face,
+                    metres: length(stretches),
+                    stretches,
+                    from: pointAlong(wall, first),
+                    to: pointAlong(wall, last),
+                    facing,
+                    standsIn,
+                });
+            }
+        }
+    }
+    return reading;
+}
+/** The rooms a probe a little in front of the stretches' middle lies in. */
+function roomsStoodIn(wall, face, offset, stretches, rooms) {
+    const widest = [...stretches].sort((p, q) => q[1] - q[0] - (p[1] - p[0]))[0];
+    const run = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const [x, z] = pointAlong(wall, (widest[0] + widest[1]) / 2);
+    const ahead = offset + (face === 'a' ? LOOK_AHEAD_M : -LOOK_AHEAD_M);
+    const probe = [x + (-dz / run) * ahead, z + (dx / run) * ahead];
+    return rooms
+        .filter((zone) => pointInPolygon(probe, zone.polygon) &&
+        !(zone.holes ?? []).some((hole) => pointInPolygon(probe, hole, false)))
+        .map((zone) => zone.name);
+}

package/dist/agent-operations/wall-joins.d.ts

@@ -0,0 +1,119 @@
+import type { AnyNode } from '../schema/index.js';
+/**
+ * Two facts about where straight walls of one level meet, for `verify_scene`:
+ *
+ * - `wall_end_short`: a wall end that stops short of another wall's body, leaving daylight
+ *   between them. The room graph (`wall_open_end`) elects an end within 8 cm of a body as joined
+ *   and says nothing of it; the floor, the finish and the render show the slot.
+ * - `wall_nearly_aligned`: a wall that continues another a few degrees off its axis, or sits
+ *   between two aligned walls a few degrees off their line (a short wall holding a door,
+ *   drawn skewed). A wall angled by design turns more than this and does not qualify.
+ *
+ * Measured on the walls' bodies (the stored line shifted by the justification, a thickness wide),
+ * straight walls only: a curved wall has no single axis and no single end cap.
+ */
+type WallNode = AnyNode & {
+    type: 'wall';
+};
+type Pt = readonly [number, number];
+/** An end that stops this far short of a body or more is a gap; nearer is a joint. */
+export declare const END_SHORT_MIN_M = 0.03;
+/** Further than this the end is a free end that happens to stand near a wall, not a missed joint. */
+export declare const END_SHORT_MAX_M = 0.25;
+/** A turn smaller than this is a straight line drawn with noise; a larger one up to the maximum is the finding. */
+export declare const ALIGN_MIN_DEG = 0.5;
+/** A turn larger than this is an angle somebody drew (a bay, an angled wing). */
+export declare const ALIGN_MAX_DEG = 6;
+/** A skew that moves the wall's far end less than this off its neighbour's line is within drawing tolerance, and is not said. */
+export declare const ALIGN_MIN_OFFSET_M = 0.02;
+export type WallBody = {
+    id: string;
+    name: string;
+    /** The body's centre line, start to end. */
+    a: Pt;
+    b: Pt;
+    length: number;
+    /** Unit direction a to b. */
+    ux: number;
+    uy: number;
+    thickness: number;
+};
+export type WallEndShortIssue = {
+    type: 'wall_end_short';
+    message: string;
+    severity: 'warning';
+    levelId: string;
+    wallId: string;
+    wallName: string;
+    end: 'start' | 'end';
+    otherWallId: string;
+    otherWallName: string;
+    /** Daylight between the end and the other wall's body, in metres. */
+    gap: number;
+    /** Where the end is, [x, z]. */
+    at: [number, number];
+    nodeIds: [string, string];
+};
+export type WallNearlyAlignedIssue = {
+    type: 'wall_nearly_aligned';
+    message: string;
+    severity: 'warning';
+    levelId: string;
+    wallId: string;
+    wallName: string;
+    /** The largest angle between the wall's axis and a neighbour's, in degrees. */
+    angle: number;
+    /** How far the wall's far end stands off the neighbour's line, in metres. */
+    offset: number;
+    neighbours: {
+        wallId: string;
+        name: string;
+        end: 'start' | 'end';
+        angle: number;
+    }[];
+    nodeIds: string[];
+};
+/** The straight, visible walls long enough to measure, as bodies. */
+export declare function wallBodies(walls: readonly WallNode[]): WallBody[];
+/**
+ * Wall ends that stop 3 to 25 cm short of another wall of the level: the daylight between the
+ * end's cap and the other wall's body, the other wall named. An end that touches any wall (the
+ * caps and bodies within 3 cm) is a joint and is not asked; so is an end whose nearest wall lies
+ * to its side, not ahead of it (two walls running side by side).
+ */
+export declare function wallEndShortIssues(input: {
+    levelId: string;
+    levelName: string;
+    bodies: readonly WallBody[];
+    min?: number;
+    max?: number;
+}): WallEndShortIssue[];
+export type Bend = {
+    wall: WallBody;
+    end: 'start' | 'end';
+    other: WallBody;
+    otherEnd: 'start' | 'end';
+    angle: number;
+};
+/**
+ * Every place one wall carries on into another: the two bodies' ends within a wall thickness of
+ * each other, and the second heading away from the joint within `maxDeg` of the first's heading.
+ * The angle is the turn between them (0 is one straight line).
+ */
+export declare function wallContinuations(bodies: readonly WallBody[], maxDeg: number): Bend[];
+/**
+ * A wall that continues another at an angle between 0.5 and 6 degrees: joined at an end and
+ * carrying on in nearly the same direction. A wall between two neighbours that are aligned with
+ * each other is the one reported (the short wall holding a door, drawn skewed), with both
+ * neighbours; a single bend is reported on the shorter of its two walls.
+ */
+export declare function wallNearlyAlignedIssues(input: {
+    levelId: string;
+    levelName: string;
+    bodies: readonly WallBody[];
+    min?: number;
+    max?: number;
+    minOffset?: number;
+}): WallNearlyAlignedIssue[];
+export {};
+//# sourceMappingURL=wall-joins.d.ts.map

package/dist/agent-operations/wall-joins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-joins.d.ts","sourceRoot":"","sources":["../../src/agent-operations/wall-joins.ts"],"names":[],"mappings":"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"}

package/dist/agent-operations/wall-joins.js

@@ -0,0 +1,308 @@
+import { isCurvedWall } from '../systems/wall/wall-curve.js';
+import { getWallBodyLine } from '../systems/wall/wall-frame.js';
+/** An end that stops this far short of a body or more is a gap; nearer is a joint. */
+export const END_SHORT_MIN_M = 0.03;
+/** Further than this the end is a free end that happens to stand near a wall, not a missed joint. */
+export const END_SHORT_MAX_M = 0.25;
+/** A turn smaller than this is a straight line drawn with noise; a larger one up to the maximum is the finding. */
+export const ALIGN_MIN_DEG = 0.5;
+/** A turn larger than this is an angle somebody drew (a bay, an angled wing). */
+export const ALIGN_MAX_DEG = 6;
+/** A skew that moves the wall's far end less than this off its neighbour's line is within drawing tolerance, and is not said. */
+export const ALIGN_MIN_OFFSET_M = 0.02;
+/** The two neighbours of a wall count as aligned with each other within this. */
+const NEIGHBOURS_ALIGNED_DEG = 0.5;
+/** Shortest wall that is measured. */
+const MIN_LENGTH_M = 0.05;
+/** The nearest points of two parts of a wall end and a body must lie this far ahead of the end, as a share of the distance (cos of 60 degrees). */
+const AHEAD = 0.5;
+const round = (value, places) => Math.round(value * 10 ** places) / 10 ** places;
+const nameOf = (wall) => wall.name?.trim() || wall.id;
+/** The straight, visible walls long enough to measure, as bodies. */
+export function wallBodies(walls) {
+    const bodies = [];
+    for (const wall of walls) {
+        if (wall.visible === false || isCurvedWall(wall))
+            continue;
+        const line = getWallBodyLine(wall);
+        const dx = line.end.x - line.start.x;
+        const dy = line.end.y - line.start.y;
+        const length = Math.hypot(dx, dy);
+        if (!(length >= MIN_LENGTH_M) || !Number.isFinite(length))
+            continue;
+        bodies.push({
+            id: wall.id,
+            name: nameOf(wall),
+            a: [line.start.x, line.start.y],
+            b: [line.end.x, line.end.y],
+            length,
+            ux: dx / length,
+            uy: dy / length,
+            thickness: wall.thickness ?? 0.1,
+        });
+    }
+    return bodies.sort((p, q) => (p.id < q.id ? -1 : 1));
+}
+const dot = (ax, ay, bx, by) => ax * bx + ay * by;
+/** The closest points of two segments and their distance (0 where they cross). */
+function closestOfSegments(p1, p2, q1, q2) {
+    const d1x = p2[0] - p1[0];
+    const d1y = p2[1] - p1[1];
+    const d2x = q2[0] - q1[0];
+    const d2y = q2[1] - q1[1];
+    const rx = p1[0] - q1[0];
+    const ry = p1[1] - q1[1];
+    const a = dot(d1x, d1y, d1x, d1y);
+    const e = dot(d2x, d2y, d2x, d2y);
+    const f = dot(d2x, d2y, rx, ry);
+    let s;
+    let t;
+    if (a <= 1e-12 && e <= 1e-12) {
+        s = 0;
+        t = 0;
+    }
+    else if (a <= 1e-12) {
+        s = 0;
+        t = Math.min(1, Math.max(0, f / e));
+    }
+    else {
+        const c = dot(d1x, d1y, rx, ry);
+        if (e <= 1e-12) {
+            t = 0;
+            s = Math.min(1, Math.max(0, -c / a));
+        }
+        else {
+            const b = dot(d1x, d1y, d2x, d2y);
+            const denom = a * e - b * b;
+            s = denom > 1e-12 ? Math.min(1, Math.max(0, (b * f - c * e) / denom)) : 0;
+            t = (b * s + f) / e;
+            if (t < 0) {
+                t = 0;
+                s = Math.min(1, Math.max(0, -c / a));
+            }
+            else if (t > 1) {
+                t = 1;
+                s = Math.min(1, Math.max(0, (b - c) / a));
+            }
+        }
+    }
+    const p = [p1[0] + d1x * s, p1[1] + d1y * s];
+    const q = [q1[0] + d2x * t, q1[1] + d2y * t];
+    return { d: Math.hypot(p[0] - q[0], p[1] - q[1]), p, q };
+}
+/** The four corners of a body, in order. */
+function corners(body) {
+    const nx = -body.uy * (body.thickness / 2);
+    const ny = body.ux * (body.thickness / 2);
+    return [
+        [body.a[0] + nx, body.a[1] + ny],
+        [body.b[0] + nx, body.b[1] + ny],
+        [body.b[0] - nx, body.b[1] - ny],
+        [body.a[0] - nx, body.a[1] - ny],
+    ];
+}
+function insideRectangle(point, rectangle) {
+    let sign = 0;
+    for (let i = 0; i < 4; i++) {
+        const from = rectangle[i];
+        const to = rectangle[(i + 1) % 4];
+        const cross = (to[0] - from[0]) * (point[1] - from[1]) - (to[1] - from[1]) * (point[0] - from[0]);
+        if (Math.abs(cross) < 1e-12)
+            continue;
+        const s = Math.sign(cross);
+        if (sign === 0)
+            sign = s;
+        else if (s !== sign)
+            return false;
+    }
+    return true;
+}
+/** The closest points of a segment and a body's rectangle; 0 apart where they touch or overlap. */
+function closestToBody(c1, c2, body) {
+    const rectangle = corners(body);
+    if (insideRectangle(c1, rectangle))
+        return { d: 0, p: c1, q: c1 };
+    if (insideRectangle(c2, rectangle))
+        return { d: 0, p: c2, q: c2 };
+    let best = { d: Number.POSITIVE_INFINITY, p: c1, q: c1 };
+    for (let i = 0; i < 4; i++) {
+        const hit = closestOfSegments(c1, c2, rectangle[i], rectangle[(i + 1) % 4]);
+        if (hit.d < best.d)
+            best = hit;
+    }
+    return best;
+}
+const endPoint = (body, end) => (end === 'start' ? body.a : body.b);
+/** The unit direction pointing out of the wall at an end. */
+const outward = (body, end) => end === 'start' ? [-body.ux, -body.uy] : [body.ux, body.uy];
+/**
+ * Wall ends that stop 3 to 25 cm short of another wall of the level: the daylight between the
+ * end's cap and the other wall's body, the other wall named. An end that touches any wall (the
+ * caps and bodies within 3 cm) is a joint and is not asked; so is an end whose nearest wall lies
+ * to its side, not ahead of it (two walls running side by side).
+ */
+export function wallEndShortIssues(input) {
+    const min = input.min ?? END_SHORT_MIN_M;
+    const max = input.max ?? END_SHORT_MAX_M;
+    const issues = [];
+    for (const wall of input.bodies) {
+        for (const end of ['start', 'end']) {
+            const e = endPoint(wall, end);
+            const [ox, oy] = outward(wall, end);
+            const half = wall.thickness / 2;
+            const cap1 = [e[0] - oy * half, e[1] + ox * half];
+            const cap2 = [e[0] + oy * half, e[1] - ox * half];
+            let touching = false;
+            let nearest;
+            for (const other of input.bodies) {
+                if (other.id === wall.id)
+                    continue;
+                const hit = closestToBody(cap1, cap2, other);
+                if (hit.d < min) {
+                    touching = true;
+                    break;
+                }
+                if (hit.d > max)
+                    continue;
+                const vx = hit.q[0] - hit.p[0];
+                const vy = hit.q[1] - hit.p[1];
+                if (dot(vx, vy, ox, oy) < AHEAD * hit.d)
+                    continue;
+                if (!nearest || hit.d < nearest.d)
+                    nearest = { other, d: hit.d };
+            }
+            if (touching || !nearest)
+                continue;
+            const gap = round(nearest.d, 3);
+            const cm = (gap * 100).toFixed(1);
+            issues.push({
+                type: 'wall_end_short',
+                severity: 'warning',
+                levelId: input.levelId,
+                wallId: wall.id,
+                wallName: wall.name,
+                end,
+                otherWallId: nearest.other.id,
+                otherWallName: nearest.other.name,
+                gap,
+                at: [round(e[0], 3), round(e[1], 3)],
+                nodeIds: [wall.id, nearest.other.id],
+                message: `On ${input.levelName}, ${wall.name} (${wall.id}) ${end} stops ${cm} cm short of ${nearest.other.name} (${nearest.other.id}) at (${e[0].toFixed(2)}, ${e[1].toFixed(2)}): ${cm} cm of daylight between them (asked for a gap of ${min * 100}-${max * 100} cm; a joint is closer, a free end further)`,
+            });
+        }
+    }
+    return issues;
+}
+const degrees = (radians) => (radians * 180) / Math.PI;
+const angleBetween = (ax, ay, bx, by) => degrees(Math.acos(Math.min(1, Math.max(-1, dot(ax, ay, bx, by)))));
+/** Distance from a point to the infinite line of a body. */
+const offLine = (point, body) => Math.abs((point[0] - body.a[0]) * body.uy - (point[1] - body.a[1]) * body.ux);
+/**
+ * Every place one wall carries on into another: the two bodies' ends within a wall thickness of
+ * each other, and the second heading away from the joint within `maxDeg` of the first's heading.
+ * The angle is the turn between them (0 is one straight line).
+ */
+export function wallContinuations(bodies, maxDeg) {
+    const bends = [];
+    for (const wall of bodies) {
+        for (const end of ['start', 'end']) {
+            const e = endPoint(wall, end);
+            const [ox, oy] = outward(wall, end);
+            for (const other of bodies) {
+                if (other.id === wall.id)
+                    continue;
+                for (const otherEnd of ['start', 'end']) {
+                    const f = endPoint(other, otherEnd);
+                    if (Math.hypot(e[0] - f[0], e[1] - f[1]) > Math.max(wall.thickness, other.thickness))
+                        continue;
+                    // the direction the other wall takes away from the joint
+                    const [dx, dy] = outward(other, otherEnd === 'start' ? 'end' : 'start');
+                    const angle = angleBetween(ox, oy, dx, dy);
+                    if (angle <= maxDeg)
+                        bends.push({ wall, end, other, otherEnd, angle });
+                }
+            }
+        }
+    }
+    return bends;
+}
+/**
+ * A wall that continues another at an angle between 0.5 and 6 degrees: joined at an end and
+ * carrying on in nearly the same direction. A wall between two neighbours that are aligned with
+ * each other is the one reported (the short wall holding a door, drawn skewed), with both
+ * neighbours; a single bend is reported on the shorter of its two walls.
+ */
+export function wallNearlyAlignedIssues(input) {
+    const min = input.min ?? ALIGN_MIN_DEG;
+    const max = input.max ?? ALIGN_MAX_DEG;
+    const minOffset = input.minOffset ?? ALIGN_MIN_OFFSET_M;
+    const bends = wallContinuations(input.bodies, max).filter((bend) => bend.angle >= min);
+    const byWall = new Map();
+    for (const bend of bends)
+        byWall.set(bend.wall.id, [...(byWall.get(bend.wall.id) ?? []), bend]);
+    const issues = [];
+    const covered = new Set();
+    const neighbourOf = (bend) => ({
+        wallId: bend.other.id,
+        name: bend.other.name,
+        end: bend.end,
+        angle: round(bend.angle, 1),
+    });
+    const issue = (wall, own, offset) => {
+        const angle = round(Math.max(...own.map((bend) => bend.angle)), 1);
+        const neighbours = own.map(neighbourOf);
+        return {
+            type: 'wall_nearly_aligned',
+            severity: 'warning',
+            levelId: input.levelId,
+            wallId: wall.id,
+            wallName: wall.name,
+            angle,
+            offset: round(offset, 3),
+            neighbours,
+            nodeIds: [wall.id, ...own.map((bend) => bend.other.id)],
+            message: `On ${input.levelName}, ${wall.name} (${wall.id}) lies ${angle.toFixed(1)}° off the axis of ${neighbours
+                .map((n) => `${n.name} (${n.wallId}) at its ${n.end} (${n.angle.toFixed(1)}°)`)
+                .join(' and ')}; its far end stands ${(offset * 100).toFixed(1)} cm off that line (asked for a turn of ${min}-${max}° that moves the far end 2 cm or more: a straighter line is one line, a larger turn is an angle drawn on purpose)`,
+        };
+    };
+    // a wall between two neighbours aligned with each other: the skewed one
+    for (const [id, own] of byWall) {
+        const wall = own[0].wall;
+        const starts = own.filter((bend) => bend.end === 'start');
+        const ends = own.filter((bend) => bend.end === 'end');
+        if (!starts.length || !ends.length)
+            continue;
+        for (const first of starts) {
+            for (const second of ends) {
+                const between = angleBetween(first.other.ux, first.other.uy, second.other.ux, second.other.uy);
+                const aligned = Math.min(between, 180 - between) < NEIGHBOURS_ALIGNED_DEG;
+                if (!aligned || covered.has(id))
+                    continue;
+                covered.add(id);
+                const offset = Math.max(offLine(wall.a, first.other), offLine(wall.b, first.other));
+                if (offset >= minOffset)
+                    issues.push(issue(wall, [first, second], offset));
+            }
+        }
+    }
+    // a single bend: the shorter wall carries it, once
+    const reported = new Set();
+    for (const bend of bends) {
+        if (covered.has(bend.wall.id) || covered.has(bend.other.id))
+            continue;
+        const shorter = bend.wall.length < bend.other.length ||
+            (bend.wall.length === bend.other.length && bend.wall.id < bend.other.id);
+        if (!shorter)
+            continue;
+        const key = [bend.wall.id, bend.other.id].sort().join('|');
+        if (reported.has(key))
+            continue;
+        reported.add(key);
+        const far = bend.end === 'start' ? bend.wall.b : bend.wall.a;
+        const offset = offLine(far, bend.other);
+        if (offset >= minOffset)
+            issues.push(issue(bend.wall, [bend], offset));
+    }
+    return issues.sort((a, b) => (a.wallId < b.wallId ? -1 : 1));
+}

package/dist/agent-operations/wall-object-observations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-object-observations.d.ts","sourceRoot":"","sources":["../../src/agent-operations/wall-object-observations.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,IAAI,EAEV,MAAM,wBAAwB,CAAA;AAQ/B,OAAO,KAAK,EAAE,OAAO,EAAsB,MAAM,WAAW,CAAA;AAI5D,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AACpC,MAAM,MAAM,cAAc,GAAG;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,IAAI,CAAA;CAAE,CAAA;AAC3E,+FAA+F;AAC/F,MAAM,MAAM,kBAAkB,GAAG;IAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAAC,KAAK,EAAE,cAAc,EAAE,CAAA;CAAE,CAAA;AAC7E,KAAK,QAAQ,GAAG;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,OAAO,GAAG,MAAM,CAAA;IACtB,eAAe,EAAE,UAAU,CAAA;IAC3B,MAAM,CAAC,EAAE;QAAE,GAAG,EAAE,IAAI,CAAC;QAAC,GAAG,EAAE,IAAI,CAAA;KAAE,CAAA;IACjC,QAAQ,EAAE,eAAe,GAAG,iBAAiB,GAAG,gBAAgB,GAAG,mBAAmB,CAAA;CACvF,CAAA;AACD,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG;IAC7C,IAAI,EACA,wBAAwB,GACxB,mBAAmB,GACnB,iBAAiB,GACjB,yBAAyB,GACzB,gCAAgC,CAAA;IACpC,OAAO,EAAE,MAAM,CAAA;IACf,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,wBAAwB,CAAC,EAAE,MAAM,CAAA;IACjC,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAiID,4GAA4G;AAC5G,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,QAAQ,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAM,GAC1D,qBAAqB,EAAE,CAoJzB"}
+{"version":3,"file":"wall-object-observations.d.ts","sourceRoot":"","sources":["../../src/agent-operations/wall-object-observations.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,IAAI,EAEV,MAAM,wBAAwB,CAAA;AAQ/B,OAAO,KAAK,EAAE,OAAO,EAAsB,MAAM,WAAW,CAAA;AAK5D,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AACpC,MAAM,MAAM,cAAc,GAAG;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,IAAI,CAAA;CAAE,CAAA;AAC3E,+FAA+F;AAC/F,MAAM,MAAM,kBAAkB,GAAG;IAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAAC,KAAK,EAAE,cAAc,EAAE,CAAA;CAAE,CAAA;AAC7E,KAAK,QAAQ,GAAG;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,OAAO,GAAG,MAAM,CAAA;IACtB,eAAe,EAAE,UAAU,CAAA;IAC3B,MAAM,CAAC,EAAE;QAAE,GAAG,EAAE,IAAI,CAAC;QAAC,GAAG,EAAE,IAAI,CAAA;KAAE,CAAA;IACjC,QAAQ,EAAE,eAAe,GAAG,iBAAiB,GAAG,gBAAgB,GAAG,mBAAmB,CAAA;CACvF,CAAA;AACD,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG;IAC7C,IAAI,EACA,wBAAwB,GACxB,mBAAmB,GACnB,iBAAiB,GACjB,yBAAyB,GACzB,gCAAgC,CAAA;IACpC,OAAO,EAAE,MAAM,CAAA;IACf,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,wBAAwB,CAAC,EAAE,MAAM,CAAA;IACjC,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAoID,4GAA4G;AAC5G,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,QAAQ,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAM,GAC1D,qBAAqB,EAAE,CAmJzB"}