@bitbybit-dev/ifc 0.0.0-stage → 1.5.0-rc.0

package/lib/build/measure.js

@@ -0,0 +1,195 @@
+import { perimeter2, signedArea2 } from "@bitbybit-dev/base/lib/api/services/helpers/polygons";
+import { length2, subtract2 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import { isList, isReference } from "../step/values";
+import { polylinePoints } from "./curves";
+import { directionOf } from "./placement";
+import { representationOf } from "./representations";
+import { frameOf } from "./solids";
+import { placedOnPlan } from "./math";
+const UPRIGHT_NORMAL = 1e-9;
+const SAME_BOUND = 1e-9;
+const MOMENT_DIVISOR = 6;
+function numberAt(reader, id, attribute) {
+    const value = reader.attribute(id, attribute);
+    return typeof value === "number" ? value : 0;
+}
+function curveOutline(reader, curve) {
+    return isReference(curve) ? polylinePoints(reader, curve.ref) : undefined;
+}
+export function profileShape(reader, profile) {
+    const type = reader.entity(profile).type;
+    if (type === "IfcArbitraryClosedProfileDef" || type === "IfcArbitraryProfileDefWithVoids") {
+        const outer = curveOutline(reader, reader.attribute(profile, "OuterCurve"));
+        if (outer === undefined) {
+            return undefined;
+        }
+        const inner = type === "IfcArbitraryProfileDefWithVoids" ? reader.attribute(profile, "InnerCurves") : null;
+        const holes = (isList(inner) ? inner : []).map((curve) => { var _a; return (_a = curveOutline(reader, curve)) !== null && _a !== void 0 ? _a : []; });
+        const area = Math.abs(signedArea2(outer)) - holes.reduce((sum, hole) => sum + Math.abs(signedArea2(hole)), 0);
+        return { area, perimeter: perimeter2(outer), outline: outer };
+    }
+    if (type === "IfcRectangleProfileDef") {
+        const x = numberAt(reader, profile, "XDim");
+        const y = numberAt(reader, profile, "YDim");
+        const frame = frameOf(reader, reader.attribute(profile, "Position"));
+        const corners = [[-x / 2, -y / 2], [x / 2, -y / 2], [x / 2, y / 2], [-x / 2, y / 2]];
+        const outline = corners.map((corner) => placedOnPlan(frame, corner));
+        return { area: x * y, perimeter: 2 * (x + y), outline };
+    }
+    if (type === "IfcCircleProfileDef") {
+        const radius = numberAt(reader, profile, "Radius");
+        return { area: Math.PI * radius * radius, perimeter: 2 * Math.PI * radius, outline: undefined };
+    }
+    if (type === "IfcIShapeProfileDef") {
+        const width = numberAt(reader, profile, "OverallWidth");
+        const depth = numberAt(reader, profile, "OverallDepth");
+        const web = numberAt(reader, profile, "WebThickness");
+        const flange = numberAt(reader, profile, "FlangeThickness");
+        return { area: 2 * width * flange + (depth - 2 * flange) * web, perimeter: 2 * (2 * width - web + depth), outline: undefined };
+    }
+    return undefined;
+}
+function valueAt(f, point) {
+    return f.a * point[0] + f.b * point[1] + f.c;
+}
+function minus(f, g) {
+    return { a: f.a - g.a, b: f.b - g.b, c: f.c - g.c };
+}
+function clipped(polygon, keep) {
+    const result = [];
+    polygon.forEach((point, index) => {
+        const next = polygon[(index + 1) % polygon.length];
+        const here = valueAt(keep, point);
+        const there = valueAt(keep, next);
+        if (here <= 0) {
+            result.push(point);
+        }
+        if ((here < 0 && there > 0) || (here > 0 && there < 0)) {
+            const fraction = here / (here - there);
+            result.push([point[0] + (next[0] - point[0]) * fraction, point[1] + (next[1] - point[1]) * fraction]);
+        }
+    });
+    return result;
+}
+function integral(polygon, f) {
+    let twiceArea = 0;
+    let x = 0;
+    let y = 0;
+    polygon.forEach((point, index) => {
+        const next = polygon[(index + 1) % polygon.length];
+        const cross = point[0] * next[1] - next[0] * point[1];
+        twiceArea += cross;
+        x += (point[0] + next[0]) * cross;
+        y += (point[1] + next[1]) * cross;
+    });
+    const signed = (f.a * x + f.b * y) / MOMENT_DIVISOR + (f.c * twiceArea) / 2;
+    return twiceArea < 0 ? -signed : signed;
+}
+function distinct(functions) {
+    const same = (f, g) => Math.abs(f.a - g.a) <= SAME_BOUND && Math.abs(f.b - g.b) <= SAME_BOUND && Math.abs(f.c - g.c) <= SAME_BOUND;
+    return functions.filter((f, index) => functions.findIndex((g) => same(f, g)) === index);
+}
+function pairs(bounds) {
+    const tops = distinct(bounds.tops);
+    const bottoms = distinct(bounds.bottoms);
+    return tops.flatMap((top, k) => bottoms.map((bottom, m) => ({
+        top,
+        bottom,
+        keeps: [
+            ...tops.filter((_, j) => j !== k).map((other) => minus(top, other)),
+            ...bottoms.filter((_, j) => j !== m).map((other) => minus(other, bottom)),
+            minus(bottom, top),
+            ...bounds.sides,
+        ],
+    })));
+}
+function within(polygon, keeps) {
+    return keeps.reduce((region, keep) => (region.length ? clipped(region, keep) : region), [...polygon]);
+}
+export function volumeBetween(footprint, bounds) {
+    return pairs(bounds).reduce((sum, { top, bottom, keeps }) => {
+        const region = within(footprint, keeps);
+        return sum + (region.length > 2 ? integral(region, minus(top, bottom)) : 0);
+    }, 0);
+}
+export function areaWithin(footprint, sides) {
+    const region = within(footprint, sides);
+    return region.length > 2 ? integral(region, { a: 0, b: 0, c: 1 }) : 0;
+}
+export function areaBetween(start, end, bounds) {
+    const length = length2(subtract2(end, start));
+    const at = (f, s) => valueAt(f, [start[0] + (end[0] - start[0]) * s, start[1] + (end[1] - start[1]) * s]);
+    let low = 0;
+    let high = 1;
+    for (const side of bounds.sides) {
+        const from = at(side, 0);
+        const to = at(side, 1);
+        if (from === to) {
+            high = from > 0 ? low : high;
+        }
+        else if (to > from) {
+            high = Math.min(high, from / (from - to));
+        }
+        else {
+            low = Math.max(low, from / (from - to));
+        }
+    }
+    if (!(high > low)) {
+        return 0;
+    }
+    const all = [...bounds.tops, ...bounds.bottoms];
+    const breaks = new Set([low, high]);
+    all.forEach((f, i) => all.slice(i + 1).forEach((g) => {
+        const from = at(f, 0) - at(g, 0);
+        const to = at(f, 1) - at(g, 1);
+        const crossing = from === to ? Number.NaN : from / (from - to);
+        if (crossing > low && crossing < high) {
+            breaks.add(crossing);
+        }
+    }));
+    const lowest = (s) => Math.min(...bounds.tops.map((f) => at(f, s)));
+    const highest = (s) => Math.max(...bounds.bottoms.map((f) => at(f, s)));
+    const height = (s) => Math.max(0, lowest(s) - highest(s));
+    const points = [...breaks].sort((a, b) => a - b);
+    return points.slice(1).reduce((sum, to, index) => {
+        const from = points[index];
+        return sum + length * (to - from) * (height(from) + height(to)) / 2;
+    }, 0);
+}
+export function withLevels(bounds, bottom, top) {
+    return { tops: [...bounds.tops, { a: 0, b: 0, c: top }], bottoms: [...bounds.bottoms, { a: 0, b: 0, c: bottom }], sides: bounds.sides };
+}
+export function boundsOf(base, top, planes) {
+    const level = (height) => ({ a: 0, b: 0, c: height });
+    const surface = (plane) => {
+        const [x, y, z] = plane.normal;
+        return { a: -x / z, b: -y / z, c: plane.origin[2] + (plane.origin[0] * x + plane.origin[1] * y) / z };
+    };
+    return {
+        tops: [level(top), ...planes.filter((plane) => plane.normal[2] > UPRIGHT_NORMAL).map(surface)],
+        bottoms: [level(base), ...planes.filter((plane) => plane.normal[2] < -UPRIGHT_NORMAL).map(surface)],
+        sides: planes.filter((plane) => Math.abs(plane.normal[2]) <= UPRIGHT_NORMAL).map((plane) => ({
+            a: plane.normal[0],
+            b: plane.normal[1],
+            c: -(plane.origin[0] * plane.normal[0] + plane.origin[1] * plane.normal[1]),
+        })),
+    };
+}
+export function extrudedBodyOf(reader, product) {
+    const body = representationOf(reader, product, "Body");
+    const items = body === undefined ? null : reader.attribute(body, "Items");
+    const only = isList(items) && items.length === 1 ? items[0] : undefined;
+    if (!isReference(only) || reader.entity(only.ref).type !== "IfcExtrudedAreaSolid") {
+        return undefined;
+    }
+    const solid = only.ref;
+    const profile = reader.attribute(solid, "SweptArea");
+    const depth = reader.attribute(solid, "Depth");
+    const shape = isReference(profile) ? profileShape(reader, profile.ref) : undefined;
+    const direction = directionOf(reader, reader.attribute(solid, "ExtrudedDirection"), [0, 0, 1]);
+    const length = Math.hypot(direction[0], direction[1], direction[2]);
+    if (!shape || typeof depth !== "number" || !(length > 0)) {
+        return undefined;
+    }
+    return { solid, frame: frameOf(reader, reader.attribute(solid, "Position")), depth: depth * Math.abs(direction[2]) / length, shape };
+}

package/lib/build/moving.d.ts

@@ -0,0 +1,4 @@
+import type { Base } from "@bitbybit-dev/base";
+import type { IfcTransaction } from "../model/transaction";
+import type { EntityWriter } from "./entity-writer";
+export declare function moveElement(tx: IfcTransaction, writer: EntityWriter, element: number, translation: Base.Vector3, turnDegrees: number): void;

package/lib/build/moving.js

@@ -0,0 +1,61 @@
+import { WORLD_AXES, relativeAxes } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { isReference } from "../step/values";
+import { DEGREES_TO_RADIANS, FILLING } from "./constants";
+import { absoluteFrame, movePlacement, objectPlacementOf, productsPlacedBy } from "./placement";
+import { firstItem, representationOf, unwrapClippings } from "./representations";
+import { relatingOf } from "./relationships";
+import { describeObject } from "./spatial";
+import { joinsOf } from "./walls";
+const OPENING = "IfcOpeningElement";
+const WALL = "IfcWall";
+const ELEMENT = "IfcElement";
+const SPATIAL_STRUCTURE = "IfcSpatialStructureElement";
+const SPACE = "IfcSpace";
+function refuseUnmovable(reader, element, placement) {
+    const type = reader.entity(element).type;
+    const what = describeObject(reader, element);
+    if (reader.schema.isSubtypeOf(type, OPENING) || relatingOf(reader, FILLING, element) !== undefined) {
+        throw new Error(`${what} moves with its wall: use openings.edit`);
+    }
+    if (reader.schema.isSubtypeOf(type, SPATIAL_STRUCTURE) && !reader.schema.isSubtypeOf(type, SPACE)) {
+        throw new Error(`${what} is part of the model's structure; a storey moves with spatial.setElevation`);
+    }
+    if (reader.schema.isSubtypeOf(type, WALL) && joinsOf(reader, element).length) {
+        throw new Error(`${what} is joined to other walls; move it with walls.edit, which keeps its joins`);
+    }
+    if (reader.schema.isSubtypeOf(type, WALL) && clippingsOf(reader, element).length) {
+        throw new Error(`${what} is clipped; move it with walls.edit, which keeps its clippings where they are`);
+    }
+    const sharer = productsPlacedBy(reader, placement).find((product) => product !== element);
+    if (sharer !== undefined) {
+        throw new Error(`${what} shares its placement with ${describeObject(reader, sharer)}, so it cannot move on its own`);
+    }
+    const parent = reader.attribute(placement, "PlacementRelTo");
+    const host = isReference(parent) ? productsPlacedBy(reader, parent.ref).find((product) => reader.schema.isSubtypeOf(reader.entity(product).type, ELEMENT)) : undefined;
+    if (host !== undefined) {
+        throw new Error(`${what} is placed on ${describeObject(reader, host)} and moves with it`);
+    }
+}
+function clippingsOf(reader, wall) {
+    const body = representationOf(reader, wall, "Body");
+    return body === undefined ? [] : unwrapClippings(reader, firstItem(reader, body))[1];
+}
+function turned(vector, cos, sin) {
+    return [vector[0] * cos - vector[1] * sin, vector[0] * sin + vector[1] * cos, vector[2]];
+}
+export function moveElement(tx, writer, element, translation, turnDegrees) {
+    const placement = objectPlacementOf(tx, element);
+    refuseUnmovable(tx, element, placement);
+    const parent = tx.attribute(placement, "PlacementRelTo");
+    const world = absoluteFrame(tx, placement);
+    const angle = turnDegrees * DEGREES_TO_RADIANS;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const moved = {
+        origin: [world.origin[0] + translation[0], world.origin[1] + translation[1], world.origin[2] + translation[2]],
+        x: turned(world.x, cos, sin),
+        y: turned(world.y, cos, sin),
+        z: turned(world.z, cos, sin),
+    };
+    movePlacement(tx, writer, placement, relativeAxes(isReference(parent) ? absoluteFrame(tx, parent.ref) : WORLD_AXES, moved));
+}

package/lib/build/openings.d.ts

@@ -0,0 +1,12 @@
+import type { IfcTransaction } from "../model/transaction";
+import type { ModelReader, OpeningChange, WallGeometry, WallOpening, WallOpeningPlace, WallOpeningSpec } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+export declare function openingMargin(thickness: number): number;
+export declare function openingBody(tx: IfcTransaction, writer: EntityWriter, width: number, height: number, depth: number): number;
+export declare function createWallOpening(tx: IfcTransaction, writer: EntityWriter, spec: WallOpeningSpec, tolerance: number): WallOpening;
+export declare function openingsOf(reader: ModelReader, element: number): number[];
+export declare function fillingsOf(reader: ModelReader, opening: number): number[];
+export declare function readWallOpening(reader: ModelReader, wall: WallGeometry, wallPlacement: number, opening: number, tolerance: number): WallOpeningPlace | undefined;
+export declare function carriedWith(reader: ModelReader, opening: number, wallPlacement: number): boolean;
+export declare function carryOpening(tx: IfcTransaction, writer: EntityWriter, place: WallOpeningPlace, next: WallOpeningPlace, before: WallGeometry, after: WallGeometry): void;
+export declare function editWallOpening(tx: IfcTransaction, writer: EntityWriter, element: number, change: OpeningChange, tolerance: number): void;

package/lib/build/openings.js

@@ -0,0 +1,156 @@
+import { composeAxes, pointToLocal, pointToWorld, relativeAxes } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { enumValue, isList, isReference, ref } from "../step/values";
+import { FILLING, OPENING_MARGIN_RATIO, VOIDING } from "./constants";
+import { movePlacement, objectPlacementOf, parentPlacementOf, relativeFrame } from "./placement";
+import { relatingOf } from "./relationships";
+import { describeObject } from "./spatial";
+import { bodyContext } from "./contexts";
+import { extrusionCorners } from "./solids";
+import { axisFrame, readWall } from "./wall-geometry";
+import { replaceRepresentation, representationOf } from "./representations";
+const OPENING = "IfcOpeningElement";
+const WALL = "IfcWall";
+export function openingMargin(thickness) {
+    return thickness * OPENING_MARGIN_RATIO;
+}
+export function openingBody(tx, writer, width, height, depth) {
+    const profile = writer.create("IfcRectangleProfileDef", {
+        ProfileType: enumValue("AREA"),
+        Position: ref(writer.placement2([width / 2, height / 2])),
+        XDim: width,
+        YDim: height,
+    });
+    const solid = writer.extrusion(profile, { origin: [0, 0, 0], x: [1, 0, 0], y: [0, 0, 1], z: [0, -1, 0] }, depth);
+    return writer.shapeRepresentation(bodyContext(tx, writer), "Body", "SweptSolid", [solid]);
+}
+function frameAt(wall, offset, sill, across) {
+    const axis = axisFrame(wall);
+    return Object.assign(Object.assign({}, axis), { origin: pointToWorld(axis, [offset, across, sill]) });
+}
+function openingFrame(wall, offset, sill) {
+    return frameAt(wall, offset, sill, wall.high + openingMargin(wall.high - wall.low));
+}
+function middleFrame(wall, offset, sill) {
+    return frameAt(wall, offset, sill, (wall.low + wall.high) / 2);
+}
+function requireFit(wall, offset, width, height, tolerance) {
+    if (!(width > 0) || !(height > 0)) {
+        throw new Error(`An opening needs a width and a height of more than zero, got ${width} by ${height}`);
+    }
+    if (offset < -tolerance || offset + width > wall.length + tolerance) {
+        throw new Error(`The opening from ${offset} to ${offset + width} does not fit along the wall, which is ${wall.length} long`);
+    }
+}
+export function createWallOpening(tx, writer, spec, tolerance) {
+    var _a;
+    const wall = readWall(tx, spec.wall);
+    requireFit(wall, spec.offset, spec.width, spec.height, tolerance);
+    const thickness = wall.high - wall.low;
+    const margin = openingMargin(thickness);
+    const placement = writer.localPlacement(objectPlacementOf(tx, spec.wall), openingFrame(wall, spec.offset, spec.sill));
+    const opening = writer.create("IfcOpeningElement", {
+        GlobalId: tx.globalId(spec.id),
+        Name: (_a = spec.name) !== null && _a !== void 0 ? _a : null,
+        ObjectPlacement: ref(placement),
+        Representation: ref(writer.productShape([openingBody(tx, writer, spec.width, spec.height, thickness + 2 * margin)])),
+        PredefinedType: enumValue("OPENING"),
+    });
+    writer.create(VOIDING.relationship, { GlobalId: tx.globalId(undefined), [VOIDING.relating]: ref(spec.wall), [VOIDING.related]: ref(opening) });
+    return { opening, placement, wallFace: -(thickness + margin), thickness };
+}
+export function openingsOf(reader, element) {
+    return reader.referencesTo(element).flatMap((user) => {
+        const relating = reader.typeOf(user) === VOIDING.relationship ? reader.attribute(user, VOIDING.relating) : null;
+        const opening = isReference(relating) && relating.ref === element ? reader.attribute(user, VOIDING.related) : null;
+        return isReference(opening) ? [opening.ref] : [];
+    });
+}
+export function fillingsOf(reader, opening) {
+    return reader.referencesTo(opening).flatMap((user) => {
+        const relating = reader.typeOf(user) === FILLING.relationship ? reader.attribute(user, FILLING.relating) : null;
+        const filling = isReference(relating) && relating.ref === opening ? reader.attribute(user, FILLING.related) : null;
+        return isReference(filling) ? [filling.ref] : [];
+    });
+}
+function bodyCorners(reader, opening) {
+    const body = representationOf(reader, opening, "Body");
+    const items = body === undefined ? null : reader.attribute(body, "Items");
+    const only = isList(items) && items.length === 1 ? items[0] : undefined;
+    return isReference(only) ? extrusionCorners(reader, only.ref) : [];
+}
+function spanOf(values, tolerance) {
+    const low = Math.min(...values);
+    const high = Math.max(...values);
+    return values.every((value) => Math.abs(value - low) <= tolerance || Math.abs(value - high) <= tolerance) ? [low, high] : undefined;
+}
+export function readWallOpening(reader, wall, wallPlacement, opening, tolerance) {
+    if (parentPlacementOf(reader, opening) !== wallPlacement) {
+        return undefined;
+    }
+    const placement = objectPlacementOf(reader, opening);
+    const axis = axisFrame(wall);
+    const frame = relativeFrame(reader, placement);
+    const local = bodyCorners(reader, opening).map((corner) => pointToLocal(axis, pointToWorld(frame, corner)));
+    const along = spanOf(local.map((point) => point[0]), tolerance);
+    const across = spanOf(local.map((point) => point[1]), tolerance);
+    const up = spanOf(local.map((point) => point[2]), tolerance);
+    if (!local.length || !along || !across || !up || across[0] > wall.low + tolerance || across[1] < wall.high - tolerance) {
+        return undefined;
+    }
+    return { opening, placement, offset: along[0], sill: up[0], width: along[1] - along[0], height: up[1] - up[0] };
+}
+export function carriedWith(reader, opening, wallPlacement) {
+    if (parentPlacementOf(reader, opening) !== wallPlacement) {
+        return false;
+    }
+    const own = objectPlacementOf(reader, opening);
+    return fillingsOf(reader, opening).every((filling) => {
+        const parent = parentPlacementOf(reader, filling);
+        return parent === own || parent === wallPlacement;
+    });
+}
+export function carryOpening(tx, writer, place, next, before, after) {
+    const thickness = after.high - after.low;
+    const from = relativeFrame(tx, place.placement);
+    const to = openingFrame(after, next.offset, next.sill);
+    const fromMiddle = middleFrame(before, place.offset, place.sill);
+    const toMiddle = middleFrame(after, next.offset, next.sill);
+    movePlacement(tx, writer, place.placement, to);
+    replaceRepresentation(tx, place.opening, representationOf(tx, place.opening, "Body"), openingBody(tx, writer, next.width, next.height, thickness + 2 * openingMargin(thickness)));
+    for (const filling of fillingsOf(tx, place.opening).filter((placed) => objectPlacementOf(tx, placed) !== place.placement)) {
+        const placement = objectPlacementOf(tx, filling);
+        const onOpening = parentPlacementOf(tx, filling) === place.placement;
+        const inWall = composeAxes(toMiddle, relativeAxes(fromMiddle, onOpening ? composeAxes(from, relativeFrame(tx, placement)) : relativeFrame(tx, placement)));
+        movePlacement(tx, writer, placement, onOpening ? relativeAxes(to, inWall) : inWall);
+    }
+}
+function openingOf(reader, element) {
+    if (reader.schema.isSubtypeOf(reader.entity(element).type, OPENING)) {
+        return element;
+    }
+    const opening = relatingOf(reader, FILLING, element);
+    if (opening === undefined) {
+        throw new Error(`${describeObject(reader, element)} is neither an opening nor a door or window in one`);
+    }
+    return opening;
+}
+export function editWallOpening(tx, writer, element, change, tolerance) {
+    var _a, _b, _c, _d;
+    const opening = openingOf(tx, element);
+    const host = relatingOf(tx, VOIDING, opening);
+    if (host === undefined || !tx.schema.isSubtypeOf(tx.entity(host).type, WALL)) {
+        throw new Error(`${describeObject(tx, opening)} is not an opening in a wall`);
+    }
+    const wall = readWall(tx, host);
+    const wallPlacement = objectPlacementOf(tx, host);
+    const place = readWallOpening(tx, wall, wallPlacement, opening, tolerance);
+    if (place === undefined || !carriedWith(tx, opening, wallPlacement)) {
+        throw new Error(`${describeObject(tx, opening)} is not an opening this library can move`);
+    }
+    if (fillingsOf(tx, opening).length && (change.width !== undefined || change.height !== undefined)) {
+        throw new Error(`${describeObject(tx, opening)} takes its size from the door or window in it`);
+    }
+    const next = Object.assign(Object.assign({}, place), { offset: (_a = change.offset) !== null && _a !== void 0 ? _a : place.offset, sill: (_b = change.sill) !== null && _b !== void 0 ? _b : place.sill, width: (_c = change.width) !== null && _c !== void 0 ? _c : place.width, height: (_d = change.height) !== null && _d !== void 0 ? _d : place.height });
+    requireFit(wall, next.offset, next.width, next.height, tolerance);
+    carryOpening(tx, writer, place, next, wall, wall);
+}

package/lib/build/outlines.d.ts

@@ -0,0 +1,4 @@
+import type { Base } from "@bitbybit-dev/base";
+export declare function cleanOutline(points: readonly Base.Point2[], tolerance: number, what: string): Base.Point2[];
+export declare function isInsideOrOn(point: Base.Point2, outline: readonly Base.Point2[], tolerance: number): boolean;
+export declare function edgesCross(first: readonly Base.Point2[], second: readonly Base.Point2[], tolerance: number): boolean;

package/lib/build/outlines.js

@@ -0,0 +1,40 @@
+import { isInsidePolygon2, signedArea2 } from "@bitbybit-dev/base/lib/api/services/helpers/polygons";
+import { cross2, length2, subtract2 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import { MIN_OUTLINE_POINTS } from "./constants";
+import { distanceToSegment } from "./math";
+export function cleanOutline(points, tolerance, what) {
+    const first = points[0];
+    const last = points[points.length - 1];
+    const open = first && last && points.length > 1 && length2(subtract2(first, last)) <= tolerance ? points.slice(0, -1) : [...points];
+    if (open.length < MIN_OUTLINE_POINTS) {
+        throw new Error(`The ${what} needs at least ${MIN_OUTLINE_POINTS} distinct points, got ${open.length}`);
+    }
+    open.forEach((point, index) => {
+        const next = open[(index + 1) % open.length];
+        if (length2(subtract2(next, point)) <= tolerance) {
+            throw new Error(`The ${what} repeats its point ${index} at ${index + 1}, which leaves a side of no length`);
+        }
+    });
+    if (!(Math.abs(signedArea2(open)) > tolerance * tolerance)) {
+        throw new Error(`The ${what} must enclose an area`);
+    }
+    return open;
+}
+export function isInsideOrOn(point, outline, tolerance) {
+    return isInsidePolygon2(point, outline) || outline.some((corner, index) => distanceToSegment(point, corner, outline[(index + 1) % outline.length]) <= tolerance);
+}
+function sideOf(point, start, end) {
+    return cross2(subtract2(end, start), subtract2(point, start)) / length2(subtract2(end, start));
+}
+function apart(first, second, tolerance) {
+    return (first > tolerance && second < -tolerance) || (first < -tolerance && second > tolerance);
+}
+export function edgesCross(first, second, tolerance) {
+    return first.some((a, i) => {
+        const b = first[(i + 1) % first.length];
+        return second.some((c, j) => {
+            const d = second[(j + 1) % second.length];
+            return apart(sideOf(c, a, b), sideOf(d, a, b), tolerance) && apart(sideOf(a, c, d), sideOf(b, c, d), tolerance);
+        });
+    });
+}

package/lib/build/placement.d.ts

@@ -0,0 +1,16 @@
+import type { Base } from "@bitbybit-dev/base";
+import type { IfcTransaction } from "../model/transaction";
+import type { IfcValue } from "../step/step-types";
+import type { EntityReader, ModelReader } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+import type { Frame3 } from "./build-types";
+export declare function numbersOf(value: IfcValue, what: string): readonly number[];
+export declare function pointOf(reader: EntityReader, value: IfcValue): Base.Point3;
+export declare function directionOf(reader: EntityReader, value: IfcValue, fallback: Base.Vector3): Base.Vector3;
+export declare function axisPlacementFrame(reader: EntityReader, placement: number): Frame3;
+export declare function relativeFrame(reader: EntityReader, localPlacement: number): Frame3;
+export declare function absoluteFrame(reader: EntityReader, localPlacement: number, known?: Map<number, Frame3>): Frame3;
+export declare function objectPlacementOf(reader: EntityReader, product: number): number;
+export declare function parentPlacementOf(reader: EntityReader, product: number): number | undefined;
+export declare function movePlacement(tx: IfcTransaction, writer: EntityWriter, placement: number, frame: Frame3): void;
+export declare function productsPlacedBy(reader: ModelReader, placement: number): number[];

package/lib/build/placement.js

@@ -0,0 +1,106 @@
+import { WORLD_AXES, composeAxes } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { isList, isReference, ref } from "../step/values";
+import { frameFrom } from "./math";
+const MAX_PLACEMENT_DEPTH = 256;
+const PRODUCT = "IfcProduct";
+const LOCAL_PLACEMENT = "IfcLocalPlacement";
+export function numbersOf(value, what) {
+    if (!isList(value) || !value.every((item) => typeof item === "number" && Number.isFinite(item))) {
+        throw new Error(`${what} is not a list of finite numbers`);
+    }
+    return value;
+}
+export function pointOf(reader, value) {
+    var _a, _b, _c;
+    if (!isReference(value)) {
+        throw new Error("A point is missing");
+    }
+    const coordinates = numbersOf(reader.attribute(value.ref, "Coordinates"), `#${value.ref} Coordinates`);
+    return [(_a = coordinates[0]) !== null && _a !== void 0 ? _a : 0, (_b = coordinates[1]) !== null && _b !== void 0 ? _b : 0, (_c = coordinates[2]) !== null && _c !== void 0 ? _c : 0];
+}
+export function directionOf(reader, value, fallback) {
+    var _a, _b, _c;
+    if (!isReference(value)) {
+        return fallback;
+    }
+    const ratios = numbersOf(reader.attribute(value.ref, "DirectionRatios"), `#${value.ref} DirectionRatios`);
+    return [(_a = ratios[0]) !== null && _a !== void 0 ? _a : 0, (_b = ratios[1]) !== null && _b !== void 0 ? _b : 0, (_c = ratios[2]) !== null && _c !== void 0 ? _c : 0];
+}
+export function axisPlacementFrame(reader, placement) {
+    const entity = reader.entity(placement);
+    if (entity.type !== "IfcAxis2Placement2D" && entity.type !== "IfcAxis2Placement3D") {
+        throw new Error(`#${placement} is an ${entity.type}, not an axis placement`);
+    }
+    const origin = pointOf(reader, reader.attribute(placement, "Location"));
+    if (entity.type === "IfcAxis2Placement2D") {
+        const x = directionOf(reader, reader.attribute(placement, "RefDirection"), [1, 0, 0]);
+        return frameFrom(origin, [0, 0, 1], [x[0], x[1], 0]);
+    }
+    const z = directionOf(reader, reader.attribute(placement, "Axis"), [0, 0, 1]);
+    const alongX = Math.abs(z[1]) + Math.abs(z[2]) === 0;
+    const x = directionOf(reader, reader.attribute(placement, "RefDirection"), alongX ? [0, 1, 0] : [1, 0, 0]);
+    return frameFrom(origin, z, x);
+}
+export function relativeFrame(reader, localPlacement) {
+    const relative = reader.attribute(localPlacement, "RelativePlacement");
+    if (!isReference(relative)) {
+        throw new Error(`#${localPlacement} has no relative placement`);
+    }
+    return axisPlacementFrame(reader, relative.ref);
+}
+export function absoluteFrame(reader, localPlacement, known) {
+    const chain = [];
+    const seen = new Set();
+    let base = WORLD_AXES;
+    for (let current = localPlacement; current !== undefined;) {
+        const placed = known === null || known === void 0 ? void 0 : known.get(current);
+        if (placed) {
+            base = placed;
+            break;
+        }
+        if (seen.has(current) || chain.length > MAX_PLACEMENT_DEPTH) {
+            throw new Error(`The placement #${localPlacement} is relative to itself through #${current}`);
+        }
+        seen.add(current);
+        if (reader.entity(current).type !== LOCAL_PLACEMENT) {
+            throw new Error(`#${current} is a ${reader.entity(current).type}, which this library does not place`);
+        }
+        chain.unshift(current);
+        const parent = reader.attribute(current, "PlacementRelTo");
+        current = isReference(parent) ? parent.ref : undefined;
+    }
+    return chain.reduce((frame, placement) => {
+        const placed = composeAxes(frame, relativeFrame(reader, placement));
+        known === null || known === void 0 ? void 0 : known.set(placement, placed);
+        return placed;
+    }, base);
+}
+export function objectPlacementOf(reader, product) {
+    const placement = reader.attribute(product, "ObjectPlacement");
+    if (!isReference(placement)) {
+        throw new Error(`#${product} has no placement`);
+    }
+    return placement.ref;
+}
+export function parentPlacementOf(reader, product) {
+    const placement = reader.attribute(product, "ObjectPlacement");
+    const parent = isReference(placement) && reader.entity(placement.ref).type === LOCAL_PLACEMENT ? reader.attribute(placement.ref, "PlacementRelTo") : null;
+    return isReference(parent) ? parent.ref : undefined;
+}
+export function movePlacement(tx, writer, placement, frame) {
+    const old = tx.attribute(placement, "RelativePlacement");
+    tx.update(placement, { RelativePlacement: ref(writer.placement3(frame)) });
+    if (isReference(old)) {
+        tx.dropIfUnused([old.ref]);
+    }
+}
+export function productsPlacedBy(reader, placement) {
+    return reader.referencesTo(placement).filter((user) => {
+        var _a;
+        if (!reader.schema.isSubtypeOf((_a = reader.typeOf(user)) !== null && _a !== void 0 ? _a : "", PRODUCT)) {
+            return false;
+        }
+        const placed = reader.attribute(user, "ObjectPlacement");
+        return isReference(placed) && placed.ref === placement;
+    });
+}

package/lib/build/profiles.d.ts

@@ -0,0 +1,4 @@
+import type { ProfileSpec } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+export declare function checkProfile(profile: ProfileSpec): void;
+export declare function writeProfile(writer: EntityWriter, profile: ProfileSpec, name: string | undefined): number;

package/lib/build/profiles.js

@@ -0,0 +1,35 @@
+import * as Inputs from "../api/inputs";
+import { enumValue, ref } from "../step/values";
+import { requirePositive } from "./checks";
+export function checkProfile(profile) {
+    if (profile.kind === Inputs.IFC.profileKindEnum.rectangle) {
+        requirePositive(profile.width, "profile's width");
+        requirePositive(profile.depth, "profile's depth");
+    }
+    else if (profile.kind === Inputs.IFC.profileKindEnum.circle) {
+        requirePositive(profile.radius, "profile's radius");
+    }
+    else {
+        requirePositive(profile.width, "profile's width");
+        requirePositive(profile.depth, "profile's depth");
+        requirePositive(profile.webThickness, "profile's web thickness");
+        requirePositive(profile.flangeThickness, "profile's flange thickness");
+        if (profile.webThickness >= profile.width) {
+            throw new Error("An I section's web must be thinner than its flanges are wide");
+        }
+        if (2 * profile.flangeThickness >= profile.depth) {
+            throw new Error("An I section's two flanges must be thinner together than its depth");
+        }
+    }
+}
+export function writeProfile(writer, profile, name) {
+    checkProfile(profile);
+    const common = { ProfileType: enumValue("AREA"), ProfileName: name !== null && name !== void 0 ? name : null, Position: ref(writer.placement2([0, 0])) };
+    if (profile.kind === Inputs.IFC.profileKindEnum.rectangle) {
+        return writer.create("IfcRectangleProfileDef", Object.assign(Object.assign({}, common), { XDim: profile.width, YDim: profile.depth }));
+    }
+    if (profile.kind === Inputs.IFC.profileKindEnum.circle) {
+        return writer.create("IfcCircleProfileDef", Object.assign(Object.assign({}, common), { Radius: profile.radius }));
+    }
+    return writer.create("IfcIShapeProfileDef", Object.assign(Object.assign({}, common), { OverallWidth: profile.width, OverallDepth: profile.depth, WebThickness: profile.webThickness, FlangeThickness: profile.flangeThickness }));
+}

package/lib/build/project.d.ts

@@ -0,0 +1,11 @@
+import type { ModelSnapshot } from "../model/snapshot";
+import * as Inputs from "../api/inputs";
+import type { MeasuredUnit, NewProject } from "./build-types";
+export declare const SCHEMA_FOR_NEW_MODELS = "IFC4";
+export declare const DESIGN_TRANSFER_VIEW = "ViewDefinition [DesignTransferView_V1.0]";
+export declare function precisionFor(unit: Inputs.IFC.lengthUnitEnum): number;
+export declare function createProject(project: NewProject): ModelSnapshot;
+export declare function projectOf(model: ModelSnapshot): number;
+export declare function siPerUnit(model: ModelSnapshot, unitType: MeasuredUnit): number;
+export declare function millimetresPerUnit(model: ModelSnapshot): number;
+export declare function radiansPerUnit(model: ModelSnapshot): number;