@expofp/wayfinding-compiler 0.0.0-bootstrap.0

package/dist/lib/walkable.js

@@ -0,0 +1,140 @@
+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,
+        },
+    };
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@expofp/wayfinding-compiler",
+  "version": "0.0.0-bootstrap.0",
+  "type": "module",
+  "description": "ExpoFP SDK internal: compiles raw plan geometry into a wayfinding routing graph",
+  "homepage": "https://developer.expofp.com/",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@expofp/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "clipper2-ts": "2.0.1-18",
+    "tslib": "^2.3.0",
+    "@expofp/wayfinding-geometry": "0.0.0-bootstrap.0"
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "!**/*.map"
+  ],
+  "nx": {
+    "targets": {}
+  }
+}