@pascal-app/core 1.0.3 → 1.0.4

package/dist/lib/room-zone-adoption.js

@@ -0,0 +1,150 @@
+import { area, containsPoint, intersection } from './polygon-boolean.js';
+/**
+ * Which existing zone becomes the room of an enclosed face. Shared by the M3 load
+ * migration and the structure kernel so both load paths and live edits agree.
+ *
+ * Hand-drawn zones are loose: drawn to wall centre lines, inner or outer faces,
+ * tens of centimetres off, sometimes spanning a closet or a second space behind a
+ * wall. A zone is its face's room when the face holds most of the zone and the zone
+ * covers most of the face's clear floor, or when the two simply match (IoU).
+ */
+export const ROOM_MATCH_IOU = 0.9;
+/** Part of the face's clear floor the zone must cover. */
+export const ROOM_ADOPT_COVER = 0.5;
+/** Part of the zone that must lie in the face (its dominant face). */
+export const ROOM_ADOPT_SHARE = 0.5;
+const EPSILON = 1e-9;
+function bounds(rings) {
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const ring of rings)
+        for (const [x, y] of ring) {
+            minX = Math.min(minX, x);
+            minY = Math.min(minY, y);
+            maxX = Math.max(maxX, x);
+            maxY = Math.max(maxY, y);
+        }
+    return { minX, minY, maxX, maxY };
+}
+function overlaps(a, b) {
+    return a.minX < b.maxX && b.minX < a.maxX && a.minY < b.maxY && b.minY < a.maxY;
+}
+/** Every face the zone overlaps, with its fit numbers, in face order. */
+export function zoneFaceFits(zone, faces) {
+    const polygon = { outer: zone.polygon, holes: zone.holes ?? [] };
+    const zoneArea = area([polygon]);
+    if (!(zoneArea > EPSILON))
+        return [];
+    const box = bounds([zone.polygon]);
+    const fits = [];
+    faces.forEach((face, index) => {
+        if (!overlaps(box, bounds([face.polygon.outer])))
+            return;
+        const overlap = area(intersection(polygon, face.polygon));
+        if (!(overlap > EPSILON))
+            return;
+        const faceArea = area([face.polygon]);
+        const clearArea = face.clear.outer.length >= 3 ? area([face.clear]) : 0;
+        const clearOverlap = clearArea > EPSILON ? area(intersection(polygon, face.clear)) : overlap;
+        fits.push({
+            face: index,
+            key: face.key,
+            share: overlap / zoneArea,
+            cover: clearOverlap / (clearArea > EPSILON ? clearArea : faceArea),
+            iou: Math.max(overlap / (zoneArea + faceArea - overlap), clearArea > EPSILON ? clearOverlap / (zoneArea + clearArea - clearOverlap) : 0),
+        });
+    });
+    return fits;
+}
+/** The face holding most of the zone, when the zone is that face's room. */
+export function adoptableFace(fits) {
+    let best;
+    for (const fit of fits)
+        if (!best ||
+            fit.share > best.share + EPSILON ||
+            (Math.abs(fit.share - best.share) <= EPSILON &&
+                (fit.cover > best.cover + EPSILON ||
+                    (Math.abs(fit.cover - best.cover) <= EPSILON && fit.key < best.key))))
+            best = fit;
+    if (!best)
+        return;
+    return best.iou >= ROOM_MATCH_IOU ||
+        (best.cover >= ROOM_ADOPT_COVER && best.share >= ROOM_ADOPT_SHARE)
+        ? best
+        : undefined;
+}
+/** Orders two candidates for one face: the zone covering more of it wins. */
+export function compareAdoptionFits(a, b) {
+    return (b.fit.cover - a.fit.cover || b.fit.iou - a.fit.iou || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+/** Face index → adopted zone id; at most one zone per face, one face per zone. */
+export function electAdoptedZones(faces, zones) {
+    const candidates = new Map();
+    for (const zone of zones) {
+        const fit = adoptableFace(zoneFaceFits(zone, faces));
+        if (!fit)
+            continue;
+        const list = candidates.get(fit.face) ?? [];
+        list.push({ id: zone.id, fit });
+        candidates.set(fit.face, list);
+    }
+    const elected = new Map();
+    for (const [face, list] of candidates)
+        elected.set(face, list.sort(compareAdoptionFits)[0].id);
+    return elected;
+}
+function iou(a, b) {
+    const overlap = area(intersection(a, b));
+    const combined = area([a]) + area([b]) - overlap;
+    return combined > 0 ? overlap / combined : 0;
+}
+const boundaryKey = (walls = [], separators = []) => JSON.stringify([[...walls].sort(), [...separators].sort()]);
+/**
+ * The face an existing room keeps: the face with exactly its boundaries (nothing
+ * about it changed, even where degenerate faces overlap), then the outer face when
+ * its separators just carved an island, then the face holding its seed, then the
+ * largest overlap.
+ * Shared by the load migration and the structure kernel, so a reload never trades an
+ * existing room for a newly created one.
+ */
+export function existingRoomFace(room, faces, overlaps = faces.map((face) => iou({ outer: room.polygon, holes: room.holes ?? [] }, face.polygon))) {
+    const holes = room.holes ?? [];
+    const separators = room.boundarySeparatorIds ?? [];
+    const own = boundaryKey(room.boundaryWallIds, separators);
+    return faces
+        .map((face, index) => ({
+        index,
+        key: face.key,
+        exact: own !== boundaryKey() &&
+            boundaryKey(face.boundaryWallIds, face.boundarySeparatorIds) === own,
+        overlap: overlaps[index],
+        seed: !!room.seed && containsPoint([face.polygon], room.seed),
+        // A new separator island takes area from the room, never its identity,
+        // even when the old seed lies inside the new island.
+        islandOuter: face.polygon.holes.length > holes.length &&
+            face.boundarySeparatorIds.some((id) => !separators.includes(id)) &&
+            iou({ outer: room.polygon, holes: [] }, { outer: face.polygon.outer, holes: [] }) >
+                1 - 1e-6,
+    }))
+        .filter(({ overlap, seed }) => seed || overlap > 0)
+        .sort((a, b) => Number(b.exact) - Number(a.exact) ||
+        Number(b.islandOuter) - Number(a.islandOuter) ||
+        Number(b.seed) - Number(a.seed) ||
+        b.overlap - a.overlap ||
+        (a.key < b.key ? -1 : a.key > b.key ? 1 : 0))[0]?.index;
+}
+/** Among existing rooms keeping one face, the one covering most of it survives. */
+export function compareExistingRooms(face) {
+    const covered = new Map();
+    const cover = (room) => {
+        let value = covered.get(room.id);
+        if (value === undefined) {
+            value = area(intersection({ outer: room.polygon, holes: room.holes ?? [] }, face.polygon));
+            covered.set(room.id, value);
+        }
+        return value;
+    };
+    return (a, b) => cover(b) - cover(a) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}

package/dist/lib/setback-envelope.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The BUILDABLE ENVELOPE as the zoning officer draws it: every lot line
+ * pushed inward by its own required yard, measured perpendicular to that
+ * line, the offsets clipped against each other where they meet. A curved
+ * (radius) lot line — a cul-de-sac frontage, a rounded corner — offsets to
+ * a CONCENTRIC curve, never a chord — the industry-standard setback for pie
+ * shapes, radius corners and odd lots.
+ *
+ * Built as a distance field rather than by intersecting offset lines: a
+ * point is buildable when its distance to EVERY lot line is at least that
+ * line's setback. The zero contour of `min_i(dist(p, line_i) − d_i)` over
+ * the lot is exactly the variable-distance inward offset — straight where
+ * the lot is straight, concentric round a radius, clipped where offsets
+ * cross, and rounded round a reflex notch — for convex, pie-shaped,
+ * L-shaped and radius-cornered lots alike. The contour is traced by the
+ * same marching squares the site plan draws terrain with, then simplified
+ * so a rectangle comes back as four corners and an arc keeps its vertices.
+ */
+export type Pt = readonly [number, number];
+export declare function polygonAreaAbs(points: readonly Pt[]): number;
+/**
+ * Which edges belong to the same ARC RUN: consecutive short edges (under
+ * `shortM`) turning gently (under `turnDeg` per vertex) — the county
+ * fabric's way of drawing a radius. A long edge is its own run. Returns
+ * the run id per edge.
+ */
+export declare function arcRuns(points: readonly Pt[], shortM?: number, turnDeg?: number): number[];
+/**
+ * The polygon `points` offset INWARD by `distances[i]` along edge i (edge i
+ * runs from points[i] to points[i + 1]). Empty when nothing buildable
+ * remains. The result starts near the lot's first vertex and winds the
+ * lot's way.
+ */
+/** A half-plane the envelope may not enter: the line a→b, `inside` a point on the forbidden side (a sight triangle's hypotenuse, the corner inside). */
+export type KeepOut = {
+    a: Pt;
+    b: Pt;
+    inside: Pt;
+};
+export declare function insetPolygon(points: readonly Pt[], distances: readonly number[], options?: {
+    resolution?: number;
+    simplifyM?: number;
+    keepOut?: readonly KeepOut[];
+}): Pt[];
+/**
+ * Which envelope edge is the one behind the lot's front line: the longest
+ * envelope edge running parallel to it (within 25°) with its midpoint
+ * nearest that line; failing that, the envelope edge whose midpoint is
+ * nearest the lot front's midpoint (a pie lot's curved frontage has no
+ * single parallel — its longest arc chord fronts the house).
+ */
+export declare function envelopeFrontEdge(lot: readonly Pt[], frontIndex: number, envelope: readonly Pt[]): number;
+/**
+ * The CORNER SIGHT TRIANGLE at a street intersection (the clear-vision /
+ * visibility triangle): from the point where the two street lines meet —
+ * the right-of-way lines extended through the curb return — `legM` along
+ * each, the hypotenuse joining them; nothing over the code's height (30
+ * in typically) stands inside it. The leg is the ordinance's (25 ft is the
+ * common residential figure; FDOT and the Greenbook size it by speed) —
+ * verify locally. `edgeA` and `edgeB` are the two street edges; null when
+ * their lines are parallel or the corner lies far from both.
+ */
+export declare function sightTriangle(points: readonly Pt[], edgeA: number, edgeB: number, legM: number): {
+    corner: Pt;
+    a: Pt;
+    b: Pt;
+} | null;
+/**
+ * The street corners of a lot: pairs of street edges that meet at a real
+ * turn (40° or more) directly or across a curb-return run of short edges.
+ */
+export declare function streetCorners(points: readonly Pt[], streetEdges: readonly number[]): [number, number][];
+//# sourceMappingURL=setback-envelope.d.ts.map

package/dist/lib/setback-envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setback-envelope.d.ts","sourceRoot":"","sources":["../../src/lib/setback-envelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,MAAM,MAAM,EAAE,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAiC1C,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,GAAG,MAAM,CAE5D;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,SAAI,EAAE,OAAO,SAAK,GAAG,MAAM,EAAE,CAoCjF;AAyJD;;;;;GAKG;AACH,wJAAwJ;AACxJ,MAAM,MAAM,OAAO,GAAG;IAAE,CAAC,EAAE,EAAE,CAAC;IAAC,CAAC,EAAE,EAAE,CAAC;IAAC,MAAM,EAAE,EAAE,CAAA;CAAE,CAAA;AAElD,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,EAAE,EAAE,EACrB,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,SAAS,OAAO,EAAE,CAAA;CAAO,GACtF,EAAE,EAAE,CAwGN;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,SAAS,EAAE,EAAE,EAClB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,SAAS,EAAE,EAAE,GACtB,MAAM,CA8CR;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,EAAE,EAAE,EACrB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GACX;IAAE,MAAM,EAAE,EAAE,CAAC;IAAC,CAAC,EAAE,EAAE,CAAC;IAAC,CAAC,EAAE,EAAE,CAAA;CAAE,GAAG,IAAI,CA0BrC;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,EAAE,EAAE,EACrB,WAAW,EAAE,SAAS,MAAM,EAAE,GAC7B,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAmCpB"}