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

package/lib/geometry/items.js

@@ -0,0 +1,313 @@
+import { WORLD_AXES, axesToMatrix, vectorToLocal } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { add3, length3, scale3 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import { wound2 } from "@bitbybit-dev/base/lib/api/services/helpers/polygons";
+import { PARALLEL_TOLERANCE } from "../build/constants";
+import { axisPlacementFrame, directionOf } from "../build/placement";
+import { isEnumeration, isList, isReference } from "../step/values";
+import { CurveSampler } from "./curves";
+import { UnsupportedGeometryError } from "./errors";
+import { INWARD, MeshCollector, OUTWARD, UNORIENTED, concatenated } from "./faceted";
+import { itemColour } from "./colours";
+import { operatorMatrix } from "./operators";
+import { profileRegion } from "./profiles";
+import { regionSolid } from "./regions";
+import { SweptSolids } from "./swept-solids";
+const IDENTITY = axesToMatrix(WORLD_AXES);
+const Z_AXIS = [0, 0, 1];
+const PLAIN_HALF_SPACES = new Set(["IfcHalfSpaceSolid", "IfcBoxedHalfSpace"]);
+const CLOSED_SHELL = "IfcClosedShell";
+const MAPPED_ITEM = "IfcMappedItem";
+const SURFACE_MODEL_FACES = { IfcFaceBasedSurfaceModel: "FbsmFaces", IfcShellBasedSurfaceModel: "SbsmBoundary" };
+const MESH_ITEMS = new Set([
+    "IfcTriangulatedFaceSet", "IfcPolygonalFaceSet", "IfcFacetedBrep", "IfcFacetedBrepWithVoids", "IfcAdvancedBrep", "IfcAdvancedBrepWithVoids", "IfcFaceBasedSurfaceModel", "IfcShellBasedSurfaceModel",
+]);
+const BREPS_WITH_VOIDS = new Set(["IfcFacetedBrepWithVoids", "IfcAdvancedBrepWithVoids"]);
+function isIdentity(matrix) {
+    return matrix.every((value, index) => value === IDENTITY[index]);
+}
+function flat(points) {
+    return points.flatMap(([x, y]) => [x, y]);
+}
+export class ItemConverter {
+    constructor(model, builder, reach) {
+        this.items = new Map();
+        this.maps = new Map();
+        this.representations = new Map();
+        this.itemColours = new Map();
+        this.model = model;
+        this.builder = builder;
+        this.curves = new CurveSampler(model);
+        this.reach = reach;
+        this.solids = new SweptSolids(model, builder, this.curves);
+    }
+    representation(representation) {
+        return this.joined(this.parts(representation).map((part) => part.node));
+    }
+    parts(representation) {
+        const known = this.representations.get(representation);
+        if (known) {
+            return known;
+        }
+        const items = this.model.attribute(representation, "Items");
+        const ids = (isList(items) ? items : []).filter(isReference).map((item) => item.ref);
+        if (!ids.length) {
+            throw new UnsupportedGeometryError(`#${representation} holds no items`);
+        }
+        const groups = new Map();
+        const groupOf = (rgba) => {
+            const key = rgba ? rgba.join(",") : "";
+            let group = groups.get(key);
+            if (!group) {
+                group = { rgba, entries: [] };
+                groups.set(key, group);
+            }
+            return group;
+        };
+        for (const item of ids) {
+            const own = itemColour(this.model, this.itemColours, item);
+            if (this.model.typeOf(item) === MAPPED_ITEM) {
+                this.mappedParts(item).forEach((part) => { var _a; return groupOf((_a = part.rgba) !== null && _a !== void 0 ? _a : own).entries.push({ node: part.node }); });
+            }
+            else {
+                groupOf(own).entries.push({ item });
+            }
+        }
+        const parts = [...groups.values()].map((group) => ({ rgba: group.rgba, node: this.groupNode(representation, group.entries) }));
+        this.representations.set(representation, parts);
+        return parts;
+    }
+    item(item) {
+        const known = this.items.get(item);
+        if (known !== undefined) {
+            return known;
+        }
+        const node = this.convert(item);
+        this.items.set(item, node);
+        return node;
+    }
+    convert(item) {
+        const type = this.model.entity(item).type;
+        switch (type) {
+            case "IfcExtrudedAreaSolid":
+                return this.extrusion(item);
+            case "IfcBooleanClippingResult":
+            case "IfcBooleanResult":
+                return this.boolean(item);
+            case "IfcMappedItem":
+                return this.mapped(item);
+            case "IfcRevolvedAreaSolid":
+                return this.solids.revolved(item);
+            case "IfcExtrudedAreaSolidTapered":
+                return this.solids.tapered(item);
+            case "IfcSweptDiskSolid":
+            case "IfcSweptDiskSolidPolygonal":
+                return this.solids.sweptDisk(item, type === "IfcSweptDiskSolidPolygonal");
+            case "IfcSurfaceCurveSweptAreaSolid":
+            case "IfcFixedReferenceSweptAreaSolid":
+                return this.solids.areaSweep(item, type === "IfcFixedReferenceSweptAreaSolid");
+            case "IfcBlock":
+            case "IfcRightCircularCylinder":
+            case "IfcRightCircularCone":
+            case "IfcSphere":
+            case "IfcRectangularPyramid":
+                return this.solids.primitive(item, type);
+            case "IfcCsgSolid": {
+                const root = this.model.attribute(item, "TreeRootExpression");
+                if (!isReference(root)) {
+                    throw new UnsupportedGeometryError(`#${item} has no tree root expression`);
+                }
+                return this.item(root.ref);
+            }
+            case "IfcTriangulatedFaceSet":
+            case "IfcPolygonalFaceSet":
+            case "IfcFacetedBrep":
+            case "IfcFacetedBrepWithVoids":
+            case "IfcAdvancedBrep":
+            case "IfcAdvancedBrepWithVoids":
+            case "IfcFaceBasedSurfaceModel":
+            case "IfcShellBasedSurfaceModel":
+                return this.meshNode(item, this.meshOf(item));
+            default:
+                throw new UnsupportedGeometryError(`An ${type} is not supported yet`);
+        }
+    }
+    placedBy(node, placement) {
+        if (placement === undefined) {
+            return node;
+        }
+        const matrix = axesToMatrix(axisPlacementFrame(this.model, placement));
+        return isIdentity(matrix) ? node : this.builder.node({ op: "transform", of: node, matrix });
+    }
+    extrusion(item) {
+        const area = this.model.attribute(item, "SweptArea");
+        if (!isReference(area)) {
+            throw new UnsupportedGeometryError(`#${item} has no swept area`);
+        }
+        const region = profileRegion(this.model, area.ref, this.curves);
+        const direction = directionOf(this.model, this.model.attribute(item, "ExtrudedDirection"), Z_AXIS);
+        const depth = this.model.attribute(item, "Depth");
+        if (typeof depth !== "number" || !Number.isFinite(depth) || depth === 0) {
+            throw new UnsupportedGeometryError(`#${item} has no depth`);
+        }
+        const solid = this.extruded(region, scale3(direction, Math.sign(depth) / length3(direction)), Math.abs(depth));
+        const position = this.model.attribute(item, "Position");
+        return this.placedBy(solid, isReference(position) ? position.ref : undefined);
+    }
+    extruded(region, direction, depth) {
+        return regionSolid(this.builder, region, (profile, part) => {
+            if (part.kind !== "polygon" || part.plane === undefined) {
+                return this.builder.node({ op: "extrude", profile, direction, depth });
+            }
+            const across = vectorToLocal(part.plane, direction);
+            if (!(Math.abs(across[2]) > PARALLEL_TOLERANCE)) {
+                throw new UnsupportedGeometryError("An extrusion runs along the plane of its outline");
+            }
+            const solid = this.builder.node({ op: "extrude", profile, direction: across, depth });
+            return this.builder.node({ op: "transform", of: solid, matrix: axesToMatrix(part.plane) });
+        });
+    }
+    boolean(item) {
+        var _a;
+        const operator = this.model.attribute(item, "Operator");
+        const first = this.model.attribute(item, "FirstOperand");
+        const second = this.model.attribute(item, "SecondOperand");
+        if (!isReference(first) || !isReference(second)) {
+            throw new UnsupportedGeometryError(`#${item} lacks an operand`);
+        }
+        const solid = this.item(first.ref);
+        const plain = PLAIN_HALF_SPACES.has((_a = this.model.typeOf(second.ref)) !== null && _a !== void 0 ? _a : "");
+        switch (isEnumeration(operator) ? operator.enum : undefined) {
+            case "DIFFERENCE":
+                return this.builder.node({ op: "difference", of: solid, tools: [this.tool(second.ref)] });
+            case "UNION":
+                if (plain) {
+                    throw new UnsupportedGeometryError(`#${item} unites a solid with a half-space, which has no bounds`);
+                }
+                return this.builder.node({ op: "union", of: [solid, this.tool(second.ref)] });
+            case "INTERSECTION": {
+                if (plain) {
+                    const space = this.halfSpace(second.ref);
+                    return this.builder.node({ op: "difference", of: solid, tools: [this.builder.node(Object.assign(Object.assign({}, space), { normal: scale3(space.normal, -1) }))] });
+                }
+                return this.builder.node({ op: "intersection", of: [solid, this.tool(second.ref)] });
+            }
+            default:
+                throw new UnsupportedGeometryError(`#${item} has no boolean operator`);
+        }
+    }
+    tool(operand) {
+        switch (this.model.entity(operand).type) {
+            case "IfcHalfSpaceSolid":
+            case "IfcBoxedHalfSpace":
+                return this.builder.node(this.halfSpace(operand));
+            case "IfcPolygonalBoundedHalfSpace":
+                return this.boundedHalfSpace(operand);
+            default:
+                return this.item(operand);
+        }
+    }
+    boundedHalfSpace(solid) {
+        const position = this.model.attribute(solid, "Position");
+        const boundary = this.model.attribute(solid, "PolygonalBoundary");
+        if (!isReference(position) || !isReference(boundary)) {
+            throw new UnsupportedGeometryError(`#${solid} lacks its position or its boundary`);
+        }
+        const outline = wound2(this.curves.outline(boundary.ref), true);
+        const profile = this.builder.node({ op: "polygon", points: this.builder.numbers(flat(outline)), holes: [] });
+        const prism = this.builder.node({ op: "extrude", profile, direction: Z_AXIS, depth: 2 * this.reach });
+        const frame = axisPlacementFrame(this.model, position.ref);
+        const placed = this.builder.node({ op: "transform", of: prism, matrix: axesToMatrix(Object.assign(Object.assign({}, frame), { origin: add3(frame.origin, scale3(frame.z, -this.reach)) })) });
+        const space = this.halfSpace(solid);
+        const outside = this.builder.node(Object.assign(Object.assign({}, space), { normal: scale3(space.normal, -1) }));
+        return this.builder.node({ op: "difference", of: placed, tools: [outside] });
+    }
+    halfSpace(solid) {
+        const surface = this.model.attribute(solid, "BaseSurface");
+        if (!isReference(surface) || this.model.entity(surface.ref).type !== "IfcPlane") {
+            throw new UnsupportedGeometryError("Only half-spaces bounded by a plane are supported yet");
+        }
+        const position = this.model.attribute(surface.ref, "Position");
+        if (!isReference(position)) {
+            throw new UnsupportedGeometryError(`#${surface.ref} has no position`);
+        }
+        const frame = axisPlacementFrame(this.model, position.ref);
+        const agreement = this.model.attribute(solid, "AgreementFlag");
+        const normal = agreement === true ? scale3(frame.z, -1) : frame.z;
+        return { op: "halfSpace", origin: frame.origin, normal };
+    }
+    joined(nodes) {
+        return nodes.length === 1 ? nodes[0] : this.builder.node({ op: "compound", of: [...nodes] });
+    }
+    groupNode(representation, entries) {
+        const meshes = entries.flatMap((entry) => { var _a; return ("item" in entry && MESH_ITEMS.has((_a = this.model.typeOf(entry.item)) !== null && _a !== void 0 ? _a : "") ? [entry.item] : []); });
+        if (entries.length > 1 && meshes.length === entries.length) {
+            return this.meshNode(representation, concatenated(meshes.map((item) => this.meshOf(item))));
+        }
+        return this.joined(entries.map((entry) => ("item" in entry ? this.item(entry.item) : entry.node)));
+    }
+    mapped(item) {
+        return this.joined(this.mappedParts(item).map((part) => part.node));
+    }
+    mappedParts(item) {
+        const source = this.model.attribute(item, "MappingSource");
+        const target = this.model.attribute(item, "MappingTarget");
+        if (!isReference(source) || !isReference(target)) {
+            throw new UnsupportedGeometryError(`#${item} lacks its source or target`);
+        }
+        let shared = this.maps.get(source.ref);
+        if (shared === undefined) {
+            const representation = this.model.attribute(source.ref, "MappedRepresentation");
+            if (!isReference(representation)) {
+                throw new UnsupportedGeometryError(`#${source.ref} maps no representation`);
+            }
+            const origin = this.model.attribute(source.ref, "MappingOrigin");
+            const placement = isReference(origin) ? origin.ref : undefined;
+            shared = this.parts(representation.ref).map((part) => ({ rgba: part.rgba, node: this.placedBy(part.node, placement) }));
+            this.maps.set(source.ref, shared);
+        }
+        const matrix = operatorMatrix(this.model, target.ref);
+        return isIdentity(matrix) ? shared : shared.map((part) => ({ rgba: part.rgba, node: this.builder.node({ op: "transform", of: part.node, matrix }) }));
+    }
+    meshNode(item, mesh) {
+        if (!mesh.indices.length) {
+            throw new UnsupportedGeometryError(`#${item} holds no faces with an area`);
+        }
+        return this.builder.node({ op: "triangles", positions: this.builder.numbers(mesh.positions), indices: this.builder.indices(mesh.indices) });
+    }
+    meshOf(item) {
+        const collector = new MeshCollector(this.model);
+        const type = this.model.entity(item).type;
+        switch (type) {
+            case "IfcTriangulatedFaceSet":
+                collector.triangulatedFaces(item);
+                break;
+            case "IfcPolygonalFaceSet":
+                collector.polygonalFaces(item);
+                break;
+            case "IfcFaceBasedSurfaceModel":
+            case "IfcShellBasedSurfaceModel":
+                this.surfaceModel(collector, item, type);
+                break;
+            default:
+                this.facetedBrep(collector, item, type);
+        }
+        return collector.mesh;
+    }
+    facetedBrep(collector, item, type) {
+        const outer = this.model.attribute(item, "Outer");
+        if (!isReference(outer)) {
+            throw new UnsupportedGeometryError(`#${item} has no outer shell`);
+        }
+        collector.shell(outer.ref, OUTWARD);
+        const voids = BREPS_WITH_VOIDS.has(type) ? this.model.attribute(item, "Voids") : null;
+        for (const shell of (isList(voids) ? voids : []).filter(isReference)) {
+            collector.shell(shell.ref, INWARD);
+        }
+    }
+    surfaceModel(collector, item, type) {
+        const sets = this.model.attribute(item, SURFACE_MODEL_FACES[type]);
+        for (const set of (isList(sets) ? sets : []).filter(isReference)) {
+            collector.shell(set.ref, this.model.typeOf(set.ref) === CLOSED_SHELL ? OUTWARD : UNORIENTED);
+        }
+    }
+}

package/lib/geometry/operators.d.ts

@@ -0,0 +1,3 @@
+import type { Base } from "@bitbybit-dev/base";
+import type { ModelSnapshot } from "../model/snapshot";
+export declare function operatorMatrix(model: ModelSnapshot, operator: number): Base.TransformMatrix;

package/lib/geometry/operators.js

@@ -0,0 +1,65 @@
+import { cross3, dot3, length3, scale3, subtract3 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import { PARALLEL_TOLERANCE } from "../build/constants";
+import { directionOf, pointOf } from "../build/placement";
+import { isReference } from "../step/values";
+import { UnsupportedGeometryError } from "./errors";
+const X_AXIS = [1, 0, 0];
+const Y_AXIS = [0, 1, 0];
+const Z_AXIS = [0, 0, 1];
+const SPATIAL_OPERATOR = "IfcCartesianTransformationOperator3D";
+function optionalAttribute(model, id, name) {
+    return model.schema.entity(model.entity(id).type).positions.has(name) ? model.attribute(id, name) : null;
+}
+function operatorAxis(model, operator, name) {
+    const value = optionalAttribute(model, operator, name);
+    if (!isReference(value)) {
+        return undefined;
+    }
+    const direction = directionOf(model, value, Z_AXIS);
+    const length = length3(direction);
+    if (!(length > 0)) {
+        throw new UnsupportedGeometryError(`#${operator} has an ${name} of zero length`);
+    }
+    return scale3(direction, 1 / length);
+}
+function operatorScale(model, operator, name, fallback) {
+    const value = optionalAttribute(model, operator, name);
+    if (value === null) {
+        return fallback;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value) || !(value > 0)) {
+        throw new UnsupportedGeometryError(`#${operator} has a ${name} that is not a number above zero`);
+    }
+    return value;
+}
+function spaceAxes(operator, axis1, axis2, axis3) {
+    const z = axis3 !== null && axis3 !== void 0 ? axis3 : Z_AXIS;
+    const hint = axis1 !== null && axis1 !== void 0 ? axis1 : (length3(cross3(z, X_AXIS)) > PARALLEL_TOLERANCE ? X_AXIS : Y_AXIS);
+    const across = subtract3(hint, scale3(z, dot3(hint, z)));
+    const length = length3(across);
+    if (!(length > PARALLEL_TOLERANCE)) {
+        throw new UnsupportedGeometryError(`#${operator} has its Axis1 along its Axis3`);
+    }
+    const x = scale3(across, 1 / length);
+    const y = cross3(z, x);
+    return [x, dot3(axis2 !== null && axis2 !== void 0 ? axis2 : Y_AXIS, y) < -PARALLEL_TOLERANCE ? cross3(x, z) : y, z];
+}
+function planeAxes(axis1, axis2) {
+    if (axis1 !== undefined) {
+        const y = cross3(Z_AXIS, axis1);
+        return [axis1, axis2 !== undefined && dot3(axis2, y) < -PARALLEL_TOLERANCE ? cross3(axis1, Z_AXIS) : y, Z_AXIS];
+    }
+    return axis2 === undefined ? [X_AXIS, Y_AXIS, Z_AXIS] : [cross3(axis2, Z_AXIS), axis2, Z_AXIS];
+}
+export function operatorMatrix(model, operator) {
+    const origin = pointOf(model, model.attribute(operator, "LocalOrigin"));
+    const axis1 = operatorAxis(model, operator, "Axis1");
+    const axis2 = operatorAxis(model, operator, "Axis2");
+    const [x, y, z] = model.schema.isSubtypeOf(model.entity(operator).type, SPATIAL_OPERATOR)
+        ? spaceAxes(operator, axis1, axis2, operatorAxis(model, operator, "Axis3"))
+        : planeAxes(axis1, axis2);
+    const scale = operatorScale(model, operator, "Scale", 1);
+    const scaleY = operatorScale(model, operator, "Scale2", scale);
+    const scaleZ = operatorScale(model, operator, "Scale3", scale);
+    return [...scale3(x, scale), 0, ...scale3(y, scaleY), 0, ...scale3(z, scaleZ), 0, ...origin, 1];
+}

package/lib/geometry/profiles.d.ts

@@ -0,0 +1,4 @@
+import type { ModelSnapshot } from "../model/snapshot";
+import { type CurveSampler } from "./curves";
+import type { ProfileRegion } from "./geometry-types";
+export declare function profileRegion(model: ModelSnapshot, profile: number, curves: CurveSampler): ProfileRegion;

package/lib/geometry/profiles.js

@@ -0,0 +1,277 @@
+import { roundedCorners2, wound2 } from "@bitbybit-dev/base/lib/api/services/helpers/polygons";
+import { axisPlacementFrame } from "../build/placement";
+import { radiansPerUnit } from "../build/project";
+import { isList, isReference } from "../step/values";
+import { arcSegments } from "./curves";
+import { UnsupportedGeometryError } from "./errors";
+import { placedOnPlan } from "../build/math";
+import { operatorMatrix } from "./operators";
+const FULL_TURN = 2 * Math.PI;
+const SIMILARITY_TOLERANCE = 1e-9;
+const MIRROR_ABOUT_Y = [-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+const SCHEMA_WITHOUT_EDGE_RADII = "IFC2X3";
+function finiteAttribute(model, id, name) {
+    const value = model.attribute(id, name);
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new UnsupportedGeometryError(`#${id} has no finite ${name}`);
+    }
+    return value;
+}
+function optionalAttribute(model, id, name) {
+    const value = model.attribute(id, name);
+    return value === null ? 0 : finiteAttribute(model, id, name);
+}
+function slopeRise(model, id, name) {
+    const slope = optionalAttribute(model, id, name);
+    return slope === 0 ? 0 : Math.tan(slope * radiansPerUnit(model));
+}
+function refuseSlope(model, id, name) {
+    if (optionalAttribute(model, id, name) !== 0) {
+        throw new UnsupportedGeometryError(`#${id} has a ${name}, which is not supported yet`);
+    }
+}
+function placed(model, profile, points) {
+    const position = model.attribute(profile, "Position");
+    if (!isReference(position)) {
+        return points;
+    }
+    const frame = axisPlacementFrame(model, position.ref);
+    return points.map((point) => placedOnPlan(frame, point));
+}
+function rounded(corners) {
+    return roundedCorners2(corners.map((corner) => corner.point), corners.map((corner) => corner.radius), arcSegments);
+}
+const corner = (x, y, radius = 0) => ({ point: [x, y], radius });
+function iShape(model, profile) {
+    const x = finiteAttribute(model, profile, "OverallWidth") / 2;
+    const y = finiteAttribute(model, profile, "OverallDepth") / 2;
+    const web = finiteAttribute(model, profile, "WebThickness") / 2;
+    const flange = finiteAttribute(model, profile, "FlangeThickness");
+    const fillet = optionalAttribute(model, profile, "FilletRadius");
+    const edge = optionalAttribute(model, profile, "FlangeEdgeRadius");
+    const rise = (x - web) * slopeRise(model, profile, "FlangeSlope");
+    return [
+        corner(-x, -y), corner(x, -y), corner(x, -y + flange, edge), corner(web, -y + flange + rise, fillet),
+        corner(web, y - flange - rise, fillet), corner(x, y - flange, edge), corner(x, y), corner(-x, y),
+        corner(-x, y - flange, edge), corner(-web, y - flange - rise, fillet), corner(-web, -y + flange + rise, fillet), corner(-x, -y + flange, edge),
+    ];
+}
+function lShape(model, profile) {
+    refuseSlope(model, profile, "LegSlope");
+    const depth = finiteAttribute(model, profile, "Depth");
+    const width = model.attribute(profile, "Width") === null ? depth : finiteAttribute(model, profile, "Width");
+    const [x, y] = [width / 2, depth / 2];
+    const thickness = finiteAttribute(model, profile, "Thickness");
+    const fillet = optionalAttribute(model, profile, "FilletRadius");
+    const edge = optionalAttribute(model, profile, "EdgeRadius");
+    return [corner(-x, -y), corner(x, -y), corner(x, -y + thickness, edge), corner(-x + thickness, -y + thickness, fillet), corner(-x + thickness, y, edge), corner(-x, y)];
+}
+function uShape(model, profile) {
+    const y = finiteAttribute(model, profile, "Depth") / 2;
+    const x = finiteAttribute(model, profile, "FlangeWidth") / 2;
+    const web = finiteAttribute(model, profile, "WebThickness");
+    const flange = finiteAttribute(model, profile, "FlangeThickness");
+    const fillet = optionalAttribute(model, profile, "FilletRadius");
+    const edge = optionalAttribute(model, profile, "EdgeRadius");
+    const slope = slopeRise(model, profile, "FlangeSlope");
+    const [atWeb, atTip] = [(x - web) * slope, x * slope];
+    return [
+        corner(-x, -y), corner(x, -y), corner(x, -y + flange - atTip, edge), corner(-x + web, -y + flange + atWeb, fillet),
+        corner(-x + web, y - flange - atWeb, fillet), corner(x, y - flange + atTip, edge), corner(x, y), corner(-x, y),
+    ];
+}
+function tShape(model, profile) {
+    refuseSlope(model, profile, "WebSlope");
+    refuseSlope(model, profile, "FlangeSlope");
+    const y = finiteAttribute(model, profile, "Depth") / 2;
+    const x = finiteAttribute(model, profile, "FlangeWidth") / 2;
+    const web = finiteAttribute(model, profile, "WebThickness") / 2;
+    const flange = finiteAttribute(model, profile, "FlangeThickness");
+    const fillet = optionalAttribute(model, profile, "FilletRadius");
+    const flangeEdge = optionalAttribute(model, profile, "FlangeEdgeRadius");
+    const webEdge = optionalAttribute(model, profile, "WebEdgeRadius");
+    return [
+        corner(web, -y, webEdge), corner(web, y - flange, fillet), corner(x, y - flange, flangeEdge), corner(x, y),
+        corner(-x, y), corner(-x, y - flange, flangeEdge), corner(-web, y - flange, fillet), corner(-web, -y, webEdge),
+    ];
+}
+function rectangle(model, profile, inset, radius) {
+    const x = finiteAttribute(model, profile, "XDim") / 2 - inset;
+    const y = finiteAttribute(model, profile, "YDim") / 2 - inset;
+    return [corner(-x, -y, radius), corner(x, -y, radius), corner(x, y, radius), corner(-x, y, radius)];
+}
+function cShape(model, profile) {
+    const y = finiteAttribute(model, profile, "Depth") / 2;
+    const x = finiteAttribute(model, profile, "Width") / 2;
+    const wall = finiteAttribute(model, profile, "WallThickness");
+    const girth = finiteAttribute(model, profile, "Girth");
+    const inner = optionalAttribute(model, profile, "InternalFilletRadius");
+    const outer = inner > 0 ? inner + wall : 0;
+    return [
+        corner(-x, -y, outer), corner(x, -y, outer), corner(x, -y + girth), corner(x - wall, -y + girth), corner(x - wall, -y + wall, inner), corner(-x + wall, -y + wall, inner),
+        corner(-x + wall, y - wall, inner), corner(x - wall, y - wall, inner), corner(x - wall, y - girth), corner(x, y - girth), corner(x, y, outer), corner(-x, y, outer),
+    ];
+}
+function zShape(model, profile) {
+    const y = finiteAttribute(model, profile, "Depth") / 2;
+    const x = finiteAttribute(model, profile, "FlangeWidth");
+    const web = finiteAttribute(model, profile, "WebThickness") / 2;
+    const flange = finiteAttribute(model, profile, "FlangeThickness");
+    const fillet = optionalAttribute(model, profile, "FilletRadius");
+    const edge = optionalAttribute(model, profile, "EdgeRadius");
+    return [
+        corner(-web, -y), corner(x, -y), corner(x, -y + flange, edge), corner(web, -y + flange, fillet),
+        corner(web, y), corner(-x, y), corner(-x, y - flange, edge), corner(-web, y - flange, fillet),
+    ];
+}
+function asymmetricIShape(model, profile) {
+    const bottom = finiteAttribute(model, profile, "BottomFlangeWidth") / 2;
+    const top = finiteAttribute(model, profile, "TopFlangeWidth") / 2;
+    const y = finiteAttribute(model, profile, "OverallDepth") / 2;
+    const web = finiteAttribute(model, profile, "WebThickness") / 2;
+    const bottomFlange = finiteAttribute(model, profile, "BottomFlangeThickness");
+    const topFlange = model.attribute(profile, "TopFlangeThickness") === null ? bottomFlange : finiteAttribute(model, profile, "TopFlangeThickness");
+    const bottomFillet = optionalAttribute(model, profile, "BottomFlangeFilletRadius");
+    const topFillet = optionalAttribute(model, profile, "TopFlangeFilletRadius");
+    const hasEdges = model.schemaName !== SCHEMA_WITHOUT_EDGE_RADII;
+    const bottomEdge = hasEdges ? optionalAttribute(model, profile, "BottomFlangeEdgeRadius") : 0;
+    const topEdge = hasEdges ? optionalAttribute(model, profile, "TopFlangeEdgeRadius") : 0;
+    const bottomRise = hasEdges ? (bottom - web) * slopeRise(model, profile, "BottomFlangeSlope") : 0;
+    const topRise = hasEdges ? (top - web) * slopeRise(model, profile, "TopFlangeSlope") : 0;
+    return [
+        corner(-bottom, -y), corner(bottom, -y), corner(bottom, -y + bottomFlange, bottomEdge), corner(web, -y + bottomFlange + bottomRise, bottomFillet),
+        corner(web, y - topFlange - topRise, topFillet), corner(top, y - topFlange, topEdge), corner(top, y), corner(-top, y),
+        corner(-top, y - topFlange, topEdge), corner(-web, y - topFlange - topRise, topFillet), corner(-web, -y + bottomFlange + bottomRise, bottomFillet), corner(-bottom, -y + bottomFlange, bottomEdge),
+    ];
+}
+function trapezium(model, profile) {
+    const x = finiteAttribute(model, profile, "BottomXDim") / 2;
+    const top = finiteAttribute(model, profile, "TopXDim");
+    const offset = finiteAttribute(model, profile, "TopXOffset");
+    const y = finiteAttribute(model, profile, "YDim") / 2;
+    return [corner(-x, -y), corner(x, -y), corner(offset + top - x, y), corner(offset - x, y)];
+}
+function ellipse(model, profile) {
+    const a = finiteAttribute(model, profile, "SemiAxis1");
+    const b = finiteAttribute(model, profile, "SemiAxis2");
+    const segments = arcSegments(FULL_TURN);
+    return Array.from({ length: segments }, (_, at) => corner(a * Math.cos((FULL_TURN * at) / segments), b * Math.sin((FULL_TURN * at) / segments)));
+}
+function onPlan(matrix, [x, y]) {
+    return [matrix[0] * x + matrix[4] * y + matrix[12], matrix[1] * x + matrix[5] * y + matrix[13]];
+}
+function isSimilarity(matrix) {
+    const scale = Math.hypot(matrix[0], matrix[1]);
+    return Math.abs(Math.hypot(matrix[4], matrix[5]) - scale) <= SIMILARITY_TOLERANCE * scale && Math.abs(matrix[0] * matrix[4] + matrix[1] * matrix[5]) <= SIMILARITY_TOLERANCE * scale * scale;
+}
+function circlePoints(center, radius) {
+    const segments = arcSegments(FULL_TURN);
+    return Array.from({ length: segments }, (_, at) => [center[0] + radius * Math.cos((FULL_TURN * at) / segments), center[1] + radius * Math.sin((FULL_TURN * at) / segments)]);
+}
+function transformedRegion(region, matrix) {
+    switch (region.kind) {
+        case "composite":
+            return { kind: "composite", parts: region.parts.map((part) => transformedRegion(part, matrix)) };
+        case "circle":
+            if (isSimilarity(matrix)) {
+                const scale = Math.hypot(matrix[0], matrix[1]);
+                return { kind: "circle", center: onPlan(matrix, region.center), radius: region.radius * scale, innerRadius: region.innerRadius * scale };
+            }
+            return transformedRegion({ kind: "polygon", outer: circlePoints(region.center, region.radius), holes: region.innerRadius > 0 ? [circlePoints(region.center, region.innerRadius)] : [] }, matrix);
+        default:
+            return Object.assign(Object.assign({}, region), { outer: wound2(region.outer.map((point) => onPlan(matrix, point)), true), holes: region.holes.map((hole) => wound2(hole.map((point) => onPlan(matrix, point)), false)) });
+    }
+}
+function derived(model, profile, curves) {
+    const parent = model.attribute(profile, "ParentProfile");
+    if (!isReference(parent)) {
+        throw new UnsupportedGeometryError(`#${profile} has no parent profile`);
+    }
+    if (model.schema.isSubtypeOf(model.entity(profile).type, "IfcMirroredProfileDef")) {
+        return transformedRegion(profileRegion(model, parent.ref, curves), MIRROR_ABOUT_Y);
+    }
+    const operator = model.attribute(profile, "Operator");
+    if (!isReference(operator)) {
+        throw new UnsupportedGeometryError(`#${profile} has no transformation operator`);
+    }
+    return transformedRegion(profileRegion(model, parent.ref, curves), operatorMatrix(model, operator.ref));
+}
+function composite(model, profile, curves) {
+    const profiles = model.attribute(profile, "Profiles");
+    const parts = (isList(profiles) ? profiles : []).filter(isReference).map((part) => profileRegion(model, part.ref, curves));
+    if (!parts.length) {
+        throw new UnsupportedGeometryError(`#${profile} combines no profiles`);
+    }
+    return { kind: "composite", parts };
+}
+function polygon(model, profile, outer, holes = []) {
+    return {
+        kind: "polygon",
+        outer: wound2(placed(model, profile, rounded(outer)), true),
+        holes: holes.map((hole) => wound2(placed(model, profile, rounded(hole)), false)),
+    };
+}
+function circle(model, profile, innerRadius) {
+    const [center] = placed(model, profile, [[0, 0]]);
+    return { kind: "circle", center: center, radius: finiteAttribute(model, profile, "Radius"), innerRadius };
+}
+export function profileRegion(model, profile, curves) {
+    const type = model.entity(profile).type;
+    switch (type) {
+        case "IfcArbitraryClosedProfileDef":
+        case "IfcArbitraryProfileDefWithVoids": {
+            const outer = model.attribute(profile, "OuterCurve");
+            if (!isReference(outer)) {
+                throw new UnsupportedGeometryError(`#${profile} has no outer curve`);
+            }
+            const inner = type === "IfcArbitraryProfileDefWithVoids" ? model.attribute(profile, "InnerCurves") : null;
+            const plane = curves.planeOf(outer.ref);
+            const holes = (isList(inner) ? inner : []).filter(isReference).map((curve) => wound2(curves.outline(curve.ref, plane), false));
+            const region = { kind: "polygon", outer: wound2(curves.outline(outer.ref, plane), true), holes };
+            return plane === undefined ? region : Object.assign(Object.assign({}, region), { plane });
+        }
+        case "IfcRectangleProfileDef":
+            return polygon(model, profile, rectangle(model, profile, 0, 0));
+        case "IfcRoundedRectangleProfileDef":
+            return polygon(model, profile, rectangle(model, profile, 0, finiteAttribute(model, profile, "RoundingRadius")));
+        case "IfcRectangleHollowProfileDef": {
+            const wall = finiteAttribute(model, profile, "WallThickness");
+            const outer = rectangle(model, profile, 0, optionalAttribute(model, profile, "OuterFilletRadius"));
+            return polygon(model, profile, outer, [rectangle(model, profile, wall, optionalAttribute(model, profile, "InnerFilletRadius"))]);
+        }
+        case "IfcIShapeProfileDef":
+            return polygon(model, profile, iShape(model, profile));
+        case "IfcLShapeProfileDef":
+            return polygon(model, profile, lShape(model, profile));
+        case "IfcUShapeProfileDef":
+            return polygon(model, profile, uShape(model, profile));
+        case "IfcTShapeProfileDef":
+            return polygon(model, profile, tShape(model, profile));
+        case "IfcCShapeProfileDef":
+            return polygon(model, profile, cShape(model, profile));
+        case "IfcZShapeProfileDef":
+            return polygon(model, profile, zShape(model, profile));
+        case "IfcAsymmetricIShapeProfileDef":
+            return polygon(model, profile, asymmetricIShape(model, profile));
+        case "IfcTrapeziumProfileDef":
+            return polygon(model, profile, trapezium(model, profile));
+        case "IfcEllipseProfileDef":
+            return polygon(model, profile, ellipse(model, profile));
+        case "IfcDerivedProfileDef":
+        case "IfcMirroredProfileDef":
+            return derived(model, profile, curves);
+        case "IfcCompositeProfileDef":
+            return composite(model, profile, curves);
+        case "IfcCircleProfileDef":
+            return circle(model, profile, 0);
+        case "IfcCircleHollowProfileDef": {
+            const inner = finiteAttribute(model, profile, "Radius") - finiteAttribute(model, profile, "WallThickness");
+            if (!(inner > 0)) {
+                throw new UnsupportedGeometryError(`#${profile} has a wall as thick as its radius`);
+            }
+            return circle(model, profile, inner);
+        }
+        default:
+            throw new UnsupportedGeometryError(`An ${type} profile is not supported yet`);
+    }
+}