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

package/lib/geometry/curves.js

@@ -0,0 +1,370 @@
+import { arcThroughThreePoints, pointsOnArc } from "@bitbybit-dev/base/lib/api/services/helpers/arcs";
+import { pointToLocal, squareFrame } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { expandedKnots, knotDomain, nurbsCurvePoint } from "@bitbybit-dev/base/lib/api/services/helpers/nurbs";
+import { newellNormal } from "@bitbybit-dev/base/lib/api/services/helpers/triangulation";
+import { add3, dot3, scale3, subtract3 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import { axisPlacementFrame, directionOf, numbersOf, pointOf } from "../build/placement";
+import { radiansPerUnit } from "../build/project";
+import { isEnumeration, isList, isReference, isTyped } from "../step/values";
+import { UnsupportedGeometryError } from "./errors";
+const FULL_TURN = 2 * Math.PI;
+const SEGMENTS_PER_TURN = 32;
+const MIN_ARC_SEGMENTS = 2;
+const MAX_CURVE_DEPTH = 64;
+const DUPLICATE_RATIO = 1e-9;
+const ANGLE_TOLERANCE = 1e-9;
+const SEGMENT_SLACK = 1e-9;
+const ARC_POINTS = 3;
+const ARC_INDEX = "IFCARCINDEX";
+const PARAMETER_VALUE = "IFCPARAMETERVALUE";
+const PLANE_RATIO = 1e-6;
+const SEGMENTS_PER_SPAN = 8;
+const MAX_SPLINE_SEGMENTS = 512;
+function withoutRepeats(points) {
+    const extent = points.reduce((largest, [x, y]) => Math.max(largest, Math.abs(x), Math.abs(y)), 0);
+    const tolerance = extent * DUPLICATE_RATIO;
+    const same = (a, b) => Math.abs(a[0] - b[0]) <= tolerance && Math.abs(a[1] - b[1]) <= tolerance;
+    const kept = points.filter((point, at) => at === 0 || !same(point, points[at - 1]));
+    return kept.length > 1 && same(kept[0], kept[kept.length - 1]) ? kept.slice(0, -1) : kept;
+}
+function withoutRepeatedPoints(points) {
+    const extent = points.reduce((largest, point) => Math.max(largest, ...point.map(Math.abs)), 0);
+    const tolerance = extent * DUPLICATE_RATIO;
+    return points.filter((point, at) => at === 0 || point.some((value, axis) => Math.abs(value - points[at - 1][axis]) > tolerance));
+}
+export function arcSegments(sweep) {
+    return Math.max(MIN_ARC_SEGMENTS, Math.ceil(Math.abs(sweep) / (FULL_TURN / SEGMENTS_PER_TURN) - SEGMENT_SLACK));
+}
+export function sweepBetween(start, end, counterClockwise) {
+    const ahead = (((end - start) % FULL_TURN) + FULL_TURN) % FULL_TURN;
+    if (ahead < ANGLE_TOLERANCE || FULL_TURN - ahead < ANGLE_TOLERANCE) {
+        return counterClockwise ? FULL_TURN : -FULL_TURN;
+    }
+    return counterClockwise ? ahead : ahead - FULL_TURN;
+}
+function threePointArc(start, middle, end) {
+    const arc = arcThroughThreePoints(start, middle, end);
+    return arc ? pointsOnArc(arc, start, end, arcSegments(arc.sweep)) : [start, middle, end];
+}
+function indexList(value) {
+    const inner = isTyped(value) ? value.value : value;
+    if (!isList(inner) || !inner.every((item) => typeof item === "number" && Number.isSafeInteger(item))) {
+        throw new UnsupportedGeometryError("A curve segment is not a list of point indices");
+    }
+    return inner;
+}
+export class CurveSampler {
+    constructor(model, density = 1) {
+        this.model = model;
+        this.density = density;
+    }
+    outline(curve, plane) {
+        return withoutRepeats(plane === undefined ? this.sampled(curve, 0).map(([x, y]) => [x, y]) : this.polylineIn(curve, plane));
+    }
+    path(curve) {
+        return withoutRepeatedPoints(this.sampled(curve, 0));
+    }
+    endTangents(curve, depth = 0) {
+        var _a, _b;
+        if (depth > MAX_CURVE_DEPTH) {
+            return [undefined, undefined];
+        }
+        const type = this.model.entity(curve).type;
+        if (type === "IfcCircle" || type === "IfcEllipse") {
+            const tangent = this.conicTangent(curve, 0, 1);
+            return [tangent, tangent];
+        }
+        if (type === "IfcCompositeCurve" || type === "IfcCompositeCurveOnSurface") {
+            const segments = this.model.attribute(curve, "Segments");
+            const list = (isList(segments) ? segments : []).filter(isReference);
+            const ends = (segment, last) => {
+                const parent = segment === undefined ? null : this.model.attribute(segment, "ParentCurve");
+                if (!isReference(parent)) {
+                    return undefined;
+                }
+                const reversed = this.model.attribute(segment, "SameSense") === false;
+                const [start, end] = this.endTangents(parent.ref, depth + 1);
+                const chosen = last !== reversed ? end : start;
+                return chosen && reversed ? scale3(chosen, -1) : chosen;
+            };
+            return [ends((_a = list[0]) === null || _a === void 0 ? void 0 : _a.ref, false), ends((_b = list[list.length - 1]) === null || _b === void 0 ? void 0 : _b.ref, true)];
+        }
+        if (type !== "IfcTrimmedCurve") {
+            return [undefined, undefined];
+        }
+        const basis = this.model.attribute(curve, "BasisCurve");
+        if (!isReference(basis) || !["IfcCircle", "IfcEllipse"].includes(this.model.entity(basis.ref).type)) {
+            return [undefined, undefined];
+        }
+        const preference = this.model.attribute(curve, "MasterRepresentation");
+        const byParameter = isEnumeration(preference) && preference.enum === "PARAMETER";
+        const first = this.conicAngle(basis.ref, this.trimOf(this.model.attribute(curve, "Trim1"), curve, "Trim1"), byParameter);
+        const second = this.conicAngle(basis.ref, this.trimOf(this.model.attribute(curve, "Trim2"), curve, "Trim2"), byParameter);
+        const sweep = sweepBetween(first, second, this.model.attribute(curve, "SenseAgreement") !== false);
+        return [this.conicTangent(basis.ref, first, Math.sign(sweep)), this.conicTangent(basis.ref, first + sweep, Math.sign(sweep))];
+    }
+    parameterSpan(curve) {
+        const type = this.model.entity(curve).type;
+        if (type === "IfcPolyline") {
+            return Math.max(0, this.polylinePoints(curve).length - 1);
+        }
+        if (type !== "IfcTrimmedCurve") {
+            return undefined;
+        }
+        const basis = this.model.attribute(curve, "BasisCurve");
+        const first = this.trimOf(this.model.attribute(curve, "Trim1"), curve, "Trim1");
+        const second = this.trimOf(this.model.attribute(curve, "Trim2"), curve, "Trim2");
+        if (!isReference(basis) || first.parameter === undefined || second.parameter === undefined) {
+            return undefined;
+        }
+        const basisType = this.model.entity(basis.ref).type;
+        if (basisType === "IfcLine") {
+            return Math.abs(second.parameter - first.parameter);
+        }
+        if (basisType !== "IfcCircle" && basisType !== "IfcEllipse") {
+            return undefined;
+        }
+        const forward = this.model.attribute(curve, "SenseAgreement") !== false;
+        const sweep = sweepBetween(first.parameter * this.radiansPerUnit, second.parameter * this.radiansPerUnit, forward);
+        return Math.abs(sweep) / this.radiansPerUnit;
+    }
+    planeOf(curve) {
+        if (this.model.entity(curve).type !== "IfcPolyline") {
+            return undefined;
+        }
+        const points = this.polylinePoints(curve);
+        if (points.every((point) => point[2] === 0)) {
+            return undefined;
+        }
+        const plane = points.length < ARC_POINTS ? "normal" : squareFrame(points[0], newellNormal(points.flat(), points.map((_, at) => at)), subtract3(points[1], points[0]));
+        if (typeof plane === "string") {
+            throw new UnsupportedGeometryError(`#${curve} is an outline with no area`);
+        }
+        const extent = points.reduce((largest, point) => Math.max(largest, ...point.map((value, axis) => Math.abs(value - points[0][axis]))), 0);
+        if (points.some((point) => Math.abs(pointToLocal(plane, point)[2]) > extent * PLANE_RATIO)) {
+            throw new UnsupportedGeometryError(`#${curve} is an outline whose points do not lie in one plane`);
+        }
+        return plane;
+    }
+    get radiansPerUnit() {
+        var _a;
+        (_a = this.angleUnit) !== null && _a !== void 0 ? _a : (this.angleUnit = radiansPerUnit(this.model));
+        return this.angleUnit;
+    }
+    sampled(curve, depth) {
+        if (depth > MAX_CURVE_DEPTH) {
+            throw new UnsupportedGeometryError(`#${curve} nests curves more than ${MAX_CURVE_DEPTH} deep, or through itself`);
+        }
+        const type = this.model.entity(curve).type;
+        switch (type) {
+            case "IfcPolyline":
+                return this.polylinePoints(curve);
+            case "IfcIndexedPolyCurve":
+                return this.indexed(curve);
+            case "IfcCompositeCurve":
+            case "IfcCompositeCurveOnSurface":
+                return this.composite(curve, depth);
+            case "IfcTrimmedCurve":
+                return this.trimmed(curve);
+            case "IfcCircle":
+            case "IfcEllipse":
+                return this.conic(curve, 0, FULL_TURN, undefined, undefined);
+            case "IfcBSplineCurveWithKnots":
+            case "IfcRationalBSplineCurveWithKnots": {
+                const spline = this.bspline(curve);
+                return this.splinePoints(spline, ...knotDomain(spline.degree, spline.knots));
+            }
+            default:
+                throw new UnsupportedGeometryError(`An ${type} outline is not supported yet`);
+        }
+    }
+    polylinePoints(curve) {
+        const points = this.model.attribute(curve, "Points");
+        return (isList(points) ? points : []).map((point) => pointOf(this.model, point));
+    }
+    polylineIn(curve, plane) {
+        if (this.model.entity(curve).type !== "IfcPolyline") {
+            throw new UnsupportedGeometryError(`#${curve} lies outside its profile's plane, which only a polyline may`);
+        }
+        return this.polylinePoints(curve).map((point) => {
+            const [x, y] = pointToLocal(plane, point);
+            return [x, y];
+        });
+    }
+    indexed(curve) {
+        const list = this.model.attribute(curve, "Points");
+        if (!isReference(list)) {
+            throw new UnsupportedGeometryError(`#${curve} has no points`);
+        }
+        const coordinates = this.model.attribute(list.ref, "CoordList");
+        const all = (isList(coordinates) ? coordinates : []).map((item, index) => {
+            var _a, _b, _c;
+            const numbers = numbersOf(item, `#${list.ref} point ${index}`);
+            return [(_a = numbers[0]) !== null && _a !== void 0 ? _a : 0, (_b = numbers[1]) !== null && _b !== void 0 ? _b : 0, (_c = numbers[2]) !== null && _c !== void 0 ? _c : 0];
+        });
+        const segments = this.model.attribute(curve, "Segments");
+        if (!isList(segments)) {
+            return all;
+        }
+        const pointAt = (index) => {
+            const point = all[index - 1];
+            if (!point) {
+                throw new UnsupportedGeometryError(`#${curve} names point ${index}, which its list does not hold`);
+            }
+            return point;
+        };
+        const points = [];
+        let last;
+        for (const segment of segments) {
+            const indices = indexList(segment);
+            const named = indices.map(pointAt);
+            const isArc = isTyped(segment) && segment.type.toUpperCase() === ARC_INDEX;
+            if (isArc && named.length !== ARC_POINTS) {
+                throw new UnsupportedGeometryError(`#${curve} has an arc through ${named.length} points, not ${ARC_POINTS}`);
+            }
+            const sampled = isArc ? threePointArc(named[0], named[1], named[2]) : named;
+            points.push(...(last !== undefined && last === indices[0] ? sampled.slice(1) : sampled));
+            last = indices[indices.length - 1];
+        }
+        return points;
+    }
+    composite(curve, depth) {
+        const segments = this.model.attribute(curve, "Segments");
+        const points = [];
+        for (const segment of isList(segments) ? segments : []) {
+            if (!isReference(segment)) {
+                throw new UnsupportedGeometryError(`#${curve} has a segment that is not a reference`);
+            }
+            const parent = this.model.attribute(segment.ref, "ParentCurve");
+            if (!isReference(parent)) {
+                throw new UnsupportedGeometryError(`#${segment.ref} has no parent curve`);
+            }
+            const path = this.sampled(parent.ref, depth + 1);
+            points.push(...(this.model.attribute(segment.ref, "SameSense") === false ? [...path].reverse() : path));
+        }
+        if (!points.length) {
+            throw new UnsupportedGeometryError(`#${curve} has no segments`);
+        }
+        return points;
+    }
+    trimOf(value, curve, name) {
+        let point;
+        let parameter;
+        for (const item of isList(value) ? value : []) {
+            if (isReference(item)) {
+                point = pointOf(this.model, item);
+            }
+            else if (isTyped(item) && item.type.toUpperCase() === PARAMETER_VALUE && typeof item.value === "number" && Number.isFinite(item.value)) {
+                parameter = item.value;
+            }
+        }
+        if (point === undefined && parameter === undefined) {
+            throw new UnsupportedGeometryError(`#${curve} has no ${name} it can be trimmed at`);
+        }
+        return { point, parameter };
+    }
+    trimmed(curve) {
+        const basis = this.model.attribute(curve, "BasisCurve");
+        if (!isReference(basis)) {
+            throw new UnsupportedGeometryError(`#${curve} has no basis curve`);
+        }
+        const preference = this.model.attribute(curve, "MasterRepresentation");
+        const byParameter = isEnumeration(preference) && preference.enum === "PARAMETER";
+        const first = this.trimOf(this.model.attribute(curve, "Trim1"), curve, "Trim1");
+        const second = this.trimOf(this.model.attribute(curve, "Trim2"), curve, "Trim2");
+        const forward = this.model.attribute(curve, "SenseAgreement") !== false;
+        const type = this.model.entity(basis.ref).type;
+        if (type === "IfcLine") {
+            return [this.linePoint(basis.ref, first, byParameter), this.linePoint(basis.ref, second, byParameter)];
+        }
+        if (type !== "IfcCircle" && type !== "IfcEllipse") {
+            throw new UnsupportedGeometryError(`A trimmed ${type} is not supported yet`);
+        }
+        const start = this.conicAngle(basis.ref, first, byParameter);
+        const end = this.conicAngle(basis.ref, second, byParameter);
+        const exact = (trim) => (byParameter && trim.parameter !== undefined ? undefined : trim.point);
+        return this.conic(basis.ref, start, sweepBetween(start, end, forward), exact(first), exact(second));
+    }
+    linePoint(line, trim, byParameter) {
+        if (trim.point !== undefined && !(byParameter && trim.parameter !== undefined)) {
+            return trim.point;
+        }
+        const [x, y, z] = pointOf(this.model, this.model.attribute(line, "Pnt"));
+        const vector = this.model.attribute(line, "Dir");
+        if (!isReference(vector)) {
+            throw new UnsupportedGeometryError(`#${line} has no direction`);
+        }
+        const [dx, dy, dz] = directionOf(this.model, this.model.attribute(vector.ref, "Orientation"), [1, 0, 0]);
+        const magnitude = this.model.attribute(vector.ref, "Magnitude");
+        const length = Math.hypot(dx, dy, dz);
+        if (typeof magnitude !== "number" || !(length > 0)) {
+            throw new UnsupportedGeometryError(`#${vector.ref} has no direction or no magnitude`);
+        }
+        const step = trim.parameter * magnitude / length;
+        return [x + dx * step, y + dy * step, z + dz * step];
+    }
+    conicAngle(conic, trim, byParameter) {
+        if (trim.parameter !== undefined && (byParameter || trim.point === undefined)) {
+            return trim.parameter * this.radiansPerUnit;
+        }
+        const { origin, x, y, radii } = this.conicFrame(conic);
+        const offset = subtract3(trim.point, origin);
+        return Math.atan2(dot3(offset, y) / radii[1], dot3(offset, x) / radii[0]);
+    }
+    conicFrame(conic) {
+        const position = this.model.attribute(conic, "Position");
+        if (!isReference(position)) {
+            throw new UnsupportedGeometryError(`#${conic} has no position`);
+        }
+        const frame = axisPlacementFrame(this.model, position.ref);
+        const circle = this.model.entity(conic).type === "IfcCircle";
+        const first = this.model.attribute(conic, circle ? "Radius" : "SemiAxis1");
+        const second = circle ? first : this.model.attribute(conic, "SemiAxis2");
+        if (typeof first !== "number" || typeof second !== "number" || !(first > 0) || !(second > 0)) {
+            throw new UnsupportedGeometryError(`#${conic} has no radius above zero`);
+        }
+        return { origin: frame.origin, x: frame.x, y: frame.y, radii: [first, second] };
+    }
+    bspline(curve) {
+        const degree = this.model.attribute(curve, "Degree");
+        const controls = this.model.attribute(curve, "ControlPointsList");
+        const multiplicities = this.model.attribute(curve, "KnotMultiplicities");
+        const knots = this.model.attribute(curve, "Knots");
+        const isWhole = (value) => isList(value) && value.every((item) => typeof item === "number" && Number.isFinite(item));
+        if (typeof degree !== "number" || !(degree >= 1) || !isList(controls) || !isWhole(multiplicities) || !isWhole(knots)) {
+            throw new UnsupportedGeometryError(`#${curve} is not a B-spline curve it can read`);
+        }
+        const points = controls.map((point) => pointOf(this.model, point));
+        const expanded = expandedKnots(knots, multiplicities);
+        if (expanded.length !== points.length + degree + 1) {
+            throw new UnsupportedGeometryError(`#${curve} has ${expanded.length} knots for ${points.length} control points of degree ${degree}`);
+        }
+        const weights = this.model.entity(curve).type === "IfcRationalBSplineCurveWithKnots" ? this.model.attribute(curve, "WeightsData") : null;
+        return { degree, points, weights: isWhole(weights) ? weights : undefined, knots: expanded };
+    }
+    splinePoints(spline, from, to) {
+        const spans = new Set(spline.knots).size - 1;
+        const segments = Math.min(MAX_SPLINE_SEGMENTS * this.density, Math.max(SEGMENTS_PER_SPAN, spans * SEGMENTS_PER_SPAN * spline.degree) * this.density);
+        return Array.from({ length: segments + 1 }, (_, at) => nurbsCurvePoint(spline.degree, spline.points, spline.weights, spline.knots, from + ((to - from) * at) / segments));
+    }
+    conicTangent(conic, angle, sense) {
+        const { x, y, radii } = this.conicFrame(conic);
+        return scale3(add3(scale3(x, -radii[0] * Math.sin(angle)), scale3(y, radii[1] * Math.cos(angle))), sense);
+    }
+    conic(conic, start, sweep, from, to) {
+        const { origin, x, y, radii } = this.conicFrame(conic);
+        const segments = arcSegments(sweep) * this.density;
+        const points = [];
+        for (let step = 0; step <= segments; step++) {
+            const angle = start + sweep * step / segments;
+            points.push(add3(origin, add3(scale3(x, radii[0] * Math.cos(angle)), scale3(y, radii[1] * Math.sin(angle)))));
+        }
+        if (from) {
+            points[0] = from;
+        }
+        if (to) {
+            points[segments] = to;
+        }
+        return points;
+    }
+}

package/lib/geometry/edges.constants.d.ts

@@ -0,0 +1,5 @@
+export declare const CLOSED_EDGE_RATIO = 1e-9;
+export declare const PARAMETER_SEARCH_STEPS = 64;
+export declare const PARAMETER_SEARCH_TOLERANCE = 1e-12;
+export declare const GOLDEN_SECTION: number;
+export declare const WEIGHTED_POINTS_RATIO = 0.000001;

package/lib/geometry/edges.constants.js

@@ -0,0 +1,5 @@
+export const CLOSED_EDGE_RATIO = 1e-9;
+export const PARAMETER_SEARCH_STEPS = 64;
+export const PARAMETER_SEARCH_TOLERANCE = 1e-12;
+export const GOLDEN_SECTION = (Math.sqrt(5) - 1) / 2;
+export const WEIGHTED_POINTS_RATIO = 1e-6;

package/lib/geometry/edges.d.ts

@@ -0,0 +1,21 @@
+import type { Base } from "@bitbybit-dev/base";
+import type { ModelSnapshot } from "../model/snapshot";
+import { type CurveSampler } from "./curves";
+import type { BSplineCurve } from "./geometry-types";
+export declare function dividedByWeights(spline: BSplineCurve): BSplineCurve;
+export declare class EdgeSampler {
+    private readonly model;
+    private readonly curves;
+    private readonly sampled;
+    constructor(model: ModelSnapshot, curves: CurveSampler);
+    loop(loop: number): Base.Point3[];
+    private edge;
+    private along;
+    private conic;
+    private spline;
+    private meetingVertices;
+    private vertex;
+    private pointAt;
+    private value;
+    private references;
+}

package/lib/geometry/edges.js

@@ -0,0 +1,164 @@
+import { knotDomain, nurbsCurvePoint } from "@bitbybit-dev/base/lib/api/services/helpers/nurbs";
+import { add3, dot3, length3, scale3, subtract3 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import { numbersOf } from "../build/placement";
+import { isReference } from "../step/values";
+import { arcSegments, sweepBetween } from "./curves";
+import { UnsupportedGeometryError } from "./errors";
+import { referencesIn } from "./references";
+import { CLOSED_EDGE_RATIO, GOLDEN_SECTION, PARAMETER_SEARCH_STEPS, PARAMETER_SEARCH_TOLERANCE, WEIGHTED_POINTS_RATIO } from "./edges.constants";
+const CURVE_ON_SURFACE = new Set(["IfcSurfaceCurve", "IfcIntersectionCurve", "IfcSeamCurve"]);
+const SPLINES = new Set(["IfcBSplineCurveWithKnots", "IfcRationalBSplineCurveWithKnots"]);
+function distance(a, b) {
+    return length3(subtract3(a, b));
+}
+function nearestParameter(spline, point, from, to) {
+    const at = (t) => distance(nurbsCurvePoint(spline.degree, spline.points, spline.weights, spline.knots, t), point);
+    let best = from;
+    let bestDistance = Infinity;
+    for (let step = 0; step <= PARAMETER_SEARCH_STEPS; step++) {
+        const t = from + ((to - from) * step) / PARAMETER_SEARCH_STEPS;
+        const d = at(t);
+        if (d < bestDistance) {
+            best = t;
+            bestDistance = d;
+        }
+    }
+    const width = (to - from) / PARAMETER_SEARCH_STEPS;
+    let low = Math.max(from, best - width);
+    let high = Math.min(to, best + width);
+    while (high - low > PARAMETER_SEARCH_TOLERANCE * (to - from)) {
+        const left = high - GOLDEN_SECTION * (high - low);
+        const right = low + GOLDEN_SECTION * (high - low);
+        if (at(left) < at(right)) {
+            high = right;
+        }
+        else {
+            low = left;
+        }
+    }
+    return (low + high) / 2;
+}
+export function dividedByWeights(spline) {
+    var _a;
+    const weights = (_a = spline.weights) !== null && _a !== void 0 ? _a : [];
+    return Object.assign(Object.assign({}, spline), { points: spline.points.map((point, at) => { var _a; return scale3(point, 1 / ((_a = weights[at]) !== null && _a !== void 0 ? _a : 1)); }) });
+}
+export class EdgeSampler {
+    constructor(model, curves) {
+        this.sampled = new Map();
+        this.model = model;
+        this.curves = curves;
+    }
+    loop(loop) {
+        const type = this.model.typeOf(loop);
+        if (type === "IfcPolyLoop") {
+            return this.references(loop, "Polygon").map((point) => this.pointAt(point));
+        }
+        if (type !== "IfcEdgeLoop") {
+            throw new UnsupportedGeometryError(`A face bounded by an ${type !== null && type !== void 0 ? type : `unknown #${loop}`} is not supported yet`);
+        }
+        const points = [];
+        for (const oriented of this.references(loop, "EdgeList")) {
+            const element = this.value(oriented, "EdgeElement");
+            if (!isReference(element)) {
+                throw new UnsupportedGeometryError(`#${oriented} has no edge`);
+            }
+            const along = this.edge(element.ref);
+            const run = this.value(oriented, "Orientation") === false ? [...along].reverse() : along;
+            points.push(...run.slice(0, -1));
+        }
+        return points;
+    }
+    edge(edge) {
+        const known = this.sampled.get(edge);
+        if (known) {
+            return known;
+        }
+        const start = this.vertex(this.value(edge, "EdgeStart"), edge);
+        const end = this.vertex(this.value(edge, "EdgeEnd"), edge);
+        const geometry = this.value(edge, "EdgeGeometry");
+        const points = isReference(geometry) ? this.along(geometry.ref, start, end, this.value(edge, "SameSense") !== false) : [start, end];
+        const exact = [start, ...points.slice(1, -1), end];
+        this.sampled.set(edge, exact);
+        return exact;
+    }
+    along(curve, start, end, sameSense) {
+        const type = this.model.entity(curve).type;
+        if (type === "IfcLine") {
+            return [start, end];
+        }
+        if (CURVE_ON_SURFACE.has(type)) {
+            const curve3 = this.model.attribute(curve, "Curve3D");
+            if (!isReference(curve3)) {
+                throw new UnsupportedGeometryError(`#${curve} has no curve in space`);
+            }
+            return this.along(curve3.ref, start, end, sameSense);
+        }
+        if (type === "IfcCircle" || type === "IfcEllipse") {
+            return this.conic(curve, start, end, sameSense);
+        }
+        if (SPLINES.has(type)) {
+            return this.spline(curve, start, end, sameSense);
+        }
+        const path = this.curves.path(curve);
+        const forward = distance(path[0], start) + distance(path[path.length - 1], end) <= distance(path[0], end) + distance(path[path.length - 1], start);
+        return forward ? path : [...path].reverse();
+    }
+    conic(conic, start, end, sameSense) {
+        const { origin, x, y, radii } = this.curves.conicFrame(conic);
+        const angleOf = (point) => {
+            const offset = subtract3(point, origin);
+            return Math.atan2(dot3(offset, y) / radii[1], dot3(offset, x) / radii[0]);
+        };
+        const first = angleOf(start);
+        const sweep = sweepBetween(first, angleOf(end), sameSense);
+        const segments = arcSegments(sweep);
+        return Array.from({ length: segments + 1 }, (_, step) => {
+            const angle = first + (sweep * step) / segments;
+            return add3(origin, add3(scale3(x, radii[0] * Math.cos(angle)), scale3(y, radii[1] * Math.sin(angle))));
+        });
+    }
+    spline(curve, start, end, sameSense) {
+        const spline = this.meetingVertices(this.curves.bspline(curve), start, end);
+        const [from, to] = knotDomain(spline.degree, spline.knots);
+        const closed = distance(start, end) <= CLOSED_EDGE_RATIO * Math.max(1, length3(start));
+        if (closed) {
+            return this.curves.splinePoints(spline, sameSense ? from : to, sameSense ? to : from);
+        }
+        return this.curves.splinePoints(spline, nearestParameter(spline, start, from, to), nearestParameter(spline, end, from, to));
+    }
+    meetingVertices(spline, start, end) {
+        if (spline.weights === undefined) {
+            return spline;
+        }
+        const reach = Math.max(1, length3(start), length3(end)) * WEIGHTED_POINTS_RATIO;
+        const misses = (candidate) => {
+            const [from, to] = knotDomain(candidate.degree, candidate.knots);
+            const [first, last] = [from, to].map((t) => nurbsCurvePoint(candidate.degree, candidate.points, candidate.weights, candidate.knots, t));
+            return Math.min(distance(first, start) + distance(last, end), distance(first, end) + distance(last, start));
+        };
+        if (misses(spline) <= reach) {
+            return spline;
+        }
+        const divided = dividedByWeights(spline);
+        return misses(divided) <= reach ? divided : spline;
+    }
+    vertex(value, edge) {
+        const geometry = isReference(value) ? this.value(value.ref, "VertexGeometry") : null;
+        if (!isReference(geometry)) {
+            throw new UnsupportedGeometryError(`#${edge} has a vertex without a point`);
+        }
+        return this.pointAt(geometry.ref);
+    }
+    pointAt(point) {
+        var _a, _b, _c;
+        const coordinates = numbersOf(this.value(point, "Coordinates"), `#${point} 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];
+    }
+    value(id, name) {
+        return this.model.valueOf(this.model.peek(id), name);
+    }
+    references(id, name) {
+        return referencesIn(this.model, id, name);
+    }
+}

package/lib/geometry/elements.d.ts

@@ -0,0 +1,3 @@
+import type { ModelSnapshot } from "../model/snapshot";
+import type { ModelRecipe } from "./geometry-types";
+export declare function modelRecipe(model: ModelSnapshot, globalIds: readonly string[] | undefined, millimetresPerUnit: number, fallbackTolerance: number, isGroupedByClass?: boolean): ModelRecipe;