@expofp/wayfinding-compiler 0.0.0-experimental.3b0db16 → 0.0.0-stage

package/dist/lib/walkable.js

@@ -1,140 +0,0 @@
-import { buildingOutlines } from '@expofp/wayfinding-geometry';
-import { createClipper2Ops } from './geom/clipper2-ops.js';
-import { boundsOf, boxesOverlap, pointInRing, pointSegmentDistance, signedArea, vertexMean, wound, } from './geom/primitives.js';
-import { prepareWalls } from './geom/walls.js';
-import { NODE_SNAP } from './graph-types.js';
-/**
- * Wall half-thickness in meters. Square caps extend each jamb by it, so a doorway narrows by twice
- * this.
- */
-export const WALL_HALF_WIDTH = 0.12;
-/**
- * Footprints cut back to the walls that bound them: a room drawn as its bounding box keeps only its
- * largest piece, so it does not overshoot its wall into the aisle. A footprint the walls leave
- * whole is returned as is.
- * @param ops Polygon boolean backend.
- * @param footprints Obstacle rings, wound positive.
- * @param strips The wall strips, one per wall segment.
- * @returns One ring per footprint, in input order, and which of them the walls cut back.
- */
-function clipToOwnWalls(ops, footprints, strips) {
-    const stripBoxes = strips.map(boundsOf);
-    const clipped = footprints.map(() => false);
-    const rings = footprints.map((footprint, index) => {
-        const box = boundsOf(footprint);
-        // Only nearby strips: clipping against all of them costs minutes on a large hall.
-        const near = strips.filter((_, i) => boxesOverlap(stripBoxes[i], box));
-        if (!near.length)
-            return footprint;
-        const pieces = ops.difference([footprint], near);
-        if (pieces.length < 2)
-            return footprint;
-        clipped[index] = true;
-        return pieces.reduce((a, b) => (Math.abs(signedArea(b)) > Math.abs(signedArea(a)) ? b : a));
-    });
-    return { rings, clipped };
-}
-/**
- * Whether a destination stands on a piece of floor: its middle or a corner lies inside it, or a
- * corner lies on its boundary.
- * @param piece The piece of floor.
- * @param ring The destination's ring.
- * @returns True when the destination stands on it.
- */
-export function standsOn(piece, ring) {
-    if (ring.length < 3)
-        return false;
-    if ([vertexMean(ring), ...ring].some((p) => pointInRing(piece, p)))
-        return true;
-    // A destination at the floor's edge is carved as a notch: its corners lie on the boundary.
-    return ring.some((p) => piece.some((a, i) => {
-        const b = piece[(i + 1) % piece.length];
-        return pointSegmentDistance(p[0], p[1], a[0], a[1], b[0], b[1]) < NODE_SNAP;
-    }));
-}
-/**
- * Whether a point is inside the building: inside its outline and not in a courtyard.
- * @param outline The building's outline, from {@link WalkableArea.outline}.
- * @param point The point.
- * @returns True inside.
- */
-export function inBuilding(outline, point) {
-    return outline.filter((ring) => pointInRing(ring, point)).length % 2 === 1;
-}
-/**
- * The walls as strips wound positive, one per wall segment.
- * @param ops Polygon boolean backend.
- * @param segments The wall segments, loops' closing pieces included ({@link prepareWalls}).
- * @param halfWidth Wall half-thickness in meters.
- * @returns One strip per wall segment.
- */
-export function wallStripsOf(ops, segments, halfWidth) {
-    const strips = segments.flatMap((s) => ops.offsetSegments([
-        [s[0], s[1]],
-        [s[2], s[3]],
-    ], halfWidth));
-    // Positive winding: a NonZero union would cancel where two strips overlap.
-    return strips.map(wound);
-}
-/**
- * Footprints cut back to the walls that bound them, in input order: the shapes the floor is carved
- * with.
- * @param obstacles The obstacle rings, in any winding.
- * @param strips The wall strips, from {@link wallStripsOf}.
- * @param ops Polygon boolean backend.
- * @returns One ring per obstacle, in input order, and which of them the walls cut back.
- */
-export function carveFootprints(obstacles, strips, ops) {
-    const positive = obstacles.map(wound);
-    return clipToOwnWalls(ops, positive, strips);
-}
-/**
- * The outer contours: the building outlines the walls draw, openings closed with no width limit. A
- * bridge closing an outline borders the floor and is no wall.
- * @param walls Cleaned wall centerlines with their closed/open flag.
- * @returns The outlines, largest first, wound positive.
- */
-export function outerContoursOf(walls) {
-    const runs = walls.map(({ points, closed }) => (closed ? [...points, points[0]] : points).flat());
-    return buildingOutlines(runs).map((flat) => {
-        const ring = [];
-        for (let i = 0; i < flat.length; i += 2)
-            ring.push([flat[i], flat[i + 1]]);
-        return wound(ring);
-    });
-}
-/**
- * Build one layer's walkable area:
- *
- *   walkable = interior(outer contours) − ⋃(obstacles) − ⋃(wall strips)
- * @param input One layer's walls (flat polylines) and obstacles from {@link carveFootprints}.
- * @param ops Polygon boolean backend; defaults to clipper2, which is the only one there is.
- * @param halfWidth Wall half-thickness in meters.
- * @param shared The same walls already read and offset, when the caller holds them.
- * @returns The walkable polygon with holes, plus diagnostic layers and stats.
- */
-export function buildWalkableArea(input, ops = createClipper2Ops(), halfWidth = WALL_HALF_WIDTH, shared) {
-    const prepared = shared?.walls ?? prepareWalls(input.walls);
-    const walls = [...prepared.runs];
-    const outerContours = shared?.contours ?? outerContoursOf(walls);
-    const base = ops.union(outerContours);
-    const strips = shared?.strips ?? wallStripsOf(ops, prepared.segments, halfWidth);
-    // One union instead of subtracting strips one by one; the overlay shows it too.
-    const mergedStrips = ops.union(strips);
-    // One union and one clip, not N clips (quadratic on a large floor).
-    const walkable = ops.difference(ops.difference(base, ops.union(input.obstacles)), mergedStrips);
-    const area = ops.area(walkable);
-    return {
-        rings: walkable,
-        outline: base,
-        wallStrips: mergedStrips,
-        wallLines: walls,
-        stats: {
-            walls: walls.length,
-            outerContours: outerContours.length,
-            rings: walkable.length,
-            area: +area.toFixed(1),
-            areaExact: area,
-        },
-    };
-}