@pascal-app/core 1.0.6 → 1.1.0

package/dist/spatial/usage-field/walls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walls.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/walls.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC3E,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,YAAY,EAClB,MAAM,yBAAyB,CAAA;AAMhC,OAAO,KAAK,EAAE,KAAK,EAAQ,MAAM,SAAS,CAAA;AAE1C,MAAM,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAOrD,eAAO,MAAM,SAAS,SAAU,OAAO,GAAG,SAAS,KAAG,IAAI,IAAI,QAAQ,GAAG,UACvB,CAAA;AAElD,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,GAAG,QAAQ,EAAE,CAOpE;AAwCD;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EACf,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6B,GACjC,KAAK,EAAE,CA0CT;AAED,qHAAqH;AACrH,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,cAAc,GAAG,MAAM,CAU/E;AAID;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EACf,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6B,GACjC;IAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAkExC"}

package/dist/spatial/usage-field/walls.js

@@ -0,0 +1,180 @@
+import { getOpeningWallCut, wallSupportForNodes } from '../../lib/opening-floor-datum.js';
+import { difference, intersection, union } from '../../lib/polygon-boolean.js';
+import { wallFaceBaseOffset } from '../../lib/wall-face-script.js';
+import { getWallTrimFaces, WALL_TRIM_DEFAULTS, } from '../../schema/nodes/wall.js';
+import { getWallTop } from '../../services/storey.js';
+import { isCurvedWall } from '../../systems/wall/wall-curve.js';
+import { calculateLevelMiters, getWallPlanFootprint } from '../../systems/wall/wall-footprint.js';
+import { getWallFaceLine } from '../../systems/wall/wall-frame.js';
+import { TRIM_PROFILES } from '../../systems/wall/wall-trim-profiles.js';
+/** Lengths below this are rounding, not geometry: a piece thinner than it is not an obstacle. */
+const MIN_PIECE_M = 0.005;
+/** The wall's trims are drawn in slices of at least this projection (`MIN_SLICE_PROUD` in the trim builder). */
+const MIN_SLICE_PROUD = 0.0005;
+export const isOpening = (node) => node?.type === 'door' || node?.type === 'window';
+export function levelWalls(nodes, levelId) {
+    return Object.values(nodes)
+        .filter((node) => node.type === 'wall' && node.parentId === levelId && node.visible !== false)
+        .sort((a, b) => a.id.localeCompare(b.id));
+}
+const toRing = (points) => points.map(({ x, y }) => [x, y]);
+function pushPieces(out, pieces, base) {
+    for (const [index, piece] of pieces.entries())
+        out.push({
+            ...base,
+            id: `${base.id}${pieces.length > 1 ? `.${index}` : ''}`,
+            outer: piece.outer,
+            holes: piece.holes,
+        });
+}
+/**
+ * A wall's highest top, and the shape of a prism standing to it: a sloped top is drawn at its
+ * taller end over the whole length, so the prism claims space above the low end and is approximate.
+ */
+function wallTopReach(wall, levelId, nodes, base) {
+    const start = getWallTop(wall, levelId, nodes, base, 0);
+    const end = getWallTop(wall, levelId, nodes, base, 1);
+    return {
+        top: Math.max(start, end),
+        sloped: Math.abs(end - start) > MIN_PIECE_M
+            ? { shape: 'approx', why: 'a sloped wall top: drawn at its taller end' }
+            : { shape: 'exact' },
+    };
+}
+/**
+ * The wall bodies of one level: each wall's mitred footprint over its height, less the bands its
+ * doors and windows cut, with the pieces left below a sill and above a head. Heights are level-local:
+ * from the wall's elected base (`wallSupportForNodes`) to its top (`getWallTop`), the same two
+ * numbers the wall renderer reads.
+ */
+export function wallBodies(nodes, levelId, walls = levelWalls(nodes, levelId)) {
+    const out = [];
+    const miters = calculateLevelMiters(walls);
+    for (const wall of walls) {
+        const footprint = toRing(getWallPlanFootprint(wall, miters));
+        if (footprint.length < 3)
+            continue;
+        const support = wallSupportForNodes(wall, nodes);
+        const base = support.elevation;
+        const { top, sloped } = wallTopReach(wall, levelId, nodes, base);
+        if (!(top - base > MIN_PIECE_M))
+            continue;
+        const cuts = (wall.children ?? [])
+            .map((id) => nodes[id])
+            .filter(isOpening)
+            .map((opening) => ({ opening, cut: getOpeningWallCut(wall, opening, nodes, support) }))
+            .filter(({ cut }) => cut.band.length >= 3);
+        const bands = cuts.length ? union(cuts.map(({ cut }) => cut.band)) : [];
+        const common = { nodeId: wall.id, kind: 'wall', ...sloped };
+        pushPieces(out, difference(footprint, bands), {
+            ...common,
+            id: `${wall.id}#body`,
+            z0: base,
+            z1: top,
+        });
+        for (const { opening, cut } of cuts) {
+            const inBand = intersection(footprint, cut.band);
+            if (cut.bottom - base > MIN_PIECE_M)
+                pushPieces(out, inBand, {
+                    ...common,
+                    id: `${wall.id}#below:${opening.id}`,
+                    z0: base,
+                    z1: Math.min(cut.bottom, top),
+                });
+            if (top - cut.top > MIN_PIECE_M)
+                pushPieces(out, inBand, {
+                    ...common,
+                    id: `${wall.id}#above:${opening.id}`,
+                    z0: Math.max(cut.top, base),
+                    z1: top,
+                });
+        }
+    }
+    return out;
+}
+/** How far a trim stands out, at most, over its height: the profile's own samples, as the trim builder cuts them. */
+export function trimProjection(kind, trim) {
+    const profile = TRIM_PROFILES[kind][trim.profile] ??
+        TRIM_PROFILES[kind][WALL_TRIM_DEFAULTS[kind].profile] ??
+        TRIM_PROFILES[kind].flat;
+    if (!profile)
+        return trim.proud;
+    let widest = MIN_SLICE_PROUD;
+    for (let index = 0; index < profile.samples; index += 1)
+        widest = Math.max(widest, trim.proud * profile.proudAt((index + 0.5) / profile.samples));
+    return widest;
+}
+const TRIM_KINDS = ['skirting', 'crown', 'chairRail'];
+/**
+ * A wall's skirting, chair rail and crown as thin prisms standing on the faces they are drawn on,
+ * cut where a door opens through their height. Straight walls only: a curved wall's trim is left
+ * out and the wall named in `skipped`.
+ */
+export function wallTrims(nodes, levelId, walls = levelWalls(nodes, levelId)) {
+    const prisms = [];
+    const skipped = [];
+    for (const wall of walls) {
+        const configs = TRIM_KINDS.flatMap((kind) => {
+            const trim = { ...WALL_TRIM_DEFAULTS[kind], ...(wall[kind] ?? {}) };
+            return trim.enabled ? [{ kind, trim }] : [];
+        });
+        if (!configs.length)
+            continue;
+        if (isCurvedWall(wall)) {
+            skipped.push(wall.id);
+            continue;
+        }
+        const support = wallSupportForNodes(wall, nodes);
+        const { top, sloped } = wallTopReach(wall, levelId, nodes, support.elevation);
+        const openings = (wall.children ?? [])
+            .map((id) => nodes[id])
+            .filter(isOpening)
+            .map((opening) => ({ opening, cut: getOpeningWallCut(wall, opening, nodes, support) }))
+            .filter(({ cut }) => cut.band.length >= 3);
+        for (const { kind, trim } of configs) {
+            const proud = trimProjection(kind, trim);
+            for (const face of getWallTrimFaces(trim.sides)) {
+                const line = getWallFaceLine(wall, face);
+                const dx = line.end.x - line.start.x;
+                const dz = line.end.y - line.start.y;
+                const length = Math.hypot(dx, dz);
+                if (length < 1e-9)
+                    continue;
+                // face a is the wall's left (+normal), b its right
+                const sign = face === 'a' ? 1 : -1;
+                const nx = (-dz / length) * sign * proud;
+                const nz = (dx / length) * sign * proud;
+                const strip = [
+                    [line.start.x, line.start.y],
+                    [line.end.x, line.end.y],
+                    [line.end.x + nx, line.end.y + nz],
+                    [line.start.x + nx, line.start.y + nz],
+                ];
+                const floor = support.elevation + wallFaceBaseOffset(support, face);
+                const z0 = kind === 'crown'
+                    ? top - trim.height
+                    : kind === 'chairRail'
+                        ? floor + (trim.offsetY ?? 0)
+                        : floor;
+                const z1 = z0 + trim.height;
+                // a door opens through the trim's height where its own span meets it: the trim stops at the jambs
+                const crossing = openings
+                    .filter(({ cut }) => cut.bottom < z1 && cut.top > z0)
+                    .map(({ cut }) => cut.band);
+                const pieces = crossing.length
+                    ? difference(strip, union(crossing))
+                    : [{ outer: strip, holes: [] }];
+                pushPieces(prisms, pieces, {
+                    id: `${wall.id}#${kind}.${face}`,
+                    nodeId: wall.id,
+                    kind: 'wall-trim',
+                    z0,
+                    z1,
+                    ...(kind === 'crown' ? sloped : { shape: 'exact' }),
+                    host: { wallId: wall.id, face },
+                });
+            }
+        }
+    }
+    return { prisms, skipped };
+}

package/dist/spatial/usage-field/way-in.d.ts

@@ -0,0 +1,26 @@
+import { type Obstacle } from './obstacles.js';
+import type { LevelShapes, Prism, Ring, UsageShapes } from './types.js';
+type Point = [number, number];
+export type Way = {
+    /** The clear width of the best way from the entrance to the room's open floor. */
+    width: number;
+    at: Point;
+    /** The two things that bound the pinch. */
+    by: Obstacle[];
+};
+/**
+ * The best way from an entrance into the room it leads to: the widest path (as the passage measure reads
+ * one) from the entrance's opening (`entrance`, a ring across a doorway or an open edge) to the room's
+ * open floor, the cells where a disc of a passage's width fits. `leaf` is a line (a door's leaf standing
+ * open) added to what stands in the way. The entrance's own clear width caps that path, and an entrance is
+ * measured elsewhere, so a way is only returned when it is under a passage's width and `bounds` holds of
+ * one of the two things that bound its pinch. Null otherwise: the way is clear, or what narrows it is not
+ * what the caller asks about.
+ */
+export declare function wayIn(shapes: UsageShapes, level: LevelShapes, zone: {
+    id: string;
+    polygon: Ring;
+    holes?: Ring[];
+}, entrance: Ring, around: Point, floorY: number, underlay: (prism: Prism) => boolean, bounds: (prism: Prism) => boolean, leaf?: Prism | null): Way | null;
+export {};
+//# sourceMappingURL=way-in.d.ts.map

package/dist/spatial/usage-field/way-in.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"way-in.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/way-in.ts"],"names":[],"mappings":"AAIA,OAAO,EAAqB,KAAK,QAAQ,EAAe,MAAM,aAAa,CAAA;AAE3E,OAAO,KAAK,EAAe,WAAW,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAEjF,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAO7B,MAAM,MAAM,GAAG,GAAG;IAChB,kFAAkF;IAClF,KAAK,EAAE,MAAM,CAAA;IACb,EAAE,EAAE,KAAK,CAAA;IACT,2CAA2C;IAC3C,EAAE,EAAE,QAAQ,EAAE,CAAA;CACf,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CACnB,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,IAAI,CAAC;IAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;CAAE,EACnD,QAAQ,EAAE,IAAI,EACd,MAAM,EAAE,KAAK,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,EACnC,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,EACjC,IAAI,GAAE,KAAK,GAAG,IAAW,GACxB,GAAG,GAAG,IAAI,CA2GZ"}

package/dist/spatial/usage-field/way-in.js

@@ -0,0 +1,113 @@
+import { polygonInteriorPoint } from '../../lib/polygon-label.js';
+import { cellOf, cellX, cellZ } from './field.js';
+import { PASSAGE_M, TOLERANCE_M } from './findings.js';
+import { BODY_BAND, buildField, inRegion, maskOf } from './level-field.js';
+import { boundingObstacles, passagePair } from './obstacles.js';
+import { pathTo, refinePassage, widestPath } from './path.js';
+/** Grid step of the local field; the pinch is then solved to the millimetre, as a passage is. */
+const CELL_M = 0.05;
+/** The way is read inside this radius of where it starts: a leaf and a passage's width past its tip, or the first metres of a room. */
+const REACH_M = 3;
+/**
+ * The best way from an entrance into the room it leads to: the widest path (as the passage measure reads
+ * one) from the entrance's opening (`entrance`, a ring across a doorway or an open edge) to the room's
+ * open floor, the cells where a disc of a passage's width fits. `leaf` is a line (a door's leaf standing
+ * open) added to what stands in the way. The entrance's own clear width caps that path, and an entrance is
+ * measured elsewhere, so a way is only returned when it is under a passage's width and `bounds` holds of
+ * one of the two things that bound its pinch. Null otherwise: the way is clear, or what narrows it is not
+ * what the caller asks about.
+ */
+export function wayIn(shapes, level, zone, entrance, around, floorY, underlay, bounds, leaf = null) {
+    const ring = entrance;
+    const holes = (zone.holes ?? []);
+    const region = { outer: zone.polygon, holes };
+    const probe = polygonInteriorPoint({ polygon: zone.polygon, holes: zone.holes }, true);
+    const y = level.floors.find((floor) => inRegion(probe[0], probe[1], floor))?.y ?? floorY;
+    const [hx, hz] = around;
+    const zx = region.outer.map((p) => p[0]);
+    const zz = region.outer.map((p) => p[1]);
+    const domain = [
+        Math.max(hx - REACH_M, Math.min(...zx) - 0.2),
+        Math.max(hz - REACH_M, Math.min(...zz) - 0.2),
+        Math.min(hx + REACH_M, Math.max(...zx) + 0.2),
+        Math.min(hz + REACH_M, Math.max(...zz) + 0.2),
+    ];
+    // the prisms near the room only: the field builder makes an obstacle of every prism before it looks where it is
+    const near = (prism) => {
+        let x0 = Number.POSITIVE_INFINITY;
+        let z0 = Number.POSITIVE_INFINITY;
+        let x1 = Number.NEGATIVE_INFINITY;
+        let z1 = Number.NEGATIVE_INFINITY;
+        for (const [x, z] of prism.outer) {
+            x0 = Math.min(x0, x);
+            x1 = Math.max(x1, x);
+            z0 = Math.min(z0, z);
+            z1 = Math.max(z1, z);
+        }
+        return !(x1 < domain[0] || x0 > domain[2] || z1 < domain[1] || z0 > domain[3]);
+    };
+    const field = buildField({
+        ...shapes,
+        levels: shapes.levels.map((l) => ({ ...l, prisms: l.prisms.filter(near) })),
+    }, {
+        levelId: '',
+        y,
+        regions: [{ id: zone.id, nodeId: zone.id, ...region, y, outdoor: false, shape: 'exact' }],
+        domain,
+    }, BODY_BAND, CELL_M, underlay, leaf ? [leaf] : []);
+    const { grid, F, floor } = field;
+    if (leaf) {
+        // a line is no wall to a grid path, which steps between the cells either side of it: the cells it runs through are shut
+        const [from, tip] = leaf.outer;
+        const reach = Math.hypot(tip[0] - from[0], tip[1] - from[1]);
+        for (let s = 0; s <= reach; s += CELL_M / 4) {
+            const c = cellOf(grid, from[0] + ((tip[0] - from[0]) * s) / reach, from[1] + ((tip[1] - from[1]) * s) / reach);
+            if (c >= 0)
+                F[c] = 0;
+        }
+    }
+    const doorway = maskOf(grid, [{ outer: ring, holes: [] }]);
+    const plate = Uint8Array.from(floor);
+    const sources = [];
+    for (let c = 0; c < doorway.length; c++)
+        if (doorway[c]) {
+            plate[c] = 1;
+            if (F[c] > 0)
+                sources.push(c);
+        }
+    if (sources.length === 0)
+        return null;
+    const sourceSet = new Set(sources);
+    const widest = widestPath(grid, F, plate, sources);
+    const open = (PASSAGE_M - TOLERANCE_M) / 2;
+    let best = -1;
+    for (let c = 0; c < floor.length; c++)
+        if (floor[c] &&
+            F[c] >= open &&
+            widest.B[c] > Number.NEGATIVE_INFINITY &&
+            (best < 0 || widest.B[c] > widest.B[best]))
+            best = c;
+    if (best < 0)
+        return null;
+    // the grid is within a cell of the millimetre figure: a way a cell over the limit is not narrow
+    if (2 * widest.B[best] > PASSAGE_M + 2 * CELL_M)
+        return null;
+    const path = pathTo(widest.P, F, best);
+    const refined = refinePassage(grid, F, field.index, path, (c) => sourceSet.has(c), (x, z) => inRegion(x, z, region));
+    // what bounds the way is read where the path is narrowest, not where the refinement says a cell of that clearance is
+    const narrowest = path.cells[path.narrowest];
+    const here = [cellX(grid, narrowest % grid.W), cellZ(grid, (narrowest / grid.W) | 0)];
+    const grided = 2 * F[narrowest];
+    const pair = passagePair(field.obstacles, here[0], here[1]);
+    const exact = pair !== null && Math.abs(pair.width - refined.width) < 0.02;
+    const width = exact ? pair.width : Math.min(refined.width, grided + 2 * grid.h);
+    if (!(width < PASSAGE_M - TOLERANCE_M))
+        return null;
+    const by = exact
+        ? [pair.a, pair.b]
+        : boundingObstacles(field.obstacles, here[0], here[1], width / 2);
+    const at = exact ? [(pair.pa[0] + pair.pb[0]) / 2, (pair.pa[1] + pair.pb[1]) / 2] : here;
+    if (!by.some((o) => bounds(o.prism)))
+        return null;
+    return { width: Math.round(width * 1000) / 1000, at, by };
+}