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

package/lib/geometry/recipe-builder.d.ts

@@ -0,0 +1,14 @@
+import type { Base } from "@bitbybit-dev/base";
+export declare class RecipeBuilder {
+    private readonly nodes;
+    private readonly roots;
+    private f64;
+    private i32;
+    private f64Length;
+    private i32Length;
+    numbers(values: readonly number[]): Base.RecipeRange;
+    indices(values: readonly number[]): Base.RecipeRange;
+    node(node: Base.RecipeNode): number;
+    root(root: Base.RecipeRoot): void;
+    build(millimetresPerUnit: number, tolerance: number, groups?: readonly Base.RecipeGroup[]): Base.Recipe;
+}

package/lib/geometry/recipe-builder.js

@@ -0,0 +1,48 @@
+const INITIAL_NUMBERS = 1024;
+function grown(buffer, needed, make) {
+    if (needed <= buffer.length) {
+        return buffer;
+    }
+    let size = buffer.length;
+    while (size < needed) {
+        size *= 2;
+    }
+    const next = make(size);
+    next.set(buffer);
+    return next;
+}
+export class RecipeBuilder {
+    constructor() {
+        this.nodes = [];
+        this.roots = [];
+        this.f64 = new Float64Array(INITIAL_NUMBERS);
+        this.i32 = new Int32Array(INITIAL_NUMBERS);
+        this.f64Length = 0;
+        this.i32Length = 0;
+    }
+    numbers(values) {
+        this.f64 = grown(this.f64, this.f64Length + values.length, (size) => new Float64Array(size));
+        this.f64.set(values, this.f64Length);
+        const range = [this.f64Length, values.length];
+        this.f64Length += values.length;
+        return range;
+    }
+    indices(values) {
+        this.i32 = grown(this.i32, this.i32Length + values.length, (size) => new Int32Array(size));
+        this.i32.set(values, this.i32Length);
+        const range = [this.i32Length, values.length];
+        this.i32Length += values.length;
+        return range;
+    }
+    node(node) {
+        this.nodes.push(node);
+        return this.nodes.length - 1;
+    }
+    root(root) {
+        this.roots.push(root);
+    }
+    build(millimetresPerUnit, tolerance, groups = []) {
+        return Object.assign({ format: "bitbybit.recipe", version: 1, millimetresPerUnit,
+            tolerance, buffers: { f64: this.f64.slice(0, this.f64Length), i32: this.i32.slice(0, this.i32Length) }, nodes: this.nodes, roots: this.roots }, (groups.length ? { groups: [...groups] } : {}));
+    }
+}

package/lib/geometry/references.d.ts

@@ -0,0 +1,4 @@
+import type { ModelSnapshot } from "../model/snapshot";
+import type { IfcValue } from "../step/step-types";
+export declare function referencesOf(value: IfcValue, what: string): number[];
+export declare function referencesIn(model: ModelSnapshot, id: number, attribute: string): readonly number[];

package/lib/geometry/references.js

@@ -0,0 +1,17 @@
+import { isList, isReference } from "../step/values";
+import { UnsupportedGeometryError } from "./errors";
+export function referencesOf(value, what) {
+    if (!isList(value)) {
+        throw new UnsupportedGeometryError(`${what} is not a list`);
+    }
+    return value.map((item) => {
+        if (!isReference(item)) {
+            throw new UnsupportedGeometryError(`${what} holds something other than a reference`);
+        }
+        return item.ref;
+    });
+}
+export function referencesIn(model, id, attribute) {
+    var _a;
+    return (_a = model.referenceList(id)) !== null && _a !== void 0 ? _a : referencesOf(model.valueOf(model.peek(id), attribute), `#${id} ${attribute}`);
+}

package/lib/geometry/regions.d.ts

@@ -0,0 +1,4 @@
+import type { CircleRegion, PolygonRegion, ProfileRegion } from "./geometry-types";
+import type { RecipeBuilder } from "./recipe-builder";
+export declare function profileNode(builder: RecipeBuilder, region: PolygonRegion | CircleRegion, radius?: number): number;
+export declare function regionSolid(builder: RecipeBuilder, region: ProfileRegion, make: (profile: number, part: PolygonRegion | CircleRegion) => number): number;

package/lib/geometry/regions.js

@@ -0,0 +1,26 @@
+function flat(points) {
+    return points.flatMap(([x, y]) => [x, y]);
+}
+export function profileNode(builder, region, radius = region.kind === "circle" ? region.radius : 0) {
+    if (region.kind === "circle") {
+        return builder.node({ op: "circle", center: region.center, radius });
+    }
+    return builder.node({ op: "polygon", points: builder.numbers(flat(region.outer)), holes: region.holes.map((hole) => builder.numbers(flat(hole))) });
+}
+export function regionSolid(builder, region, make) {
+    switch (region.kind) {
+        case "composite": {
+            const parts = region.parts.map((part) => regionSolid(builder, part, make));
+            return parts.length === 1 ? parts[0] : builder.node({ op: "compound", of: parts });
+        }
+        case "circle": {
+            const solid = make(profileNode(builder, region), region);
+            if (!(region.innerRadius > 0)) {
+                return solid;
+            }
+            return builder.node({ op: "difference", of: solid, tools: [make(profileNode(builder, region, region.innerRadius), region)] });
+        }
+        default:
+            return make(profileNode(builder, region), region);
+    }
+}

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

@@ -0,0 +1,17 @@
+export declare const FULL_TURN: number;
+export declare const CLOSED_CURVE_RATIO = 1e-9;
+export declare const NEWTON_STEPS = 30;
+export declare const NEWTON_TOLERANCE = 1e-12;
+export declare const SEED_STEPS = 16;
+export declare const NEWTON_DAMPING = 0.25;
+export declare const FIT_RATIO = 1e-7;
+export declare const SPLINE_STEP = 0.000001;
+export declare const NORMAL_STEP = 0.000001;
+export declare const MIN_LOOP_POINTS = 3;
+export declare const TRIANGLE_CORNERS = 3;
+export declare const PROFILE_DENSITY = 8;
+export declare const FIT_PROBES = 8;
+export declare const FIT_TOLERANCE = 0.000001;
+export declare const CUT_SAMPLES = 64;
+export declare const CUT_TURN: number;
+export declare const POLE_RATIO = 1e-9;

package/lib/geometry/surfaces.constants.js

@@ -0,0 +1,17 @@
+export const FULL_TURN = 2 * Math.PI;
+export const CLOSED_CURVE_RATIO = 1e-9;
+export const NEWTON_STEPS = 30;
+export const NEWTON_TOLERANCE = 1e-12;
+export const SEED_STEPS = 16;
+export const NEWTON_DAMPING = 0.25;
+export const FIT_RATIO = 1e-7;
+export const SPLINE_STEP = 1e-6;
+export const NORMAL_STEP = 1e-6;
+export const MIN_LOOP_POINTS = 3;
+export const TRIANGLE_CORNERS = 3;
+export const PROFILE_DENSITY = 8;
+export const FIT_PROBES = 8;
+export const FIT_TOLERANCE = 1e-6;
+export const CUT_SAMPLES = 64;
+export const CUT_TURN = (2 * Math.PI) / 32;
+export const POLE_RATIO = 1e-9;

package/lib/geometry/surfaces.d.ts

@@ -0,0 +1,6 @@
+import { type FrameAxes } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import type { ModelSnapshot } from "../model/snapshot";
+import { CurveSampler } from "./curves";
+import type { ParametricSurface } from "./geometry-types";
+export declare function plane(frame: FrameAxes): ParametricSurface;
+export declare function parametricSurface(model: ModelSnapshot, curves: CurveSampler, surface: number, divided?: boolean): ParametricSurface | undefined;

package/lib/geometry/surfaces.js

@@ -0,0 +1,306 @@
+import { WORLD_AXES, pointToLocal, pointToWorld, vectorToWorld } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { expandedKnots, knotDomain, nurbsSurfacePoint } from "@bitbybit-dev/base/lib/api/services/helpers/nurbs";
+import { add3, cross3, dot3, length3, scale3, subtract3 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import { axisPlacementFrame, directionOf, pointOf } from "../build/placement";
+import { isList, isReference } from "../step/values";
+import { CurveSampler } from "./curves";
+import { UnsupportedGeometryError } from "./errors";
+import { CLOSED_CURVE_RATIO, FIT_RATIO, POLE_RATIO, PROFILE_DENSITY, FULL_TURN, NEWTON_DAMPING, NEWTON_STEPS, NEWTON_TOLERANCE, SEED_STEPS, SPLINE_STEP } from "./surfaces.constants";
+const Z_AXIS = [0, 0, 1];
+const NO_PERIODS = [undefined, undefined];
+const noPole = () => undefined;
+function frameOf(model, value) {
+    return isReference(value) ? axisPlacementFrame(model, value.ref) : WORLD_AXES;
+}
+function positive(model, surface, name) {
+    const value = model.attribute(surface, name);
+    if (typeof value !== "number" || !Number.isFinite(value) || !(value > 0)) {
+        throw new UnsupportedGeometryError(`#${surface} has no ${name} above zero`);
+    }
+    return value;
+}
+function polyline(points) {
+    const lengths = [0];
+    for (let at = 1; at < points.length; at++) {
+        lengths.push(lengths[at - 1] + length3(subtract3(points[at], points[at - 1])));
+    }
+    const total = lengths[lengths.length - 1];
+    return { points, lengths, closed: total > 0 && length3(subtract3(points[0], points[points.length - 1])) <= CLOSED_CURVE_RATIO * total };
+}
+function pointAlong(line, at) {
+    const { points, lengths } = line;
+    const total = lengths[lengths.length - 1];
+    const s = line.closed ? ((at % total) + total) % total : Math.min(Math.max(at, 0), total);
+    let segment = 1;
+    while (segment < lengths.length - 1 && lengths[segment] < s) {
+        segment++;
+    }
+    const span = lengths[segment] - lengths[segment - 1];
+    const t = span > 0 ? (s - lengths[segment - 1]) / span : 0;
+    return add3(points[segment - 1], scale3(subtract3(points[segment], points[segment - 1]), t));
+}
+function lengthNearest(line, point, flatten) {
+    let best = 0;
+    let bestDistance = Infinity;
+    const target = flatten(point);
+    for (let at = 1; at < line.points.length; at++) {
+        const a = flatten(line.points[at - 1]);
+        const along = subtract3(flatten(line.points[at]), a);
+        const squared = dot3(along, along);
+        const t = squared > 0 ? Math.min(1, Math.max(0, dot3(subtract3(target, a), along) / squared)) : 0;
+        const d = length3(subtract3(target, add3(a, scale3(along, t))));
+        if (d < bestDistance) {
+            bestDistance = d;
+            best = line.lengths[at - 1] + t * (line.lengths[at] - line.lengths[at - 1]);
+        }
+    }
+    return best;
+}
+function periodOf(line) {
+    return line.closed ? line.lengths[line.lengths.length - 1] : undefined;
+}
+export function plane(frame) {
+    return {
+        periods: NO_PERIODS,
+        point: (u, v) => pointToWorld(frame, [u, v, 0]),
+        parameters: (point) => {
+            const [u, v] = pointToLocal(frame, point);
+            return [u, v];
+        },
+        pole: noPole,
+    };
+}
+function cylinder(frame, radius) {
+    return {
+        periods: [FULL_TURN, undefined],
+        point: (u, v) => pointToWorld(frame, [radius * Math.cos(u), radius * Math.sin(u), v]),
+        parameters: (point) => {
+            const [x, y, z] = pointToLocal(frame, point);
+            return [Math.atan2(y, x), z];
+        },
+        pole: noPole,
+    };
+}
+function sphere(frame, radius) {
+    return {
+        periods: [FULL_TURN, undefined],
+        point: (u, v) => pointToWorld(frame, [radius * Math.cos(v) * Math.cos(u), radius * Math.cos(v) * Math.sin(u), radius * Math.sin(v)]),
+        parameters: (point) => {
+            const [x, y, z] = pointToLocal(frame, point);
+            const across = Math.hypot(x, y);
+            return [across <= POLE_RATIO * radius ? Number.NaN : Math.atan2(y, x), Math.atan2(z, across)];
+        },
+        pole: (axis, side) => (axis === 1 ? (side * Math.PI) / 2 : undefined),
+    };
+}
+function torus(frame, major, minor) {
+    return {
+        periods: [FULL_TURN, FULL_TURN],
+        point: (u, v) => {
+            const r = major + minor * Math.cos(v);
+            return pointToWorld(frame, [r * Math.cos(u), r * Math.sin(u), minor * Math.sin(v)]);
+        },
+        parameters: (point) => {
+            const [x, y, z] = pointToLocal(frame, point);
+            return [Math.atan2(y, x), Math.atan2(z, Math.hypot(x, y) - major)];
+        },
+        pole: noPole,
+    };
+}
+function revolution(profile, origin, axis) {
+    const offsetOf = (point) => subtract3(point, origin);
+    const radialOf = (point) => {
+        const offset = offsetOf(point);
+        return subtract3(offset, scale3(axis, dot3(offset, axis)));
+    };
+    const reference = profile.points.map(radialOf).find((radial) => length3(radial) > 0);
+    if (reference === undefined) {
+        throw new UnsupportedGeometryError("A surface of revolution has its whole profile on its axis");
+    }
+    const x = scale3(reference, 1 / length3(reference));
+    const y = cross3(axis, x);
+    const halfPlane = (point) => [length3(radialOf(point)), dot3(offsetOf(point), axis), 0];
+    const ends = [profile.points[0], profile.points[profile.points.length - 1]].map((point) => length3(radialOf(point)) <= CLOSED_CURVE_RATIO * profile.lengths[profile.lengths.length - 1]);
+    return {
+        periods: [periodOf(profile), FULL_TURN],
+        point: (u, v) => {
+            const [radius, height] = halfPlane(pointAlong(profile, u));
+            return add3(origin, add3(scale3(axis, height), add3(scale3(x, radius * Math.cos(v)), scale3(y, radius * Math.sin(v)))));
+        },
+        parameters: (point) => {
+            const radial = radialOf(point);
+            const onAxis = length3(radial) <= POLE_RATIO * profile.lengths[profile.lengths.length - 1];
+            return [lengthNearest(profile, point, halfPlane), onAxis ? Number.NaN : Math.atan2(dot3(radial, y), dot3(radial, x))];
+        },
+        pole: (along, side) => {
+            if (along !== 0) {
+                return undefined;
+            }
+            const end = side > 0 ? 1 : 0;
+            return ends[end] ? (side > 0 ? profile.lengths[profile.lengths.length - 1] : 0) : undefined;
+        },
+    };
+}
+function extrusion(curve, direction) {
+    const flatten = (point) => subtract3(point, scale3(direction, dot3(point, direction)));
+    return {
+        periods: [periodOf(curve), undefined],
+        point: (u, v) => add3(pointAlong(curve, u), scale3(direction, v)),
+        parameters: (point) => {
+            const u = lengthNearest(curve, point, flatten);
+            return [u, dot3(subtract3(point, pointAlong(curve, u)), direction)];
+        },
+        pole: noPole,
+    };
+}
+function splineSurface(model, surface, divided) {
+    const degrees = [model.attribute(surface, "UDegree"), model.attribute(surface, "VDegree")];
+    const controls = model.attribute(surface, "ControlPointsList");
+    const numbers = (name) => {
+        const value = model.attribute(surface, name);
+        if (!isList(value) || !value.every((item) => typeof item === "number" && Number.isFinite(item))) {
+            throw new UnsupportedGeometryError(`#${surface} has no ${name}`);
+        }
+        return value;
+    };
+    if (typeof degrees[0] !== "number" || typeof degrees[1] !== "number" || !isList(controls)) {
+        throw new UnsupportedGeometryError(`#${surface} is not a B-spline surface it can read`);
+    }
+    const [uDegree, vDegree] = [degrees[0], degrees[1]];
+    const net = controls.map((row) => (isList(row) ? row : []).map((point) => pointOf(model, point)));
+    const uKnots = expandedKnots(numbers("UKnots"), numbers("UMultiplicities"));
+    const vKnots = expandedKnots(numbers("VKnots"), numbers("VMultiplicities"));
+    if (uKnots.length !== net.length + uDegree + 1 || net.some((row) => vKnots.length !== row.length + vDegree + 1)) {
+        throw new UnsupportedGeometryError(`#${surface} has knots that do not match its control points`);
+    }
+    const weightsValue = model.entity(surface).type === "IfcRationalBSplineSurfaceWithKnots" ? model.attribute(surface, "WeightsData") : null;
+    const weights = isList(weightsValue) ? weightsValue.map((row) => (isList(row) ? row.map((item) => (typeof item === "number" ? item : 1)) : [])) : undefined;
+    if (divided && weights) {
+        net.forEach((row, i) => row.forEach((point, j) => {
+            var _a, _b;
+            row[j] = scale3(point, 1 / ((_b = (_a = weights[i]) === null || _a === void 0 ? void 0 : _a[j]) !== null && _b !== void 0 ? _b : 1));
+        }));
+    }
+    const [u0, u1] = knotDomain(uDegree, uKnots);
+    const [v0, v1] = knotDomain(vDegree, vKnots);
+    const closedU = model.attribute(surface, "UClosed") === true;
+    const closedV = model.attribute(surface, "VClosed") === true;
+    const into = (value, low, high, closed) => (closed ? low + ((((value - low) % (high - low)) + (high - low)) % (high - low)) : Math.min(high, Math.max(low, value)));
+    const clampU = (u) => into(u, u0, u1, closedU);
+    const clampV = (v) => into(v, v0, v1, closedV);
+    const point = (u, v) => nurbsSurfacePoint([uDegree, vDegree], net, weights, [uKnots, vKnots], clampU(u), clampV(v));
+    const corners = net.flat();
+    const size = Math.hypot(...[0, 1, 2].map((axis) => Math.max(...corners.map((corner) => corner[axis])) - Math.min(...corners.map((corner) => corner[axis]))));
+    const accepted = size * FIT_RATIO;
+    const seed = (target) => {
+        let best = [u0, v0];
+        let bestDistance = Infinity;
+        for (let i = 0; i <= SEED_STEPS; i++) {
+            for (let j = 0; j <= SEED_STEPS; j++) {
+                const uv = [u0 + ((u1 - u0) * i) / SEED_STEPS, v0 + ((v1 - v0) * j) / SEED_STEPS];
+                const d = length3(subtract3(point(uv[0], uv[1]), target));
+                if (d < bestDistance) {
+                    bestDistance = d;
+                    best = uv;
+                }
+            }
+        }
+        return best;
+    };
+    return {
+        periods: [closedU ? u1 - u0 : undefined, closedV ? v1 - v0 : undefined],
+        point,
+        parameters: (target, near) => {
+            const solved = (from) => {
+                let [u, v] = [closedU ? from[0] : clampU(from[0]), closedV ? from[1] : clampV(from[1])];
+                const [hu, hv] = [(u1 - u0) * SPLINE_STEP, (v1 - v0) * SPLINE_STEP];
+                for (let step = 0; step < NEWTON_STEPS; step++) {
+                    const here = point(u, v);
+                    const [uLow, uHigh] = closedU ? [u - hu, u + hu] : [Math.max(u0, u - hu), Math.min(u1, u + hu)];
+                    const [vLow, vHigh] = closedV ? [v - hv, v + hv] : [Math.max(v0, v - hv), Math.min(v1, v + hv)];
+                    const su = scale3(subtract3(point(uHigh, v), point(uLow, v)), 1 / (uHigh - uLow));
+                    const sv = scale3(subtract3(point(u, vHigh), point(u, vLow)), 1 / (vHigh - vLow));
+                    const miss = subtract3(target, here);
+                    const [a, b, c] = [dot3(su, su), dot3(su, sv), dot3(sv, sv)];
+                    const determinant = a * c - b * b;
+                    if (!(Math.abs(determinant) > 0)) {
+                        break;
+                    }
+                    const limitU = (u1 - u0) * NEWTON_DAMPING;
+                    const limitV = (v1 - v0) * NEWTON_DAMPING;
+                    const du = Math.max(-limitU, Math.min(limitU, (c * dot3(su, miss) - b * dot3(sv, miss)) / determinant));
+                    const dv = Math.max(-limitV, Math.min(limitV, (a * dot3(sv, miss) - b * dot3(su, miss)) / determinant));
+                    [u, v] = [closedU ? u + du : clampU(u + du), closedV ? v + dv : clampV(v + dv)];
+                    if (Math.abs(du) <= NEWTON_TOLERANCE * (u1 - u0) && Math.abs(dv) <= NEWTON_TOLERANCE * (v1 - v0)) {
+                        break;
+                    }
+                }
+                return { uv: [u, v], miss: length3(subtract3(point(u, v), target)) };
+            };
+            let best = near ? solved(near) : undefined;
+            if (!best || best.miss > accepted) {
+                const seeded = solved(seed(target));
+                best = !best || seeded.miss < best.miss ? seeded : best;
+            }
+            return best.uv;
+        },
+        pole: (axis, side) => {
+            const row = axis === 0 ? net[side > 0 ? net.length - 1 : 0] : net.map((column) => column[side > 0 ? column.length - 1 : 0]);
+            const collapsed = row.every((point) => length3(subtract3(point, row[0])) <= CLOSED_CURVE_RATIO * Math.max(1, length3(row[0])));
+            if (!collapsed) {
+                return undefined;
+            }
+            if (axis === 0) {
+                return side > 0 ? u1 : u0;
+            }
+            return side > 0 ? v1 : v0;
+        },
+    };
+}
+function profileCurve(model, surface) {
+    const profile = model.attribute(surface, "SweptCurve");
+    const curve = isReference(profile) ? model.attribute(profile.ref, "Curve") : null;
+    if (!isReference(curve)) {
+        throw new UnsupportedGeometryError(`#${surface} sweeps no curve`);
+    }
+    const frame = frameOf(model, model.attribute(surface, "Position"));
+    return polyline(new CurveSampler(model, PROFILE_DENSITY).path(curve.ref).map((point) => pointToWorld(frame, point)));
+}
+export function parametricSurface(model, curves, surface, divided = false) {
+    const type = model.entity(surface).type;
+    switch (type) {
+        case "IfcPlane":
+            return plane(frameOf(model, model.attribute(surface, "Position")));
+        case "IfcCylindricalSurface":
+            return cylinder(frameOf(model, model.attribute(surface, "Position")), positive(model, surface, "Radius"));
+        case "IfcSphericalSurface":
+            return sphere(frameOf(model, model.attribute(surface, "Position")), positive(model, surface, "Radius"));
+        case "IfcToroidalSurface":
+            return torus(frameOf(model, model.attribute(surface, "Position")), positive(model, surface, "MajorRadius"), positive(model, surface, "MinorRadius"));
+        case "IfcSurfaceOfRevolution": {
+            const placement = model.attribute(surface, "AxisPosition");
+            if (!isReference(placement)) {
+                throw new UnsupportedGeometryError(`#${surface} has no axis`);
+            }
+            const frame = frameOf(model, model.attribute(surface, "Position"));
+            const axis = vectorToWorld(frame, directionOf(model, model.attribute(placement.ref, "Axis"), Z_AXIS));
+            return revolution(profileCurve(model, surface), pointToWorld(frame, pointOf(model, model.attribute(placement.ref, "Location"))), scale3(axis, 1 / length3(axis)));
+        }
+        case "IfcSurfaceOfLinearExtrusion": {
+            const frame = frameOf(model, model.attribute(surface, "Position"));
+            const direction = vectorToWorld(frame, directionOf(model, model.attribute(surface, "ExtrudedDirection"), Z_AXIS));
+            return extrusion(profileCurve(model, surface), scale3(direction, 1 / length3(direction)));
+        }
+        case "IfcBSplineSurfaceWithKnots":
+        case "IfcRationalBSplineSurfaceWithKnots":
+            return splineSurface(model, surface, divided);
+        case "IfcRectangularTrimmedSurface":
+        case "IfcCurveBoundedPlane":
+        case "IfcCurveBoundedSurface": {
+            const basis = model.attribute(surface, "BasisSurface");
+            return isReference(basis) ? parametricSurface(model, curves, basis.ref, divided) : undefined;
+        }
+        default:
+            return undefined;
+    }
+}

package/lib/geometry/swept-solids.constants.d.ts

@@ -0,0 +1,7 @@
+import type { Base } from "@bitbybit-dev/base";
+export declare const FULL_TURN: number;
+export declare const TURN_SLACK = 1e-9;
+export declare const PARAMETER_RATIO = 0.000001;
+export declare const IDENTITY_MATRIX: Base.TransformMatrix;
+export declare const Y_TO_Z: Base.TransformMatrix;
+export declare const PYRAMID_TRIANGLES: readonly number[];

package/lib/geometry/swept-solids.constants.js

@@ -0,0 +1,6 @@
+export const FULL_TURN = 2 * Math.PI;
+export const TURN_SLACK = 1e-9;
+export const PARAMETER_RATIO = 1e-6;
+export const IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+export const Y_TO_Z = [1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1];
+export const PYRAMID_TRIANGLES = [0, 2, 1, 0, 3, 2, 0, 1, 4, 1, 2, 4, 2, 3, 4, 3, 0, 4];

package/lib/geometry/swept-solids.d.ts

@@ -0,0 +1,25 @@
+import type { ModelSnapshot } from "../model/snapshot";
+import { type CurveSampler } from "./curves";
+import type { RecipeBuilder } from "./recipe-builder";
+export declare class SweptSolids {
+    private readonly model;
+    private readonly builder;
+    private readonly curves;
+    constructor(model: ModelSnapshot, builder: RecipeBuilder, curves: CurveSampler);
+    revolved(item: number): number;
+    tapered(item: number): number;
+    sweptDisk(item: number, polygonal: boolean): number;
+    areaSweep(item: number, fixed: boolean): number;
+    primitive(item: number, type: string): number;
+    private pyramid;
+    private taperBetween;
+    private fixedAxes;
+    private surfaceAxes;
+    private surfaceNormal;
+    private endsOf;
+    private sweptPath;
+    private flat;
+    private region;
+    private number;
+    private placed;
+}