fluidcad 0.0.35 → 0.0.37

package/lib/dist/oc/wire-ops.js

@@ -103,7 +103,7 @@ export class WireOps {
         fixer.FixGaps2d();
         fixer.FixEdgeCurves();
         fixer.FixConnected(oc.Precision.Confusion());
-        fixer.FixReorder();
+        fixer.FixReorder(true);
         fixer.Perform();
         const fixed = fixer.Wire();
         fixer.delete();

package/lib/dist/oc/wrap-development.d.ts

@@ -0,0 +1,105 @@
+import { Plane } from "../math/plane.js";
+import { Point, Point2D } from "../math/point.js";
+import { Vector3d } from "../math/vector3d.js";
+export interface UV {
+    u: number;
+    v: number;
+}
+/** Geometry of a cylindrical target surface, extracted from its `gp_Cylinder`. */
+export interface CylinderSpec {
+    origin: Point;
+    axisDir: Vector3d;
+    radius: number;
+}
+/** Geometry of a conical target surface, extracted from its `gp_Cone`. */
+export interface ConeSpec {
+    origin: Point;
+    axisDir: Vector3d;
+    /** Radius in the frame's reference plane (at v = 0). */
+    refRadius: number;
+    /** Cone half-angle. Negative angles are normalized by reversing the axis. */
+    semiAngle: number;
+}
+export type Development = CylinderDevelopment | ConeDevelopment;
+/**
+ * Isometric (arc-length preserving) development of a sketch plane onto a
+ * developable surface — a true wrap, not a projection.
+ *
+ * The mapping is anchored at the sketch plane origin: its radial projection
+ * onto the surface becomes the anchor point, and the surface frame is
+ * recentered so the anchor sits at u = 0, keeping wrapped geometry away from
+ * the parametric seam.
+ *
+ * In-plane orientation is derived from the surface rather than assumed: the
+ * projection of the surface meridian onto the sketch plane maps to +v, and
+ * the perpendicular in-plane direction maps to +u with its sign matched to
+ * the projection of the surface's +u tangent. For the canonical sketch on a
+ * tangent plane this is the exact development; for tilted planes it degrades
+ * gracefully to the nearest isometry.
+ */
+export declare abstract class SurfaceDevelopment {
+    /** Frame origin (on the surface axis). */
+    readonly origin: Point;
+    /** Frame Z — the surface axis. */
+    readonly axisDir: Vector3d;
+    /** Frame X — points from the axis toward the sketch anchor (u = 0). */
+    readonly xDir: Vector3d;
+    /** Frame Y — completes the right-handed frame (+u tangent at the anchor). */
+    readonly yDir: Vector3d;
+    /** In-plane unit direction (sketch coords) that maps to +u (around the surface). */
+    private readonly sDir;
+    /** In-plane unit direction (sketch coords) that maps to +v (along the meridian). */
+    private readonly hDir;
+    protected constructor(plane: Plane, origin: Point, axisDir: Vector3d, xDir: Vector3d, meridianDir: Vector3d);
+    private static projectIntoPlane;
+    /** Sketch-plane point → development coordinates (s along +u, h along +v). */
+    protected develop(p: Point2D): {
+        s: number;
+        h: number;
+    };
+    /**
+     * Whether the mapping preserves winding: a counter-clockwise loop in
+     * sketch-plane coordinates (around the plane normal) stays counter-clockwise
+     * in UV. The (s, h) basis decides it — the u and v scales are positive.
+     */
+    isOrientationPreserving(): boolean;
+    /** Maps a sketch-plane point to parameters on the recentered surface. */
+    abstract toUV(p: Point2D): UV;
+    /** Evaluates the recentered surface at the given parameters. */
+    abstract evalPoint(uv: UV): Point;
+    /** Normal distance from a 3D point to the surface. */
+    abstract distanceTo(p: Point): number;
+    /** Outward surface normal at (the radial projection of) the given point. */
+    abstract surfaceNormalAt(p: Point): Vector3d;
+    /** Decomposes a point into axial height and radial offset in the surface frame. */
+    protected radialSplit(p: Point): {
+        z: number;
+        radialDist: number;
+        radialDir: Vector3d;
+    };
+}
+export declare class CylinderDevelopment extends SurfaceDevelopment {
+    readonly kind: "cylinder";
+    readonly radius: number;
+    /** Axial height of the sketch anchor in the surface frame. */
+    private readonly v0;
+    constructor(spec: CylinderSpec, plane: Plane);
+    toUV(p: Point2D): UV;
+    evalPoint(uv: UV): Point;
+    distanceTo(p: Point): number;
+    surfaceNormalAt(p: Point): Vector3d;
+}
+export declare class ConeDevelopment extends SurfaceDevelopment {
+    readonly kind: "cone";
+    readonly refRadius: number;
+    readonly semiAngle: number;
+    /** Slant distance from the apex to the v = 0 circle (= refRadius / sin(semiAngle)). */
+    private readonly apexSlant;
+    /** Slant distance from the apex to the sketch anchor. */
+    private readonly anchorSlant;
+    constructor(spec: ConeSpec, plane: Plane);
+    toUV(p: Point2D): UV;
+    evalPoint(uv: UV): Point;
+    distanceTo(p: Point): number;
+    surfaceNormalAt(p: Point): Vector3d;
+}

package/lib/dist/oc/wrap-development.js

@@ -0,0 +1,179 @@
+import { Point2D } from "../math/point.js";
+const EPSILON = 1e-9;
+const DIRECTION_EPSILON = 1e-6;
+/**
+ * Computes the anchor frame of a development: the sketch plane origin is
+ * projected radially onto the surface, and the frame's X direction points
+ * from the axis toward that anchor so the anchor sits at u = 0.
+ */
+function anchorFrame(origin, axisDir, plane) {
+    const toPlaneOrigin = origin.vectorTo(plane.origin);
+    const z0 = toPlaneOrigin.dot(axisDir);
+    const radial = toPlaneOrigin.subtract(axisDir.multiply(z0));
+    if (radial.length() < EPSILON) {
+        throw new Error("wrap(): the sketch plane origin must not lie on the target surface axis");
+    }
+    return { xDir: radial.normalize(), z0 };
+}
+/**
+ * Isometric (arc-length preserving) development of a sketch plane onto a
+ * developable surface — a true wrap, not a projection.
+ *
+ * The mapping is anchored at the sketch plane origin: its radial projection
+ * onto the surface becomes the anchor point, and the surface frame is
+ * recentered so the anchor sits at u = 0, keeping wrapped geometry away from
+ * the parametric seam.
+ *
+ * In-plane orientation is derived from the surface rather than assumed: the
+ * projection of the surface meridian onto the sketch plane maps to +v, and
+ * the perpendicular in-plane direction maps to +u with its sign matched to
+ * the projection of the surface's +u tangent. For the canonical sketch on a
+ * tangent plane this is the exact development; for tilted planes it degrades
+ * gracefully to the nearest isometry.
+ */
+export class SurfaceDevelopment {
+    /** Frame origin (on the surface axis). */
+    origin;
+    /** Frame Z — the surface axis. */
+    axisDir;
+    /** Frame X — points from the axis toward the sketch anchor (u = 0). */
+    xDir;
+    /** Frame Y — completes the right-handed frame (+u tangent at the anchor). */
+    yDir;
+    /** In-plane unit direction (sketch coords) that maps to +u (around the surface). */
+    sDir;
+    /** In-plane unit direction (sketch coords) that maps to +v (along the meridian). */
+    hDir;
+    constructor(plane, origin, axisDir, xDir, meridianDir) {
+        this.origin = origin;
+        this.axisDir = axisDir;
+        this.xDir = xDir;
+        this.yDir = axisDir.cross(xDir).normalize();
+        this.hDir = SurfaceDevelopment.projectIntoPlane(plane, meridianDir, "wrap(): the sketch plane is perpendicular to the target surface axis");
+        const uImage = SurfaceDevelopment.projectIntoPlane(plane, this.yDir, "wrap(): the sketch plane must not contain the target surface axis");
+        const perp = new Point2D(-this.hDir.y, this.hDir.x);
+        const towardU = perp.x * uImage.x + perp.y * uImage.y;
+        this.sDir = towardU >= 0 ? perp : new Point2D(-perp.x, -perp.y);
+    }
+    static projectIntoPlane(plane, dir, errorMessage) {
+        const inPlane = dir.subtract(plane.normal.multiply(dir.dot(plane.normal)));
+        if (inPlane.length() < DIRECTION_EPSILON) {
+            throw new Error(errorMessage);
+        }
+        const unit = inPlane.normalize();
+        return new Point2D(unit.dot(plane.xDirection), unit.dot(plane.yDirection));
+    }
+    /** Sketch-plane point → development coordinates (s along +u, h along +v). */
+    develop(p) {
+        return {
+            s: p.x * this.sDir.x + p.y * this.sDir.y,
+            h: p.x * this.hDir.x + p.y * this.hDir.y,
+        };
+    }
+    /**
+     * Whether the mapping preserves winding: a counter-clockwise loop in
+     * sketch-plane coordinates (around the plane normal) stays counter-clockwise
+     * in UV. The (s, h) basis decides it — the u and v scales are positive.
+     */
+    isOrientationPreserving() {
+        return this.sDir.x * this.hDir.y - this.sDir.y * this.hDir.x > 0;
+    }
+    /** Decomposes a point into axial height and radial offset in the surface frame. */
+    radialSplit(p) {
+        const w = this.origin.vectorTo(p);
+        const z = w.dot(this.axisDir);
+        const radial = w.subtract(this.axisDir.multiply(z));
+        const radialDist = radial.length();
+        const radialDir = radialDist < EPSILON ? this.xDir : radial.normalize();
+        return { z, radialDist, radialDir };
+    }
+}
+export class CylinderDevelopment extends SurfaceDevelopment {
+    kind = 'cylinder';
+    radius;
+    /** Axial height of the sketch anchor in the surface frame. */
+    v0;
+    constructor(spec, plane) {
+        const axisDir = spec.axisDir.normalize();
+        const { xDir, z0 } = anchorFrame(spec.origin, axisDir, plane);
+        super(plane, spec.origin, axisDir, xDir, axisDir);
+        this.radius = spec.radius;
+        this.v0 = z0;
+    }
+    toUV(p) {
+        const { s, h } = this.develop(p);
+        return { u: s / this.radius, v: this.v0 + h };
+    }
+    evalPoint(uv) {
+        return this.origin
+            .add(this.xDir.multiply(this.radius * Math.cos(uv.u)))
+            .add(this.yDir.multiply(this.radius * Math.sin(uv.u)))
+            .add(this.axisDir.multiply(uv.v));
+    }
+    distanceTo(p) {
+        return Math.abs(this.radialSplit(p).radialDist - this.radius);
+    }
+    surfaceNormalAt(p) {
+        return this.radialSplit(p).radialDir;
+    }
+}
+export class ConeDevelopment extends SurfaceDevelopment {
+    kind = 'cone';
+    refRadius;
+    semiAngle;
+    /** Slant distance from the apex to the v = 0 circle (= refRadius / sin(semiAngle)). */
+    apexSlant;
+    /** Slant distance from the apex to the sketch anchor. */
+    anchorSlant;
+    constructor(spec, plane) {
+        // Normalize to a positive half-angle so the slant grows with +v; a
+        // negative gp_Cone angle describes the same surface with a reversed axis.
+        let axisDir = spec.axisDir.normalize();
+        let semiAngle = spec.semiAngle;
+        if (semiAngle < 0) {
+            axisDir = axisDir.negate();
+            semiAngle = -semiAngle;
+        }
+        const { xDir, z0 } = anchorFrame(spec.origin, axisDir, plane);
+        const meridianDir = xDir.multiply(Math.sin(semiAngle)).add(axisDir.multiply(Math.cos(semiAngle)));
+        super(plane, spec.origin, axisDir, xDir, meridianDir);
+        this.refRadius = spec.refRadius;
+        this.semiAngle = semiAngle;
+        this.apexSlant = spec.refRadius / Math.sin(semiAngle);
+        this.anchorSlant = this.apexSlant + z0 / Math.cos(semiAngle);
+        if (this.anchorSlant < EPSILON) {
+            throw new Error("wrap(): the sketch plane origin projects onto the apex of the conical target face");
+        }
+    }
+    toUV(p) {
+        const { s, h } = this.develop(p);
+        // The cone develops into a planar sector around the apex, which sits at
+        // distance `anchorSlant` behind the sketch anchor along -h. Develop the
+        // point in polar coordinates around it: slant = planar radius, surface
+        // angle = planar angle / sin(semiAngle).
+        const fromApexH = this.anchorSlant + h;
+        const rho = Math.hypot(s, fromApexH);
+        if (rho < EPSILON) {
+            throw new Error("wrap(): the sketch extends across the apex of the conical target face");
+        }
+        const phi = Math.atan2(s, fromApexH);
+        return { u: phi / Math.sin(this.semiAngle), v: rho - this.apexSlant };
+    }
+    evalPoint(uv) {
+        const r = this.refRadius + uv.v * Math.sin(this.semiAngle);
+        return this.origin
+            .add(this.xDir.multiply(r * Math.cos(uv.u)))
+            .add(this.yDir.multiply(r * Math.sin(uv.u)))
+            .add(this.axisDir.multiply(uv.v * Math.cos(this.semiAngle)));
+    }
+    distanceTo(p) {
+        const { z, radialDist } = this.radialSplit(p);
+        const surfaceRadius = this.refRadius + z * Math.tan(this.semiAngle);
+        return Math.abs((radialDist - surfaceRadius) * Math.cos(this.semiAngle));
+    }
+    surfaceNormalAt(p) {
+        const { radialDir } = this.radialSplit(p);
+        return radialDir.multiply(Math.cos(this.semiAngle))
+            .subtract(this.axisDir.multiply(Math.sin(this.semiAngle)));
+    }
+}

package/lib/dist/oc/wrap-ops.d.ts

@@ -0,0 +1,100 @@
+import { Face } from "../common/face.js";
+import { Shape } from "../common/shape.js";
+import { Plane } from "../math/plane.js";
+import { Development } from "./wrap-development.js";
+export interface WrapResult {
+    solids: Shape[];
+    /** Faces lying on the target surface (the base of the wrap). */
+    startFaces: Face[];
+    /** Faces offset from the target surface by the wrap thickness. */
+    endFaces: Face[];
+    /** Wall faces generated from the outer boundary of each region. */
+    sideFaces: Face[];
+    /** Wall faces generated from sketch holes inside a region. */
+    internalFaces: Face[];
+}
+export declare class WrapOps {
+    /**
+     * Wraps planar sketch region faces onto the surface of `targetFace` and
+     * thickens them by `thickness` measured along the surface normal. Positive
+     * thickness grows out of the material (emboss), negative grows into it
+     * (deboss tool). Returns the thickened solids with their faces classified.
+     *
+     * The pad base lies EXACTLY on the target surface. Downstream booleans
+     * resolve that coincident-face contact via their fuzzy tolerance and
+     * same-domain handling; do not be tempted to sink the base slightly past
+     * the surface to "help" them — the resulting wall∕target section curves
+     * are approximated by OCCT and oscillate visibly near the wall joints.
+     */
+    static wrap(regionFaces: Face[], sketchPlane: Plane, targetFace: Face, thickness: number): WrapResult;
+    /** Builds the development mapping for the target face's underlying surface. */
+    static createDevelopment(targetFace: Face, sketchPlane: Plane): Development;
+    /**
+     * Whether the target face's material-outward normal points toward the
+     * surface axis (a bore wall) rather than away from it (an outer wall).
+     * The TopAbs orientation flag alone cannot tell: prism-swept lateral
+     * faces carry a reverse-parameterized surface (intrinsic normal inward,
+     * flag REVERSED) yet still face away from the axis.
+     */
+    private static isInwardFacing;
+    /** Builds the recentered Geom surface (sketch anchor at u = 0). */
+    private static makeSurface;
+    /** Maps one planar region face onto the surface as a face with pcurve boundaries. */
+    private static wrapRegion;
+    /**
+     * Enforces the winding the face builder needs: the outer boundary
+     * counter-clockwise in UV (material to its left on the surface), holes
+     * clockwise. The mapped wire inherits the planar wire's winding through the
+     * development (possibly mirrored), so measure the source and reverse the UV
+     * wire when it lands the wrong way.
+     */
+    private static orientUvWire;
+    /** Maps a planar wire into a wire of edges with pcurves on the surface. */
+    private static mapWire;
+    /**
+     * Maps one sketch edge onto the surface, following the source wire's
+     * traversal direction (reversed edges are sampled back to front) so the
+     * assembled UV wire winds the same way as the planar wire it came from.
+     * Straight edges on cylinders map to exact UV lines (the development is
+     * affine there); everything else is sampled along the curve and fitted with
+     * a 2D B-spline. Closed edges (e.g. full circles) are split into two halves
+     * so the resulting wire has topologically distinct vertices.
+     */
+    private static mapEdge;
+    private static mapPoint;
+    private static makeFittedUvEdge;
+    private static makeUvLineEdge;
+    /**
+     * Interpolates the developed UV samples of one sketch edge with a 2D
+     * B-spline that passes exactly through every sample (so adjacent wire
+     * edges meet bit-exactly — no endpoint snapping needed).
+     *
+     * The poles/knots are computed in-house: fluidcad-ocjs currently
+     * miscompiles `Geom2dAPI_PointsToBSpline` — both its array constructors
+     * (NaN poles) and its `Init` path (the "fit" of a clean semicircle bulged
+     * 70% past the samples). `Geom2d_BSplineCurve`'s array constructor is
+     * unaffected.
+     */
+    private static fitUvCurve;
+    /** Thickens the wrapped face along the surface normal into a solid. */
+    private static thicken;
+    /**
+     * Classifies the thickened solid's faces. The wrapped base face survives
+     * thickening unchanged (start); the only other face whose normal is aligned
+     * with the surface normal is the offset face (end); the remaining walls are
+     * split into internal (sharing an edge with a sketch hole) and side.
+     */
+    private static classify;
+    private static collectHoleEdges;
+    private static sharesEdgeWith;
+    /**
+     * Samples the face at the middle of its UV bounds: the surface point and
+     * the material-outward normal (oriented by the face's TopAbs flag) at that
+     * SAME parameter. Classification compares this normal against the
+     * development normal at the sampled point — sampling both at one location
+     * keeps the comparison angle-independent on periodic surfaces, where the
+     * normal rotates with u (a normal taken anywhere else drifts by the angular
+     * distance and breaks the alignment test past ~45°).
+     */
+    private static probeFace;
+}