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

package/lib/build/relationships.js

@@ -0,0 +1,67 @@
+import { isList, isReference, ref } from "../step/values";
+const SCANNED_LIST_LENGTH = 32;
+const listMembers = new WeakMap();
+function listHolds(list, id) {
+    if (list.length < SCANNED_LIST_LENGTH) {
+        return list.some((item) => isReference(item) && item.ref === id);
+    }
+    let members = listMembers.get(list);
+    if (!members) {
+        members = new Set(list.filter(isReference).map((item) => item.ref));
+        listMembers.set(list, members);
+    }
+    return members.has(id);
+}
+function refersTo(reader, relationship, attribute, id) {
+    const value = reader.attribute(relationship, attribute);
+    return isReference(value) ? value.ref === id : isList(value) && listHolds(value, id);
+}
+function relationshipsWhere(reader, roles, attribute, id) {
+    return reader.referencesTo(id).filter((user) => reader.typeOf(user) === roles.relationship && refersTo(reader, user, attribute, id));
+}
+export function relatingOf(reader, roles, part) {
+    const relationship = relationshipsWhere(reader, roles, roles.related, part)[0];
+    if (relationship === undefined) {
+        return undefined;
+    }
+    const whole = reader.attribute(relationship, roles.relating);
+    return isReference(whole) ? whole.ref : undefined;
+}
+export function relationshipsOf(reader, roles, whole) {
+    return relationshipsWhere(reader, roles, roles.relating, whole);
+}
+export function relate(tx, writer, roles, whole, parts) {
+    return writer.create(roles.relationship, { GlobalId: tx.globalId(undefined), [roles.relating]: ref(whole), [roles.related]: parts.map(ref) });
+}
+export function appendToRelationship(tx, writer, roles, whole, parts) {
+    const existing = relationshipsOf(tx, roles, whole)[0];
+    if (existing === undefined) {
+        return relate(tx, writer, roles, whole, parts);
+    }
+    const current = tx.attribute(existing, roles.related);
+    tx.update(existing, { [roles.related]: [...(isList(current) ? current : []), ...parts.map(ref)] });
+    return existing;
+}
+export function detach(tx, roles, part) {
+    const emptied = [];
+    for (const relationship of relationshipsWhere(tx, roles, roles.related, part)) {
+        const current = tx.attribute(relationship, roles.related);
+        const remaining = isList(current) ? current.filter((item) => !(isReference(item) && item.ref === part)) : [];
+        if (remaining.length) {
+            tx.update(relationship, { [roles.related]: remaining });
+            continue;
+        }
+        const whole = tx.attribute(relationship, roles.relating);
+        tx.delete(relationship);
+        if (isReference(whole)) {
+            emptied.push(whole.ref);
+        }
+    }
+    return emptied;
+}
+export function relatedOf(reader, roles, whole) {
+    return relationshipsOf(reader, roles, whole).flatMap((relationship) => {
+        const value = reader.attribute(relationship, roles.related);
+        return (isList(value) ? value : [value]).filter(isReference).map((item) => item.ref);
+    });
+}

package/lib/build/removal.d.ts

@@ -0,0 +1,3 @@
+import type { IfcTransaction } from "../model/transaction";
+import type { EntityWriter } from "./entity-writer";
+export declare function removeObject(tx: IfcTransaction, writer: EntityWriter, object: number, tolerance: number, parallelTolerance: number): void;

package/lib/build/removal.js

@@ -0,0 +1,106 @@
+import { isList, isReference, referencesIn } from "../step/values";
+import { AGGREGATION, CONTAINMENT, TYPE_DEFINITION } from "./constants";
+import { fillingsOf, openingsOf } from "./openings";
+import { relatedOf } from "./relationships";
+import { describeObject } from "./spatial";
+import { readableWall } from "./wall-geometry";
+import { joinsOf, regenerateWall } from "./walls";
+const RELATIONSHIP = "IfcRelationship";
+const KEPT_STRUCTURE = ["IfcProject", "IfcSite", "IfcBuilding"];
+const SPATIAL_ELEMENT = "IfcSpatialElement";
+const TYPE_OBJECT = "IfcTypeObject";
+const WALL = "IfcWall";
+function partsOf(reader, whole) {
+    return relatedOf(reader, AGGREGATION, whole);
+}
+function counted(count, what) {
+    return `${count} ${what}${count === 1 ? "" : "s"}`;
+}
+function refuseKept(reader, object) {
+    const type = reader.entity(object).type;
+    if (KEPT_STRUCTURE.some((kept) => reader.schema.isSubtypeOf(type, kept))) {
+        throw new Error(`${describeObject(reader, object)} is part of the model's structure and is not removed`);
+    }
+    if (reader.schema.isSubtypeOf(type, SPATIAL_ELEMENT)) {
+        const held = relatedOf(reader, CONTAINMENT, object).length + partsOf(reader, object).length;
+        if (held) {
+            throw new Error(`${describeObject(reader, object)} still holds ${counted(held, "object")}; remove them first`);
+        }
+    }
+    if (reader.schema.isSubtypeOf(type, TYPE_OBJECT)) {
+        const occurrences = relatedOf(reader, TYPE_DEFINITION, object).length;
+        if (occurrences) {
+            throw new Error(`${describeObject(reader, object)} is the type of ${counted(occurrences, "element")}; remove them first`);
+        }
+    }
+}
+function removalOf(reader, object) {
+    refuseKept(reader, object);
+    const removing = new Set();
+    const work = [object];
+    while (work.length) {
+        const id = work.pop();
+        if (removing.has(id)) {
+            continue;
+        }
+        removing.add(id);
+        work.push(...openingsOf(reader, id), ...fillingsOf(reader, id));
+        if (!reader.schema.isSubtypeOf(reader.entity(id).type, SPATIAL_ELEMENT)) {
+            work.push(...partsOf(reader, id));
+        }
+    }
+    return removing;
+}
+function unlink(tx, id, removing) {
+    const freed = [];
+    for (const user of [...tx.referencesTo(id)]) {
+        const entity = tx.get(user);
+        if (!entity || removing.has(user) || !tx.schema.isSubtypeOf(entity.type, RELATIONSHIP)) {
+            continue;
+        }
+        const changes = [];
+        let emptied = false;
+        tx.schema.entity(entity.type).attributes.forEach((attribute, index) => {
+            var _a;
+            const value = (_a = entity.args[index]) !== null && _a !== void 0 ? _a : null;
+            const goes = (item) => isReference(item) && removing.has(item.ref);
+            if (goes(value)) {
+                emptied = true;
+            }
+            else if (isList(value) && value.some(goes)) {
+                const remaining = value.filter((item) => !goes(item));
+                emptied || (emptied = remaining.length === 0);
+                changes.push([attribute.name, remaining]);
+            }
+        });
+        if (emptied) {
+            freed.push(...entity.args.flatMap((arg) => referencesIn(arg)));
+            tx.delete(user);
+        }
+        else if (changes.length) {
+            tx.update(user, Object.fromEntries(changes));
+        }
+    }
+    return freed;
+}
+export function removeObject(tx, writer, object, tolerance, parallelTolerance) {
+    var _a;
+    const removing = removalOf(tx, object);
+    const trimmed = new Set();
+    for (const id of removing) {
+        if (tx.schema.isSubtypeOf(tx.entity(id).type, WALL)) {
+            joinsOf(tx, id).filter((join) => join.theirs !== "ATPATH" && !removing.has(join.other)).forEach((join) => trimmed.add(join.other));
+        }
+    }
+    const freed = [];
+    for (const id of removing) {
+        freed.push(...unlink(tx, id, removing), ...tx.entity(id).args.flatMap((arg) => referencesIn(arg)));
+    }
+    removing.forEach((id) => tx.delete(id));
+    tx.dropIfUnused(freed.filter((id) => !removing.has(id)));
+    for (const wall of trimmed) {
+        if (((_a = readableWall(tx, wall)) === null || _a === void 0 ? void 0 : _a.body) !== undefined) {
+            regenerateWall(tx, writer, wall, tolerance, parallelTolerance);
+        }
+    }
+}

package/lib/build/representations.d.ts

@@ -0,0 +1,6 @@
+import type { IfcTransaction } from "../model/transaction";
+import type { ModelReader } from "./build-types";
+export declare function representationOf(reader: ModelReader, product: number, identifier: string): number | undefined;
+export declare function firstItem(reader: ModelReader, representation: number): number;
+export declare function unwrapClippings(reader: ModelReader, item: number): [number, number[]];
+export declare function replaceRepresentation(tx: IfcTransaction, product: number, oldRepresentation: number | undefined, newRepresentation: number): void;

package/lib/build/representations.js

@@ -0,0 +1,46 @@
+import { isList, isReference, ref } from "../step/values";
+import { requiredReference } from "./checks";
+export function representationOf(reader, product, identifier) {
+    const shape = reader.attribute(product, "Representation");
+    if (!isReference(shape)) {
+        return undefined;
+    }
+    const representations = reader.attribute(shape.ref, "Representations");
+    for (const representation of isList(representations) ? representations : []) {
+        if (isReference(representation) && reader.attribute(representation.ref, "RepresentationIdentifier") === identifier) {
+            return representation.ref;
+        }
+    }
+    return undefined;
+}
+export function firstItem(reader, representation) {
+    const items = reader.attribute(representation, "Items");
+    const first = isList(items) ? items[0] : undefined;
+    if (!isReference(first)) {
+        throw new Error(`#${representation} holds no items`);
+    }
+    return first.ref;
+}
+export function unwrapClippings(reader, item) {
+    const halfSpaces = [];
+    let current = item;
+    while (reader.entity(current).type === "IfcBooleanClippingResult") {
+        const second = reader.attribute(current, "SecondOperand");
+        const first = reader.attribute(current, "FirstOperand");
+        if (!isReference(second) || !isReference(first)) {
+            throw new Error(`#${current} is a clipping without operands`);
+        }
+        halfSpaces.unshift(second.ref);
+        current = first.ref;
+    }
+    return [current, halfSpaces];
+}
+export function replaceRepresentation(tx, product, oldRepresentation, newRepresentation) {
+    const shape = requiredReference(tx, product, "Representation");
+    const representations = tx.attribute(shape, "Representations");
+    const kept = (isList(representations) ? representations : []).filter((item) => !(isReference(item) && item.ref === oldRepresentation));
+    tx.update(shape, { Representations: [...kept, ref(newRepresentation)] });
+    if (oldRepresentation !== undefined) {
+        tx.dropIfUnused([oldRepresentation]);
+    }
+}

package/lib/build/roof-clipping.d.ts

@@ -0,0 +1,5 @@
+import type { IfcTransaction } from "../model/transaction";
+import type { ModelReader, Plane3, WallGeometry } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+export declare function clippingPlanes(reader: ModelReader, wall: WallGeometry, body: number): Plane3[];
+export declare function clipWallByRoof(tx: IfcTransaction, writer: EntityWriter, wall: number, roof: number, tolerance: number): void;

package/lib/build/roof-clipping.js

@@ -0,0 +1,79 @@
+import { composeAxes, vectorToWorld } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { add2, dot3, scale2, scale3 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import { isReference } from "../step/values";
+import { AGGREGATION, VERTICAL_COSINE } from "./constants";
+import { normalize3 } from "./math";
+import { absoluteFrame, axisPlacementFrame, directionOf, objectPlacementOf } from "./placement";
+import { relatedOf } from "./relationships";
+import { firstItem, representationOf, unwrapClippings } from "./representations";
+import { frameOf } from "./solids";
+import { describeObject } from "./spatial";
+import { readWall, sideLine } from "./wall-geometry";
+import { clipWall } from "./walls";
+function undersideOf(reader, part) {
+    const body = representationOf(reader, part, "Body");
+    const [solid] = body === undefined ? [undefined] : unwrapClippings(reader, firstItem(reader, body));
+    if (solid === undefined || reader.entity(solid).type !== "IfcExtrudedAreaSolid") {
+        throw new Error(`${describeObject(reader, part)} has no body this library clips with: an outline extruded through the roof is expected`);
+    }
+    const frame = composeAxes(absoluteFrame(reader, objectPlacementOf(reader, part)), frameOf(reader, reader.attribute(solid, "Position")));
+    if (Math.abs(frame.z[2]) < 1 - VERTICAL_COSINE) {
+        throw new Error(`${describeObject(reader, part)} stands upright, so it is no roof plane to clip with`);
+    }
+    const up = frame.z[2] > 0 ? frame.z : scale3(frame.z, -1);
+    const depth = reader.attribute(solid, "Depth");
+    const through = vectorToWorld(frame, normalize3(directionOf(reader, reader.attribute(solid, "ExtrudedDirection"), [0, 0, 1])));
+    const far = scale3(through, typeof depth === "number" ? depth : 0);
+    const farPoint = [frame.origin[0] + far[0], frame.origin[1] + far[1], frame.origin[2] + far[2]];
+    return { origin: dot3(farPoint, up) < dot3(frame.origin, up) ? farPoint : frame.origin, normal: up };
+}
+function heightAt(plane, point) {
+    const [x, y, z] = plane.normal;
+    return plane.origin[2] - ((point[0] - plane.origin[0]) * x + (point[1] - plane.origin[1]) * y) / z;
+}
+function footprintCorners(wall) {
+    return [wall.low, wall.high].flatMap((across) => {
+        const side = sideLine(wall, across);
+        return [side.point, add2(side.point, scale2(side.direction, wall.length))];
+    });
+}
+export function clippingPlanes(reader, wall, body) {
+    return unwrapClippings(reader, firstItem(reader, body))[1].flatMap((halfSpace) => {
+        const surface = reader.attribute(halfSpace, "BaseSurface");
+        const position = isReference(surface) && reader.entity(surface.ref).type === "IfcPlane" ? reader.attribute(surface.ref, "Position") : null;
+        if (!isReference(position)) {
+            return [];
+        }
+        const frame = composeAxes(wall.frame, axisPlacementFrame(reader, position.ref));
+        return [{ origin: frame.origin, normal: reader.attribute(halfSpace, "AgreementFlag") === true ? scale3(frame.z, -1) : frame.z }];
+    });
+}
+function samePlane(a, b, tolerance) {
+    const offset = (plane) => dot3(plane.origin, plane.normal);
+    return dot3(a.normal, b.normal) >= VERTICAL_COSINE && Math.abs(offset(a) - offset(b)) <= tolerance;
+}
+export function clipWallByRoof(tx, writer, wall, roof, tolerance) {
+    const parts = relatedOf(tx, AGGREGATION, roof);
+    if (!parts.length) {
+        throw new Error(`${describeObject(tx, roof)} has no parts to clip a wall with`);
+    }
+    const geometry = readWall(tx, wall);
+    if (geometry.body === undefined) {
+        throw new Error(`${describeObject(tx, wall)} has no body to clip`);
+    }
+    const bottom = geometry.frame.origin[2] + geometry.base;
+    const top = bottom + geometry.height;
+    const corners = footprintCorners(geometry);
+    const existing = clippingPlanes(tx, geometry, geometry.body);
+    for (const part of parts) {
+        const plane = undersideOf(tx, part);
+        const heights = corners.map((corner) => heightAt(plane, corner));
+        if (heights.every((height) => height <= bottom + tolerance)) {
+            throw new Error(`The underside of ${describeObject(tx, part)} is below the bottom of ${describeObject(tx, wall)}, so clipping by it would leave nothing of the wall`);
+        }
+        if (heights.some((height) => height < top - tolerance) && !existing.some((known) => samePlane(known, plane, tolerance))) {
+            clipWall(tx, writer, wall, plane.origin, plane.normal);
+            existing.push(plane);
+        }
+    }
+}

package/lib/build/roofs.d.ts

@@ -0,0 +1,4 @@
+import type { IfcTransaction } from "../model/transaction";
+import type { RoofSpec } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+export declare function createRoof(tx: IfcTransaction, writer: EntityWriter, spec: RoofSpec, tolerance: number): number;

package/lib/build/roofs.js

@@ -0,0 +1,131 @@
+import { WORLD_AXES } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { add2, cross2, length2, scale2, subtract2 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import { wound2 } from "@bitbybit-dev/base/lib/api/services/helpers/polygons";
+import * as Inputs from "../api/inputs";
+import { enumValue, ref } from "../step/values";
+import { AGGREGATION, DEGREES_TO_RADIANS } from "./constants";
+import { bodyContext } from "./contexts";
+import { associateNewMaterial, layerSetThickness, layerSetUsage } from "./materials";
+import { normalize2 } from "./math";
+import { cleanOutline } from "./outlines";
+import { objectPlacementOf } from "./placement";
+import { relate } from "./relationships";
+import { containIn } from "./spatial";
+const RECTANGLE_CORNERS = 4;
+const RIGHT_ANGLE_COSINE = 1e-6;
+const MAX_PITCH_DEGREES = 89;
+const ROOF_TYPES = {
+    [Inputs.IFC.roofKindEnum.flat]: "FLAT_ROOF",
+    [Inputs.IFC.roofKindEnum.monoPitch]: "SHED_ROOF",
+    [Inputs.IFC.roofKindEnum.gable]: "GABLE_ROOF",
+    [Inputs.IFC.roofKindEnum.hip]: "HIP_ROOF",
+};
+function rectangle(points, tolerance) {
+    const corners = cleanOutline(points, tolerance, "roof's outline");
+    if (corners.length !== RECTANGLE_CORNERS) {
+        throw new Error(`A roof's outline is a rectangle of ${RECTANGLE_CORNERS} corners, got ${corners.length}`);
+    }
+    corners.forEach((corner, index) => {
+        const before = normalize2(subtract2(corner, corners[(index + RECTANGLE_CORNERS - 1) % RECTANGLE_CORNERS]));
+        const after = normalize2(subtract2(corners[(index + 1) % RECTANGLE_CORNERS], corner));
+        if (Math.abs(before[0] * after[0] + before[1] * after[1]) > RIGHT_ANGLE_COSINE) {
+            throw new Error(`A roof's outline is a rectangle, and its corner ${index} is not a right angle`);
+        }
+    });
+    return corners;
+}
+function expanded(corners, overhang) {
+    const along = normalize2(subtract2(corners[1], corners[0]));
+    const across = normalize2(subtract2(corners[3], corners[0]));
+    const out = (point, alongSign, acrossSign) => add2(point, add2(scale2(along, alongSign * overhang), scale2(across, acrossSign * overhang)));
+    return [out(corners[0], -1, -1), out(corners[1], 1, -1), out(corners[2], 1, 1), out(corners[3], -1, 1)];
+}
+function eavesPlane(corners, from, outline) {
+    const start = corners[from];
+    const along = normalize2(subtract2(corners[(from + 1) % RECTANGLE_CORNERS], start));
+    const across = normalize2(subtract2(corners[(from + RECTANGLE_CORNERS - 1) % RECTANGLE_CORNERS], start));
+    return { origin: start, along, inward: across, outline };
+}
+function gablePlanes(q) {
+    const middle = (a, b) => scale2(add2(a, b), 1 / 2);
+    const ridgeStart = middle(q[0], q[3]);
+    const ridgeEnd = middle(q[1], q[2]);
+    return [eavesPlane(q, 0, [q[0], q[1], ridgeEnd, ridgeStart]), eavesPlane(q, 2, [q[2], q[3], ridgeStart, ridgeEnd])];
+}
+function hipPlanes(q, tolerance) {
+    const corners = length2(subtract2(q[1], q[0])) >= length2(subtract2(q[2], q[1])) ? q : [q[1], q[2], q[3], q[0]];
+    const along = normalize2(subtract2(corners[1], corners[0]));
+    const across = normalize2(subtract2(corners[3], corners[0]));
+    const half = length2(subtract2(corners[3], corners[0])) / 2;
+    const ridgeStart = add2(corners[0], add2(scale2(along, half), scale2(across, half)));
+    const ridgeEnd = add2(corners[1], add2(scale2(along, -half), scale2(across, half)));
+    const pointed = !(length2(subtract2(ridgeEnd, ridgeStart)) > tolerance);
+    const tops = [pointed ? [ridgeStart] : [ridgeEnd, ridgeStart], [ridgeEnd], pointed ? [ridgeStart] : [ridgeStart, ridgeEnd], [ridgeStart]];
+    return corners.map((corner, index) => eavesPlane(corners, index, [corner, corners[(index + 1) % RECTANGLE_CORNERS], ...tops[index]]));
+}
+function planesOf(spec, q, tolerance) {
+    switch (spec.kind) {
+        case Inputs.IFC.roofKindEnum.monoPitch:
+            return [eavesPlane(q, 0, q)];
+        case Inputs.IFC.roofKindEnum.gable:
+            return gablePlanes(q);
+        case Inputs.IFC.roofKindEnum.hip:
+            return hipPlanes(q, tolerance);
+        default:
+            return [{ origin: q[0], along: [1, 0], inward: [0, 1], outline: q }];
+    }
+}
+function planeFrame(plane, height, slope) {
+    const along = cross2(plane.along, plane.inward) > 0 ? plane.along : scale2(plane.along, -1);
+    const cos = Math.cos(slope);
+    const sin = Math.sin(slope);
+    const up = [plane.inward[0] * cos, plane.inward[1] * cos, sin];
+    const x = [along[0], along[1], 0];
+    return { origin: [plane.origin[0], plane.origin[1], height], x, y: up, z: [x[1] * up[2], -x[0] * up[2], x[0] * up[1] - x[1] * up[0]] };
+}
+function inPlane(plane, frame, slope, point) {
+    const offset = subtract2(point, plane.origin);
+    return [offset[0] * frame.x[0] + offset[1] * frame.x[1], (offset[0] * plane.inward[0] + offset[1] * plane.inward[1]) / Math.cos(slope)];
+}
+export function createRoof(tx, writer, spec, tolerance) {
+    var _a;
+    const flat = spec.kind === Inputs.IFC.roofKindEnum.flat;
+    if (!flat && !(spec.pitch > 0 && spec.pitch <= MAX_PITCH_DEGREES)) {
+        throw new Error(`A sloped roof's pitch is more than 0 and at most ${MAX_PITCH_DEGREES} degrees, got ${spec.pitch}`);
+    }
+    const thickness = layerSetThickness(tx, spec.layerSet);
+    if (!(thickness > 0)) {
+        throw new Error("A roof's layers must add up to more than zero thickness");
+    }
+    if (!(spec.overhang >= 0)) {
+        throw new Error(`A roof's overhang is zero or more, got ${spec.overhang}`);
+    }
+    const slope = flat ? 0 : spec.pitch * DEGREES_TO_RADIANS;
+    const outer = expanded(rectangle(spec.outline, tolerance), spec.overhang);
+    const eaves = spec.baseOffset - spec.overhang * Math.tan(slope);
+    const placement = writer.localPlacement(objectPlacementOf(tx, spec.storey), WORLD_AXES);
+    const roof = writer.create("IfcRoof", {
+        GlobalId: tx.globalId(spec.id),
+        Name: (_a = spec.name) !== null && _a !== void 0 ? _a : null,
+        ObjectPlacement: ref(placement),
+        PredefinedType: enumValue(ROOF_TYPES[spec.kind]),
+    });
+    containIn(tx, writer, spec.storey, roof);
+    const parts = planesOf(spec, outer, tolerance).map((plane) => {
+        var _a;
+        const frame = planeFrame(plane, flat ? spec.baseOffset : eaves, slope);
+        const outline = wound2(plane.outline.map((point) => inPlane(plane, frame, slope, point)), true);
+        const solid = writer.extrusion(writer.profile({ outer: outline, holes: [] }), WORLD_AXES, thickness);
+        const body = writer.shapeRepresentation(bodyContext(tx, writer), "Body", "SweptSolid", [solid]);
+        return writer.create("IfcSlab", {
+            GlobalId: tx.globalId(undefined),
+            Name: (_a = spec.name) !== null && _a !== void 0 ? _a : null,
+            ObjectPlacement: ref(writer.localPlacement(placement, frame)),
+            Representation: ref(writer.productShape([body])),
+            PredefinedType: enumValue("ROOF"),
+        });
+    });
+    relate(tx, writer, AGGREGATION, roof, parts);
+    associateNewMaterial(tx, writer, parts, layerSetUsage(writer, spec.layerSet, "AXIS3", "NEGATIVE", thickness));
+    return roof;
+}

package/lib/build/site.d.ts

@@ -0,0 +1,7 @@
+import type { ModelSnapshot } from "../model/snapshot";
+import type { IfcTransaction } from "../model/transaction";
+import type { TerrainSpec, TreeSpec } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+export declare function onlySite(model: ModelSnapshot | IfcTransaction): number;
+export declare function createTerrain(tx: IfcTransaction, writer: EntityWriter, spec: TerrainSpec, tolerance: number): number;
+export declare function createTree(tx: IfcTransaction, writer: EntityWriter, spec: TreeSpec): number;

package/lib/build/site.js

@@ -0,0 +1,112 @@
+import { WORLD_AXES } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { frustum, icosphere } from "@bitbybit-dev/base/lib/api/services/helpers/mesh-primitives";
+import { isInsidePolygon2, wound2 } from "@bitbybit-dev/base/lib/api/services/helpers/polygons";
+import { enumValue, ref } from "../step/values";
+import { POINT3_SIZE, TRIANGLE_CORNERS } from "./constants";
+import { bodyContext } from "./contexts";
+import { associateNewMaterial, dressParts, materialsOfParts, requireMaterial } from "./materials";
+import { cleanOutline } from "./outlines";
+import { objectPlacementOf } from "./placement";
+import { containIn } from "./spatial";
+const GEOGRAPHIC_ELEMENT = "IfcGeographicElement";
+const CROWN_DETAIL = 1;
+const CROWN_STRETCH = 1.25;
+const CROWN_SHARE_OF_HEIGHT = 0.45;
+const CROWN_RIPPLE = 0.07;
+const CROWN_LOBES = 3;
+const TRUNK_SIDES = 8;
+const TRUNK_TOP_SHARE = 0.6;
+const TRUNK_INTO_CROWN = 0.35;
+export function onlySite(model) {
+    const sites = model.byType("IfcSite");
+    if (sites.length !== 1) {
+        throw new Error(`Site elements are added to the model's one site, and it has ${sites.length}`);
+    }
+    return sites[0].id;
+}
+function triangulatedFaceSet(writer, mesh, origin) {
+    const points = [];
+    for (let at = 0; at < mesh.positions.length; at += POINT3_SIZE) {
+        points.push([mesh.positions[at] + origin[0], mesh.positions[at + 1] + origin[1], mesh.positions[at + 2] + origin[2]]);
+    }
+    const triangles = [];
+    for (let at = 0; at < mesh.indices.length; at += TRIANGLE_CORNERS) {
+        triangles.push([mesh.indices[at] + 1, mesh.indices[at + 1] + 1, mesh.indices[at + 2] + 1]);
+    }
+    const coordinates = writer.create("IfcCartesianPointList3D", { CoordList: points });
+    return writer.create("IfcTriangulatedFaceSet", { Coordinates: ref(coordinates), Closed: true, CoordIndex: triangles });
+}
+function crownMesh(spec) {
+    const upward = Math.min(spec.crownRadius * CROWN_STRETCH, spec.height * CROWN_SHARE_OF_HEIGHT);
+    const sphere = icosphere(CROWN_DETAIL);
+    const positions = sphere.positions.slice();
+    for (let at = 0; at < positions.length; at += POINT3_SIZE) {
+        const [x, y, z] = [positions[at], positions[at + 1], positions[at + 2]];
+        const ripple = 1 + CROWN_RIPPLE * Math.sin(CROWN_LOBES * Math.atan2(y, x) + 2 * z);
+        positions[at] = x * spec.crownRadius * ripple;
+        positions[at + 1] = y * spec.crownRadius * ripple;
+        positions[at + 2] = z * upward * ripple;
+    }
+    return { mesh: { positions, indices: sphere.indices }, centre: spec.height - upward * (1 + CROWN_RIPPLE) };
+}
+export function createTerrain(tx, writer, spec, tolerance) {
+    if (!(spec.depth > 0)) {
+        throw new Error(`The terrain's depth must be more than zero, got ${spec.depth}`);
+    }
+    const site = onlySite(tx);
+    const material = spec.material === undefined ? undefined : requireMaterial(tx, spec.material);
+    const outer = wound2(cleanOutline(spec.outline, tolerance, "outline"), true);
+    const holes = spec.holes.map((hole, index) => {
+        const cleaned = cleanOutline(hole, tolerance, `hole ${index}`);
+        if (!cleaned.every((point) => isInsidePolygon2(point, outer))) {
+            throw new Error(`Hole ${index} reaches outside the terrain's outline`);
+        }
+        return wound2(cleaned, false);
+    });
+    const placement = writer.localPlacement(objectPlacementOf(tx, site), Object.assign(Object.assign({}, WORLD_AXES), { origin: [0, 0, spec.elevation] }));
+    const solid = writer.extrusion(writer.profile({ outer, holes }), WORLD_AXES, spec.depth, [0, 0, -1]);
+    const body = writer.shapeRepresentation(bodyContext(tx, writer), "Body", "SweptSolid", [solid]);
+    const terrain = writer.create(GEOGRAPHIC_ELEMENT, {
+        GlobalId: tx.globalId(spec.id),
+        Name: spec.name,
+        ObjectPlacement: ref(placement),
+        Representation: ref(writer.productShape([body])),
+        PredefinedType: enumValue("TERRAIN"),
+    });
+    containIn(tx, writer, site, terrain);
+    if (material !== undefined) {
+        associateNewMaterial(tx, writer, [terrain], material);
+    }
+    return terrain;
+}
+export function createTree(tx, writer, spec) {
+    for (const [what, value] of [["height", spec.height], ["crown radius", spec.crownRadius], ["trunk radius", spec.trunkRadius]]) {
+        if (!(value > 0) || !Number.isFinite(value)) {
+            throw new Error(`The tree's ${what} must be more than zero, got ${value}`);
+        }
+    }
+    if (spec.trunkRadius >= spec.crownRadius) {
+        throw new Error("A tree's trunk must be narrower than its crown");
+    }
+    const site = onlySite(tx);
+    const { mesh, centre } = crownMesh(spec);
+    const trunkTop = centre + (spec.height - centre) * TRUNK_INTO_CROWN;
+    const parts = [
+        { name: "Foliage", items: [triangulatedFaceSet(writer, mesh, [0, 0, centre])], material: spec.crownMaterial },
+        { name: "Trunk", items: [triangulatedFaceSet(writer, frustum(TRUNK_SIDES, spec.trunkRadius, spec.trunkRadius * TRUNK_TOP_SHARE, trunkTop), [0, 0, 0])], material: spec.trunkMaterial },
+    ];
+    const materials = materialsOfParts(tx, parts);
+    const placement = writer.localPlacement(objectPlacementOf(tx, site), Object.assign(Object.assign({}, WORLD_AXES), { origin: [spec.position[0], spec.position[1], spec.elevation] }));
+    const body = writer.shapeRepresentation(bodyContext(tx, writer), "Body", "Tessellation", parts.flatMap((part) => part.items));
+    const tree = writer.create(GEOGRAPHIC_ELEMENT, {
+        GlobalId: tx.globalId(spec.id),
+        Name: spec.name,
+        ObjectPlacement: ref(placement),
+        Representation: ref(writer.productShape([body])),
+        ObjectType: spec.species,
+        PredefinedType: enumValue("USERDEFINED"),
+    });
+    containIn(tx, writer, site, tree);
+    dressParts(tx, writer, tree, parts, materials);
+    return tree;
+}

package/lib/build/slab-openings.d.ts

@@ -0,0 +1,4 @@
+import type { IfcTransaction } from "../model/transaction";
+import type { SlabOpeningSpec } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+export declare function createSlabOpening(tx: IfcTransaction, writer: EntityWriter, spec: SlabOpeningSpec, tolerance: number): number;

package/lib/build/slab-openings.js

@@ -0,0 +1,71 @@
+import { WORLD_AXES, vectorToWorld } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { wound2 } from "@bitbybit-dev/base/lib/api/services/helpers/polygons";
+import { enumValue, isReference, ref } from "../step/values";
+import { VERTICAL_COSINE, VOIDING } from "./constants";
+import { bodyContext } from "./contexts";
+import { polylinePoints } from "./curves";
+import { normalize3, placedOnPlan } from "./math";
+import { openingMargin } from "./openings";
+import { cleanOutline, edgesCross, isInsideOrOn } from "./outlines";
+import { absoluteFrame, directionOf, objectPlacementOf } from "./placement";
+import { firstItem, representationOf, unwrapClippings } from "./representations";
+import { frameOf } from "./solids";
+import { describeObject } from "./spatial";
+const ARBITRARY_PROFILES = ["IfcArbitraryClosedProfileDef", "IfcArbitraryProfileDefWithVoids"];
+function extrudedSolidOf(reader, slab) {
+    const body = representationOf(reader, slab, "Body");
+    if (body === undefined) {
+        throw new Error(`${describeObject(reader, slab)} has no Body representation to cut`);
+    }
+    const [solid] = unwrapClippings(reader, firstItem(reader, body));
+    if (reader.entity(solid).type !== "IfcExtrudedAreaSolid") {
+        throw new Error(`${describeObject(reader, slab)} has a body this library does not cut: an ${reader.entity(solid).type}, where an outline extruded up or down is expected`);
+    }
+    return solid;
+}
+function verticalSpan(reader, slab, solid, frame) {
+    const direction = vectorToWorld(frame, normalize3(directionOf(reader, reader.attribute(solid, "ExtrudedDirection"), [0, 0, 1])));
+    const depth = reader.attribute(solid, "Depth");
+    if (typeof depth !== "number" || Math.abs(frame.z[2]) < VERTICAL_COSINE || Math.abs(direction[2]) < VERTICAL_COSINE) {
+        throw new Error(`${describeObject(reader, slab)} is not extruded straight up or down, so this library does not cut it`);
+    }
+    const far = frame.origin[2] + direction[2] * depth;
+    return [Math.min(frame.origin[2], far), Math.max(frame.origin[2], far)];
+}
+function outlineOf(reader, solid, frame) {
+    const profile = reader.attribute(solid, "SweptArea");
+    if (!isReference(profile) || !ARBITRARY_PROFILES.includes(reader.entity(profile.ref).type)) {
+        return undefined;
+    }
+    const outer = reader.attribute(profile.ref, "OuterCurve");
+    const points = isReference(outer) ? polylinePoints(reader, outer.ref) : undefined;
+    return points === null || points === void 0 ? void 0 : points.map((point) => placedOnPlan(frame, point));
+}
+export function createSlabOpening(tx, writer, spec, tolerance) {
+    var _a;
+    const placement = objectPlacementOf(tx, spec.slab);
+    if (absoluteFrame(tx, placement).z[2] < VERTICAL_COSINE) {
+        throw new Error(`${describeObject(tx, spec.slab)} is not level, so this library does not cut it`);
+    }
+    const solid = extrudedSolidOf(tx, spec.slab);
+    const frame = frameOf(tx, tx.attribute(solid, "Position"));
+    const [bottom, top] = verticalSpan(tx, spec.slab, solid, frame);
+    const outline = wound2(cleanOutline(spec.outline, tolerance, "opening's outline"), true);
+    const slabOutline = outlineOf(tx, solid, frame);
+    if (slabOutline && (!outline.every((point) => isInsideOrOn(point, slabOutline, tolerance)) || edgesCross(outline, slabOutline, tolerance))) {
+        throw new Error(`The opening's outline reaches outside ${describeObject(tx, spec.slab)}`);
+    }
+    const margin = openingMargin(top - bottom);
+    const openingPlacement = writer.localPlacement(placement, Object.assign(Object.assign({}, WORLD_AXES), { origin: [0, 0, top + margin] }));
+    const cut = writer.extrusion(writer.profile({ outer: outline, holes: [] }), WORLD_AXES, top - bottom + 2 * margin, [0, 0, -1]);
+    const body = writer.shapeRepresentation(bodyContext(tx, writer), "Body", "SweptSolid", [cut]);
+    const opening = writer.create("IfcOpeningElement", {
+        GlobalId: tx.globalId(spec.id),
+        Name: (_a = spec.name) !== null && _a !== void 0 ? _a : null,
+        ObjectPlacement: ref(openingPlacement),
+        Representation: ref(writer.productShape([body])),
+        PredefinedType: enumValue("OPENING"),
+    });
+    writer.create(VOIDING.relationship, { GlobalId: tx.globalId(undefined), [VOIDING.relating]: ref(spec.slab), [VOIDING.related]: ref(opening) });
+    return opening;
+}