fluidcad 0.0.37 → 0.0.39

package/lib/dist/oc/loft/constrained-loft.d.ts

@@ -0,0 +1,32 @@
+import { Wire } from "../../common/wire.js";
+import { Solid } from "../../common/solid.js";
+import { LoftEndCondition } from "./skinning.js";
+export type { LoftConditionKind, LoftEndCondition } from "./skinning.js";
+/**
+ * Loft with start/end conditions. OCC's `BRepOffsetAPI_ThruSections` cannot
+ * constrain end tangency, so this path skins the surface itself: profiles
+ * become compatible B-spline sections (`SectionCompatibility`), matching pole
+ * columns are interpolated along the loft with the end derivatives pinned,
+ * and the resulting surface is capped and sewn into a solid (`Skinning`).
+ *
+ * Conditions:
+ * - `normal`: the surface leaves the profile along the profile's plane
+ *   normal — a perpendicular takeoff.
+ * - `tangent`: the surface leaves the profile inside the profile's plane,
+ *   directed outward — profiles become tangency planes (e.g. a barrel from
+ *   two stacked circles). Negative magnitudes direct it inward.
+ */
+export declare class ConstrainedLoft {
+    static build(wires: Wire[], startCondition: LoftEndCondition | undefined, endCondition: LoftEndCondition | undefined): Solid[];
+    /**
+     * Thin-walled conditioned loft, assembled directly: outer wall, inner
+     * wall, and two planar ring caps sewn into one solid. Cutting the inner
+     * loft out of the outer with a boolean instead takes OCC seconds — two
+     * nearly-parallel B-spline shells are the pave-filler's worst case — and
+     * the walls are already exact offsets, so no boolean is needed.
+     */
+    static buildThin(outerWires: Wire[], innerWires: Wire[], startCondition: LoftEndCondition | undefined, endCondition: LoftEndCondition | undefined): Solid[];
+    private static skinWires;
+    /** Planar ring between the outer and inner wall boundaries at one end. */
+    private static ringCap;
+}

package/lib/dist/oc/loft/constrained-loft.js

@@ -0,0 +1,61 @@
+import { Wire } from "../../common/wire.js";
+import { FaceOps } from "../face-ops.js";
+import { SectionCompatibility } from "./section-compatibility.js";
+import { Skinning } from "./skinning.js";
+/**
+ * Loft with start/end conditions. OCC's `BRepOffsetAPI_ThruSections` cannot
+ * constrain end tangency, so this path skins the surface itself: profiles
+ * become compatible B-spline sections (`SectionCompatibility`), matching pole
+ * columns are interpolated along the loft with the end derivatives pinned,
+ * and the resulting surface is capped and sewn into a solid (`Skinning`).
+ *
+ * Conditions:
+ * - `normal`: the surface leaves the profile along the profile's plane
+ *   normal — a perpendicular takeoff.
+ * - `tangent`: the surface leaves the profile inside the profile's plane,
+ *   directed outward — profiles become tangency planes (e.g. a barrel from
+ *   two stacked circles). Negative magnitudes direct it inward.
+ */
+export class ConstrainedLoft {
+    static build(wires, startCondition, endCondition) {
+        const compatible = ConstrainedLoft.skinWires(wires);
+        const skinned = Skinning.skinSections(compatible, startCondition, endCondition);
+        return [Skinning.buildLoftSolid(compatible, skinned.grid, skinned.vBasis)];
+    }
+    /**
+     * Thin-walled conditioned loft, assembled directly: outer wall, inner
+     * wall, and two planar ring caps sewn into one solid. Cutting the inner
+     * loft out of the outer with a boolean instead takes OCC seconds — two
+     * nearly-parallel B-spline shells are the pave-filler's worst case — and
+     * the walls are already exact offsets, so no boolean is needed.
+     */
+    static buildThin(outerWires, innerWires, startCondition, endCondition) {
+        const outer = ConstrainedLoft.skinWires(outerWires);
+        const inner = ConstrainedLoft.skinWires(innerWires);
+        const outerSkin = Skinning.skinSections(outer, startCondition, endCondition);
+        const innerSkin = Skinning.skinSections(inner, startCondition, endCondition);
+        const faces = [
+            ...Skinning.sideFaces(outer, outerSkin.grid, outerSkin.vBasis),
+            ...Skinning.sideFaces(inner, innerSkin.grid, innerSkin.vBasis),
+            ConstrainedLoft.ringCap(outer, outerSkin, inner, innerSkin, false),
+            ConstrainedLoft.ringCap(outer, outerSkin, inner, innerSkin, true),
+        ];
+        return [Skinning.sewSolid(faces)];
+    }
+    static skinWires(wires) {
+        for (const wire of wires) {
+            if (!wire.isClosed()) {
+                throw new Error("Loft with start/end conditions requires closed profiles.");
+            }
+        }
+        return SectionCompatibility.build(wires.map(w => w.getShape()));
+    }
+    /** Planar ring between the outer and inner wall boundaries at one end. */
+    static ringCap(outer, outerSkin, inner, innerSkin, isEnd) {
+        const column = (grid) => grid.map(row => row[isEnd ? row.length - 1 : 0]);
+        const outerWire = new Wire(Skinning.capWire(outer, column(outerSkin.grid)));
+        const innerWire = new Wire(Skinning.capWire(inner, column(innerSkin.grid)));
+        const ring = FaceOps.makeFaceWithHoles(outerWire, [innerWire]);
+        return FaceOps.fixFaceOrientation(ring).getShape();
+    }
+}

package/lib/dist/oc/loft/curve-data.d.ts

@@ -0,0 +1,18 @@
+import type { Geom_BSplineCurve } from "ocjs-fluidcad";
+import type { BSplineCurveData } from "../../math/bspline-interpolation.js";
+/**
+ * Plain-JS mirror of a `Geom_BSplineCurve`. `weights` is null for polynomial
+ * curves; when present it holds one weight per pole (rational curve).
+ */
+export interface RationalBSplineData extends BSplineCurveData {
+    weights: number[] | null;
+}
+/**
+ * Moves B-spline curves between OCC handles and plain data, so the knot/pole
+ * bookkeeping of the loft pipeline (concatenation, unification, skinning) can
+ * run on ordinary arrays instead of chains of native calls.
+ */
+export declare class CurveData {
+    static read(curve: Geom_BSplineCurve): RationalBSplineData;
+    static build(data: RationalBSplineData): Geom_BSplineCurve;
+}

package/lib/dist/oc/loft/curve-data.js

@@ -0,0 +1,54 @@
+import { getOC } from "../init.js";
+import { NCollections } from "../ncollection.js";
+/**
+ * Moves B-spline curves between OCC handles and plain data, so the knot/pole
+ * bookkeeping of the loft pipeline (concatenation, unification, skinning) can
+ * run on ordinary arrays instead of chains of native calls.
+ */
+export class CurveData {
+    static read(curve) {
+        const poles = [];
+        for (let i = 1; i <= curve.NbPoles(); i++) {
+            const pole = curve.Pole(i);
+            poles.push([pole.X(), pole.Y(), pole.Z()]);
+            pole.delete();
+        }
+        const knots = [];
+        const multiplicities = [];
+        for (let i = 1; i <= curve.NbKnots(); i++) {
+            knots.push(curve.Knot(i));
+            multiplicities.push(curve.Multiplicity(i));
+        }
+        let weights = null;
+        if (curve.IsRational()) {
+            weights = [];
+            for (let i = 1; i <= curve.NbPoles(); i++) {
+                weights.push(curve.Weight(i));
+            }
+        }
+        return { poles, weights, knots, multiplicities, degree: curve.Degree() };
+    }
+    static build(data) {
+        const oc = getOC();
+        const [poles, disposePoles] = NCollections.toArray1Pnt(data.poles);
+        const [knots, disposeKnots] = NCollections.toArray1Double(data.knots);
+        const [multiplicities, disposeMultiplicities] = NCollections.toArray1Int(data.multiplicities);
+        try {
+            if (data.weights) {
+                const [weights, disposeWeights] = NCollections.toArray1Double(data.weights);
+                try {
+                    return new oc.Geom_BSplineCurve(poles, weights, knots, multiplicities, data.degree, false, false);
+                }
+                finally {
+                    disposeWeights();
+                }
+            }
+            return new oc.Geom_BSplineCurve(poles, knots, multiplicities, data.degree, false);
+        }
+        finally {
+            disposePoles();
+            disposeKnots();
+            disposeMultiplicities();
+        }
+    }
+}

package/lib/dist/oc/loft/curve-eval.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Plain-data B-spline evaluation for the loft pipeline. Sections and guides
+ * live as pole/knot arrays between pipeline stages (see `CurveData`), and
+ * evaluating them directly in JS avoids rebuilding native curves just to
+ * sample a few points.
+ */
+/** Expands distinct knots + multiplicities into the flat knot sequence. */
+export declare function flattenKnots(knots: ReadonlyArray<number>, multiplicities: ReadonlyArray<number>): number[];
+export interface EvaluableBSpline {
+    degree: number;
+    knots: number[];
+    multiplicities: number[];
+    poles: number[][];
+    weights?: number[] | null;
+}
+/** Point on a (possibly rational) B-spline at parameter t. */
+export declare function evaluateBSplinePoint(curve: EvaluableBSpline, t: number): number[];
+/**
+ * Parameter in [low, high] whose evaluated point lies closest to `target`:
+ * dense sampling to bracket the minimum, then golden-section refinement.
+ * Works for any point-valued curve evaluation (plain-data or native).
+ */
+export declare function closestCurveParameter(evaluate: (t: number) => number[], target: ReadonlyArray<number>, low?: number, high?: number, samples?: number): number;

package/lib/dist/oc/loft/curve-eval.js

@@ -0,0 +1,84 @@
+import { findSpan, basisFunctions } from "../../math/bspline-interpolation.js";
+/**
+ * Plain-data B-spline evaluation for the loft pipeline. Sections and guides
+ * live as pole/knot arrays between pipeline stages (see `CurveData`), and
+ * evaluating them directly in JS avoids rebuilding native curves just to
+ * sample a few points.
+ */
+/** Expands distinct knots + multiplicities into the flat knot sequence. */
+export function flattenKnots(knots, multiplicities) {
+    const flat = [];
+    for (let i = 0; i < knots.length; i++) {
+        for (let m = 0; m < multiplicities[i]; m++) {
+            flat.push(knots[i]);
+        }
+    }
+    return flat;
+}
+/** Point on a (possibly rational) B-spline at parameter t. */
+export function evaluateBSplinePoint(curve, t) {
+    const flat = flattenKnots(curve.knots, curve.multiplicities);
+    const span = findSpan(curve.poles.length, curve.degree, t, flat);
+    const values = basisFunctions(span, t, curve.degree, flat);
+    const dimension = curve.poles[0].length;
+    const numerator = new Array(dimension).fill(0);
+    let denominator = 0;
+    for (let j = 0; j <= curve.degree; j++) {
+        const poleIndex = span - curve.degree + j;
+        const weight = curve.weights ? curve.weights[poleIndex] : 1;
+        const blend = values[j] * weight;
+        denominator += blend;
+        for (let d = 0; d < dimension; d++) {
+            numerator[d] += blend * curve.poles[poleIndex][d];
+        }
+    }
+    return numerator.map(v => v / denominator);
+}
+/**
+ * Parameter in [low, high] whose evaluated point lies closest to `target`:
+ * dense sampling to bracket the minimum, then golden-section refinement.
+ * Works for any point-valued curve evaluation (plain-data or native).
+ */
+export function closestCurveParameter(evaluate, target, low = 0, high = 1, samples = 512) {
+    const distanceAt = (t) => {
+        const p = evaluate(t);
+        let sum = 0;
+        for (let d = 0; d < target.length; d++) {
+            sum += (p[d] - target[d]) * (p[d] - target[d]);
+        }
+        return sum;
+    };
+    let bestIndex = 0;
+    let bestDistance = Infinity;
+    for (let i = 0; i <= samples; i++) {
+        const d = distanceAt(low + ((high - low) * i) / samples);
+        if (d < bestDistance) {
+            bestDistance = d;
+            bestIndex = i;
+        }
+    }
+    let a = low + ((high - low) * Math.max(0, bestIndex - 1)) / samples;
+    let b = low + ((high - low) * Math.min(samples, bestIndex + 1)) / samples;
+    const phi = (Math.sqrt(5) - 1) / 2;
+    let mid1 = b - phi * (b - a);
+    let mid2 = a + phi * (b - a);
+    let d1 = distanceAt(mid1);
+    let d2 = distanceAt(mid2);
+    for (let iteration = 0; iteration < 40; iteration++) {
+        if (d1 <= d2) {
+            b = mid2;
+            mid2 = mid1;
+            d2 = d1;
+            mid1 = b - phi * (b - a);
+            d1 = distanceAt(mid1);
+        }
+        else {
+            a = mid1;
+            mid1 = mid2;
+            d1 = d2;
+            mid2 = a + phi * (b - a);
+            d2 = distanceAt(mid2);
+        }
+    }
+    return (a + b) / 2;
+}

package/lib/dist/oc/loft/guided-loft.d.ts

@@ -0,0 +1,89 @@
+import { Wire } from "../../common/wire.js";
+import { Solid } from "../../common/solid.js";
+import { LoftEndCondition } from "./skinning.js";
+/**
+ * Loft steered by one or two side rails. OCC's pipe-shell machinery distorts
+ * pinned sections along curved rails (they tilt with the sweep frame, and
+ * the auxiliary-spine contact mode rotates and smears non-circular sections),
+ * so this path builds the surface itself:
+ *
+ * 1. skin the profiles alone (`Skinning`) — the unguided base surface,
+ * 2. slice the base into virtual sections between the profiles,
+ * 3. move each virtual section rigidly so its rail-contact point rides the
+ *    guide (one rail), or map its two contact points onto both rails with a
+ *    rotation + axial stretch (two rails) — profiles themselves stay exact,
+ * 4. re-skin through the full stack and cap/sew into a solid.
+ *
+ * Guides must pass through every profile: sections are pinned where they
+ * were sketched, so a rail that misses a profile is unsatisfiable.
+ *
+ * Start/end conditions compose with guides: the condition's takeoff field
+ * fades smoothly to the natural (unconstrained) takeoff around each guide's
+ * contact point — the rails own their sides of the surface, the condition
+ * shapes the rest. The faded fields drive both the base skin (so the
+ * virtual sections carry the conditioned shape) and the final re-skin (so
+ * the takeoff is pinned exactly where the condition is in force).
+ */
+export declare class GuidedLoft {
+    /** Virtual sections inserted between consecutive profiles. */
+    private static readonly SECTIONS_PER_SPAN;
+    /** How far (mm) a guide may sit from a profile boundary and still count as touching. */
+    private static readonly CONTACT_TOLERANCE;
+    /** Fallback condition-falloff radius (in section parameter) for a single guide. */
+    private static readonly SINGLE_GUIDE_FALLOFF;
+    static build(profileWires: Wire[], guideWires: Wire[], startCondition?: LoftEndCondition, endCondition?: LoftEndCondition): Solid[];
+    /**
+     * The unguided base skin, with any end conditions already faded around the
+     * guide contacts (blended towards the natural chord takeoff, per column).
+     */
+    private static skinBase;
+    /**
+     * The condition's takeoff field for one end of a section stack, faded to
+     * the stack's own natural takeoff (the chord to the neighbouring section)
+     * around each guide contact. Null when no condition applies to that end.
+     */
+    private static stackField;
+    /**
+     * Per-column condition weight: 0 at each guide contact, smoothstepping to
+     * 1 beyond the falloff radius (half the closest contact separation for two
+     * guides). Columns are located by their Greville parameters.
+     */
+    private static falloffWeights;
+    /**
+     * Locates the guide's contact with every profile: the guide parameter
+     * where it crosses the profile plane, and the profile parameter of the
+     * nearest boundary point. Off-boundary rails are reported with their gap —
+     * sections stay where they were sketched, so such rails are unsatisfiable.
+     */
+    private static anchorGuide;
+    /**
+     * Guide parameter where the guide crosses the plane (centroid, normal):
+     * the sign-change bracket (or on-plane endpoint) whose crossing point lies
+     * closest to the centroid, refined by bisection. Null when the guide never
+     * reaches the plane.
+     */
+    private static planeCrossing;
+    /**
+     * The full section stack: the exact profiles at their own parameters, and
+     * between each pair the base surface's iso-sections carried onto the rails.
+     */
+    private static buildSectionStack;
+    /** Poles of the base surface's iso-section at loft parameter v (a v-basis row blend). */
+    private static isoSectionPoles;
+    /**
+     * Carries a virtual section onto the rails. One rail translates the
+     * section rigidly; two rails additionally rotate and stretch it along the
+     * contact axis so both contact points land on their rails. Affine maps
+     * leave NURBS weights untouched, so transforming poles transforms the
+     * section exactly.
+     */
+    private static applyRails;
+    /**
+     * Affine map taking segment (a1, a2) onto (A1, A2): stretch along the
+     * segment axis, minimal rotation aligning the axes, rigid perpendicular
+     * components. Degenerate segments fall back to the average translation.
+     */
+    private static mapSegment;
+    /** Rodrigues rotation taking unit vector `from` to unit vector `to`. */
+    private static minimalRotation;
+}