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

package/lib/geometry/advanced.js

@@ -0,0 +1,292 @@
+import { squareFrame } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { refinedSurfaceMesh } from "@bitbybit-dev/base/lib/api/services/helpers/surface-triangulation";
+import { newellNormal } from "@bitbybit-dev/base/lib/api/services/helpers/triangulation";
+import { cross3, dot3, length3, subtract3 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import { isList, isReference } from "../step/values";
+import { UnsupportedGeometryError } from "./errors";
+import { CUT_SAMPLES, CUT_TURN, FIT_PROBES, FIT_TOLERANCE, MIN_LOOP_POINTS, NORMAL_STEP, TRIANGLE_CORNERS } from "./surfaces.constants";
+import { parametricSurface, plane } from "./surfaces";
+const OUTER_BOUND = "IfcFaceOuterBound";
+const FACE_SURFACE = "IfcFaceSurface";
+function unwrapped(value, previous, period) {
+    return period === undefined ? value : value + period * Math.round((previous - value) / period);
+}
+function signedArea(uv) {
+    let twice = 0;
+    for (let at = 0, previous = uv.length - 1; at < uv.length; previous = at++) {
+        twice += uv[previous][0] * uv[at][1] - uv[at][0] * uv[previous][1];
+    }
+    return twice / 2;
+}
+function planeThrough(points) {
+    const normal = newellNormal(points.flat(), points.map((_, at) => at));
+    const frame = squareFrame(points[0], normal, subtract3(points[1], points[0]));
+    if (typeof frame === "string") {
+        throw new UnsupportedGeometryError("A face bounded by edges has no area");
+    }
+    return plane(frame);
+}
+export class AdvancedFaces {
+    constructor(model, curves, edges) {
+        this.surfaces = new Map();
+        this.model = model;
+        this.curves = curves;
+        this.edges = edges;
+    }
+    face(face, bounds) {
+        var _a, _b, _c;
+        const loops = bounds.map((bound) => this.bound(bound));
+        const surfaceValue = this.model.schema.isSubtypeOf((_a = this.model.typeOf(face)) !== null && _a !== void 0 ? _a : "", FACE_SURFACE) ? this.value(face, "FaceSurface") : null;
+        const surface = isReference(surfaceValue) ? this.fitting(surfaceValue.ref, loops) : planeThrough((_c = (_b = loops.find((loop) => loop.outer)) === null || _b === void 0 ? void 0 : _b.points) !== null && _c !== void 0 ? _c : loops[0].points);
+        const sameSense = !isReference(surfaceValue) || this.value(face, "SameSense") !== false;
+        const placed = loops.map((loop) => this.parameters(surface, loop));
+        const { uv, positions, indices } = this.assembled(surface, placed, sameSense);
+        const mesh = refinedSurfaceMesh(uv, positions, indices, (u, v) => surface.point(u, v));
+        return this.oriented(mesh, surface, uv, sameSense);
+    }
+    surface(surface) {
+        if (!this.surfaces.has(surface)) {
+            this.surfaces.set(surface, parametricSurface(this.model, this.curves, surface));
+        }
+        const known = this.surfaces.get(surface);
+        if (!known) {
+            throw new UnsupportedGeometryError(`A face on an ${this.model.entity(surface).type} is not supported yet`);
+        }
+        return known;
+    }
+    fitting(surface, loops) {
+        const written = this.surface(surface);
+        if (this.model.entity(surface).type !== "IfcRationalBSplineSurfaceWithKnots") {
+            return written;
+        }
+        const probes = loops.flatMap((loop) => loop.points).filter((_, at, all) => at % Math.max(1, Math.floor(all.length / FIT_PROBES)) === 0);
+        const missOf = (candidate) => Math.max(...probes.map((point) => {
+            const [u, v] = candidate.parameters(point, undefined);
+            return length3(subtract3(candidate.point(u, v), point));
+        }));
+        const reach = Math.max(1, ...probes.map(length3)) * FIT_TOLERANCE;
+        const asWritten = missOf(written);
+        if (asWritten <= reach) {
+            return written;
+        }
+        const divided = parametricSurface(this.model, this.curves, surface, true);
+        return divided && missOf(divided) < asWritten ? divided : written;
+    }
+    bound(bound) {
+        const loop = this.value(bound, "Bound");
+        if (!isReference(loop)) {
+            throw new UnsupportedGeometryError(`#${bound} has no loop`);
+        }
+        const points = this.edges.loop(loop.ref);
+        if (points.length < MIN_LOOP_POINTS) {
+            throw new UnsupportedGeometryError(`#${bound} bounds no area`);
+        }
+        return { points: this.value(bound, "Orientation") === false ? [...points].reverse() : points, uv: [], winding: [0, 0], outer: this.model.schema.isSubtypeOf(this.model.peek(bound).type, OUTER_BOUND) };
+    }
+    parameters(surface, loop) {
+        const uv = [];
+        const points = [];
+        let previous;
+        let pole;
+        const regular = loop.points.findIndex((point) => !surface.parameters(point, undefined).some(Number.isNaN));
+        const turned = regular > 0 ? [...loop.points.slice(regular), ...loop.points.slice(0, regular)] : loop.points;
+        turned.forEach((point) => {
+            const [u, v] = surface.parameters(point, previous);
+            const undefinedAxis = Number.isNaN(u) ? 0 : Number.isNaN(v) ? 1 : -1;
+            if (undefinedAxis >= 0 && previous) {
+                const arrival = undefinedAxis === 0 ? [previous[0], v] : [u, previous[1]];
+                pole !== null && pole !== void 0 ? pole : (pole = { axis: undefinedAxis, at: uv.length });
+                uv.push(arrival, arrival);
+                points.push(point, point);
+                previous = arrival;
+                return;
+            }
+            const placed = previous ? [unwrapped(u, previous[0], surface.periods[0]), unwrapped(v, previous[1], surface.periods[1])] : [u, v];
+            if (pole && uv.length === pole.at + 2) {
+                const departure = pole.axis === 0 ? [placed[0], uv[pole.at][1]] : [uv[pole.at][0], placed[1]];
+                uv[pole.at + 1] = departure;
+            }
+            uv.push(placed);
+            points.push(point);
+            previous = placed;
+        });
+        if (pole) {
+            this.leastWound(surface, uv, pole.axis, pole.at + 1);
+        }
+        const winding = [0, 1].map((axis) => this.windingOf(surface, uv, axis));
+        return Object.assign(Object.assign({}, loop), { points, uv, winding });
+    }
+    windingOf(surface, uv, axis) {
+        const period = surface.periods[axis];
+        if (period === undefined) {
+            return 0;
+        }
+        const first = uv[0];
+        const last = uv[uv.length - 1];
+        return Math.round((unwrapped(first[axis], last[axis], period) - first[axis]) / period);
+    }
+    leastWound(surface, uv, axis, from) {
+        const period = surface.periods[axis];
+        const winding = this.windingOf(surface, uv, axis);
+        if (period === undefined || winding === 0) {
+            return;
+        }
+        for (let at = from; at < uv.length; at++) {
+            const point = uv[at];
+            uv[at] = axis === 0 ? [point[0] - winding * period, point[1]] : [point[0], point[1] - winding * period];
+        }
+    }
+    assembled(surface, loops, sameSense) {
+        const winding = loops.filter((loop) => loop.winding[0] !== 0 || loop.winding[1] !== 0);
+        const plain = loops.filter((loop) => loop.winding[0] === 0 && loop.winding[1] === 0);
+        let outer;
+        let holes;
+        if (winding.length === 0) {
+            const flagged = plain.findIndex((loop) => loop.outer);
+            const largest = plain.map((loop) => Math.abs(signedArea(loop.uv))).reduce((best, area, at, areas) => (area > areas[best] ? at : best), 0);
+            const index = flagged >= 0 ? flagged : largest;
+            outer = plain[index];
+            holes = plain.filter((_, at) => at !== index);
+        }
+        else if (winding.length === 2) {
+            outer = this.stitched(surface, winding[0], winding[1]);
+            holes = plain;
+        }
+        else if (winding.length === 1) {
+            outer = this.closedAtPole(surface, winding[0], sameSense);
+            holes = plain;
+        }
+        else {
+            throw new UnsupportedGeometryError(`A face whose ${winding.length} loops wrap around its surface is not supported yet`);
+        }
+        const uv = [];
+        const positions = [];
+        const indices = [outer, ...holes.map((hole) => this.shiftedInto(surface, hole, outer))].map((loop) => loop.uv.map((point, at) => {
+            uv.push(point);
+            positions.push(loop.points[at]);
+            return uv.length - 1;
+        }));
+        return { uv, positions, indices };
+    }
+    shiftedInto(surface, hole, outer) {
+        const shift = [0, 1].map((axis) => {
+            const period = surface.periods[axis];
+            if (period === undefined) {
+                return 0;
+            }
+            const low = Math.min(...outer.uv.map((point) => point[axis]));
+            const mean = hole.uv.reduce((sum, point) => sum + point[axis], 0) / hole.uv.length;
+            return -period * Math.floor((mean - low) / period);
+        });
+        return Object.assign(Object.assign({}, hole), { uv: hole.uv.map(([u, v]) => [u + shift[0], v + shift[1]]) });
+    }
+    stitched(surface, first, second) {
+        var _a;
+        const axis = first.winding[0] !== 0 ? 0 : 1;
+        const period = surface.periods[axis];
+        if (second.winding[axis] !== -first.winding[axis] || first.winding[1 - axis] !== 0 || second.winding[1 - axis] !== 0) {
+            throw new UnsupportedGeometryError("A face whose loops wrap around its surface the same way is not supported yet");
+        }
+        const shift = (point, by) => (axis === 0 ? [point[0] + by, point[1]] : [point[0], point[1] + by]);
+        const start = first.uv[0];
+        const closing = shift(start, first.winding[axis] * period);
+        const distances = second.uv.map((point) => {
+            const aligned = unwrapped(point[axis], closing[axis], period);
+            return Math.hypot(aligned - closing[axis], point[1 - axis] - closing[1 - axis]);
+        });
+        const join = distances.indexOf(Math.min(...distances));
+        const turned = [...second.uv.slice(join), ...second.uv.slice(0, join)];
+        const turnedPoints = [...second.points.slice(join), ...second.points.slice(0, join)];
+        const run = [];
+        for (const point of turned) {
+            const previous = (_a = run[run.length - 1]) !== null && _a !== void 0 ? _a : closing;
+            run.push(axis === 0 ? [unwrapped(point[0], previous[0], period), point[1]] : [point[0], unwrapped(point[1], previous[1], period)]);
+        }
+        const back = shift(run[0], second.winding[axis] * period);
+        const cut = this.across(surface, closing, run[0]);
+        const offset = second.winding[axis] * period;
+        const cutBack = [...cut.uv].reverse().map((point) => shift(point, offset));
+        return {
+            points: [...first.points, first.points[0], ...cut.points, ...turnedPoints, turnedPoints[0], ...[...cut.points].reverse()],
+            uv: [...first.uv, closing, ...cut.uv, ...run, back, ...cutBack],
+            winding: [0, 0],
+        };
+    }
+    closedAtPole(surface, loop, sameSense) {
+        const axis = loop.winding[0] !== 0 ? 0 : 1;
+        const across = 1 - axis;
+        const direction = Math.sign(loop.winding[axis]);
+        const left = axis === 0 ? direction : -direction;
+        const pole = surface.pole(across, sameSense ? left : -left);
+        if (pole === undefined) {
+            throw new UnsupportedGeometryError("A face that wraps around its surface without closing over a pole is not supported yet");
+        }
+        const period = surface.periods[axis];
+        const start = loop.uv[0];
+        const end = axis === 0 ? [start[0] + loop.winding[0] * period, start[1]] : [start[0], start[1] + loop.winding[1] * period];
+        const atPole = (point) => (axis === 0 ? [point[0], pole] : [pole, point[1]]);
+        const poleUv = atPole(start);
+        const polePoint = surface.point(poleUv[0], poleUv[1]);
+        const up = this.across(surface, end, atPole(end));
+        const turn = loop.winding[axis] * period;
+        const down = [...up.uv].reverse().map(([u, v]) => (axis === 0 ? [u - turn, v] : [u, v - turn]));
+        return {
+            points: [...loop.points, loop.points[0], ...up.points, polePoint, polePoint, ...[...up.points].reverse()],
+            uv: [...loop.uv, end, ...up.uv, atPole(end), poleUv, ...down],
+            winding: [0, 0],
+        };
+    }
+    across(surface, from, to) {
+        const at = (t) => [from[0] + (to[0] - from[0]) * t, from[1] + (to[1] - from[1]) * t];
+        let turned = 0;
+        let previous;
+        for (let step = 0; step <= CUT_SAMPLES; step++) {
+            const normal = this.surfaceNormal(surface, at(step / CUT_SAMPLES));
+            const length = length3(normal);
+            if (!(length > 0)) {
+                continue;
+            }
+            const unit = [normal[0] / length, normal[1] / length, normal[2] / length];
+            if (previous) {
+                turned += Math.acos(Math.max(-1, Math.min(1, dot3(previous, unit))));
+            }
+            previous = unit;
+        }
+        const segments = Math.min(CUT_SAMPLES, Math.max(1, Math.ceil(turned / CUT_TURN)));
+        const uv = Array.from({ length: segments - 1 }, (_, step) => at((step + 1) / segments));
+        return { uv, points: uv.map(([u, v]) => surface.point(u, v)) };
+    }
+    oriented(mesh, surface, uv, sameSense) {
+        let agreement = 0;
+        for (let at = 0; at + 2 < mesh.triangles.length; at += TRIANGLE_CORNERS) {
+            const [a, b, c] = [mesh.triangles[at], mesh.triangles[at + 1], mesh.triangles[at + 2]];
+            const normal = cross3(subtract3(mesh.positions[b], mesh.positions[a]), subtract3(mesh.positions[c], mesh.positions[a]));
+            if (a < uv.length && length3(normal) > 0) {
+                agreement += Math.sign(dot3(normal, this.surfaceNormal(surface, uv[a])));
+            }
+        }
+        if ((agreement >= 0) === sameSense) {
+            return mesh;
+        }
+        const triangles = [...mesh.triangles];
+        for (let at = 0; at + 2 < triangles.length; at += TRIANGLE_CORNERS) {
+            [triangles[at + 1], triangles[at + 2]] = [triangles[at + 2], triangles[at + 1]];
+        }
+        return { positions: mesh.positions, triangles };
+    }
+    surfaceNormal(surface, [u, v]) {
+        const step = NORMAL_STEP * Math.max(1, Math.abs(u), Math.abs(v));
+        return cross3(subtract3(surface.point(u + step, v), surface.point(u - step, v)), subtract3(surface.point(u, v + step), surface.point(u, v - step)));
+    }
+    value(id, name) {
+        return this.model.valueOf(this.model.peek(id), name);
+    }
+}
+export function faceBounds(model, face) {
+    const known = model.referenceList(face);
+    if (known && model.typeOf(face) === "IfcFace") {
+        return known;
+    }
+    const bounds = model.valueOf(model.peek(face), "Bounds");
+    return (isList(bounds) ? bounds : []).filter(isReference).map((bound) => bound.ref);
+}

package/lib/geometry/colours.d.ts

@@ -0,0 +1,3 @@
+import type { ModelSnapshot } from "../model/snapshot";
+export declare function colourOf(model: ModelSnapshot, colours: Map<number, number[] | undefined>, product: number): number[] | undefined;
+export declare function itemColour(model: ModelSnapshot, colours: Map<number, number[] | undefined>, item: number): number[] | undefined;

package/lib/geometry/colours.js

@@ -0,0 +1,109 @@
+import { materialOf } from "../build/materials";
+import { isList, isReference } from "../step/values";
+const OPAQUE = 1;
+const MATERIAL_REPRESENTATION = "IfcMaterialDefinitionRepresentation";
+const SURFACE_STYLE = "IfcSurfaceStyle";
+const STYLE_ASSIGNMENT = "IfcPresentationStyleAssignment";
+const STYLED_ITEM = "IfcStyledItem";
+function materialsIn(model, definition) {
+    const type = model.entity(definition).type;
+    if (type === "IfcMaterial") {
+        return [definition];
+    }
+    if (type === "IfcMaterialLayerSetUsage") {
+        const set = model.attribute(definition, "ForLayerSet");
+        return isReference(set) ? materialsIn(model, set.ref) : [];
+    }
+    if (type === "IfcMaterialLayerSet") {
+        const layers = model.attribute(definition, "MaterialLayers");
+        return (isList(layers) ? layers : []).filter(isReference).flatMap((layer) => {
+            const material = model.attribute(layer.ref, "Material");
+            return isReference(material) ? [material.ref] : [];
+        });
+    }
+    return [];
+}
+function shadingColour(model, style) {
+    const styles = model.attribute(style, "Styles");
+    for (const element of isList(styles) ? styles : []) {
+        if (!isReference(element) || !model.schema.isSubtypeOf(model.entity(element.ref).type, "IfcSurfaceStyleShading")) {
+            continue;
+        }
+        const colour = model.attribute(element.ref, "SurfaceColour");
+        if (!isReference(colour)) {
+            continue;
+        }
+        const channels = ["Red", "Green", "Blue"].map((name) => model.attribute(colour.ref, name));
+        const transparency = model.attribute(element.ref, "Transparency");
+        if (channels.every((channel) => typeof channel === "number")) {
+            return [...channels, OPAQUE - (typeof transparency === "number" ? transparency : 0)];
+        }
+    }
+    return undefined;
+}
+function stylesColour(model, styles, insideAssignment = false) {
+    for (const style of (isList(styles) ? styles : []).filter(isReference)) {
+        const type = model.typeOf(style.ref);
+        const colour = type === SURFACE_STYLE
+            ? shadingColour(model, style.ref)
+            : type === STYLE_ASSIGNMENT && !insideAssignment ? stylesColour(model, model.attribute(style.ref, "Styles"), true) : undefined;
+        if (colour) {
+            return colour;
+        }
+    }
+    return undefined;
+}
+function representedColour(model, definition) {
+    const representations = model.attribute(definition, "Representations");
+    for (const representation of (isList(representations) ? representations : []).filter(isReference)) {
+        const items = model.attribute(representation.ref, "Items");
+        for (const item of (isList(items) ? items : []).filter(isReference)) {
+            const colour = stylesColour(model, model.attribute(item.ref, "Styles"));
+            if (colour) {
+                return colour;
+            }
+        }
+    }
+    return undefined;
+}
+function colourOfMaterial(model, material) {
+    for (const user of model.referencesTo(material)) {
+        const represented = model.typeOf(user) === MATERIAL_REPRESENTATION ? model.attribute(user, "RepresentedMaterial") : null;
+        const colour = isReference(represented) && represented.ref === material ? representedColour(model, user) : undefined;
+        if (colour) {
+            return colour;
+        }
+    }
+    return undefined;
+}
+export function colourOf(model, colours, product) {
+    const definition = materialOf(model, product);
+    if (definition === undefined) {
+        return undefined;
+    }
+    for (const material of materialsIn(model, definition)) {
+        if (!colours.has(material)) {
+            colours.set(material, colourOfMaterial(model, material));
+        }
+        const colour = colours.get(material);
+        if (colour) {
+            return colour;
+        }
+    }
+    return undefined;
+}
+export function itemColour(model, colours, item) {
+    if (colours.has(item)) {
+        return colours.get(item);
+    }
+    let colour;
+    for (const user of model.referencesTo(item)) {
+        const styled = model.typeOf(user) === STYLED_ITEM ? model.attribute(user, "Item") : null;
+        colour = isReference(styled) && styled.ref === item ? stylesColour(model, model.attribute(user, "Styles")) : undefined;
+        if (colour) {
+            break;
+        }
+    }
+    colours.set(item, colour);
+    return colour;
+}

package/lib/geometry/curves.d.ts

@@ -0,0 +1,32 @@
+import type { Base } from "@bitbybit-dev/base";
+import { type FrameAxes } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import type { ModelSnapshot } from "../model/snapshot";
+import type { BSplineCurve, ConicFrame } from "./geometry-types";
+export declare function arcSegments(sweep: number): number;
+export declare function sweepBetween(start: number, end: number, counterClockwise: boolean): number;
+export declare class CurveSampler {
+    private readonly model;
+    private readonly density;
+    private angleUnit;
+    constructor(model: ModelSnapshot, density?: number);
+    outline(curve: number, plane?: FrameAxes): Base.Point2[];
+    path(curve: number): Base.Point3[];
+    endTangents(curve: number, depth?: number): readonly [Base.Vector3 | undefined, Base.Vector3 | undefined];
+    parameterSpan(curve: number): number | undefined;
+    planeOf(curve: number): FrameAxes | undefined;
+    private get radiansPerUnit();
+    private sampled;
+    private polylinePoints;
+    private polylineIn;
+    private indexed;
+    private composite;
+    private trimOf;
+    private trimmed;
+    private linePoint;
+    private conicAngle;
+    conicFrame(conic: number): ConicFrame;
+    bspline(curve: number): BSplineCurve;
+    splinePoints(spline: BSplineCurve, from: number, to: number): Base.Point3[];
+    private conicTangent;
+    private conic;
+}