fluidcad 0.0.32 → 0.0.34

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

@@ -121,16 +121,37 @@ export class ExtrudeOps {
             edgeFaces: edgeFacesRaw.map(({ edge, face }) => ({ edge, face: findFace(face) })),
         };
     }
-    static applyDraftOnSideFaces(solid, firstFace, lastFace, plane, angle) {
+    static applyDraftOnSideFaces(solid, firstFace, lastFace, plane, angle, excludeFaces = []) {
         const oc = getOC();
         const [dir, disposeDir] = Convert.toGpDir(plane.normal);
         const [pln, disposePln] = Convert.toGpPln(plane);
         const solidRaw = solid.getShape();
         const firstFaceRaw = firstFace.getShape();
         const lastFaceRaw = lastFace.getShape();
+        const excludeRaw = excludeFaces.map(s => s.getShape());
         const draftMaker = new oc.BRepOffsetAPI_DraftAngle(solidRaw);
-        const sideFaces = Explorer.findShapes(solidRaw, Explorer.getOcShapeType("face")).filter(f => !f.IsSame(firstFaceRaw) && !f.IsSame(lastFaceRaw));
+        const sideFaces = Explorer.findShapes(solidRaw, Explorer.getOcShapeType("face")).filter(f => !f.IsSame(firstFaceRaw)
+            && !f.IsSame(lastFaceRaw)
+            && !excludeRaw.some(e => f.IsSame(e)));
         for (const face of sideFaces) {
+            // Skip faces whose surface normal is parallel to the draft pull
+            // direction — drafting them is geometrically degenerate (you can't
+            // tilt a face around an axis parallel to the face's own normal) and
+            // OCC fails the whole Build() if any such face is added. Non-planar
+            // faces get drafted unconditionally.
+            const adaptor = new oc.BRepAdaptor_Surface(Explorer.toFace(face), true);
+            if (adaptor.GetType() === oc.GeomAbs_SurfaceType.GeomAbs_Plane) {
+                const facePlane = adaptor.Plane();
+                const ax = facePlane.Axis().Direction();
+                const dot = Math.abs(ax.Dot(dir));
+                adaptor.delete();
+                if (dot > 0.999) {
+                    continue;
+                }
+            }
+            else {
+                adaptor.delete();
+            }
             draftMaker.Add(Explorer.toFace(face), dir, angle, pln, true);
         }
         const progress = new oc.Message_ProgressRange();
@@ -150,14 +171,42 @@ export class ExtrudeOps {
         const newLastFace = modifiedLast.length > 0
             ? ShapeFactory.fromShape(modifiedLast[0])
             : lastFace;
+        // Capture the post-draft images of every input face we care about
+        // BEFORE deleting the maker. This lets the caller remap pre-draft
+        // face buckets onto the drafted result.
+        const remapMap = new Map();
+        const captureRemap = (raw) => {
+            const list = ShapeOps.shapeListToArray(draftMaker.Modified(raw));
+            remapMap.set(raw, list.length > 0
+                ? list.map(r => ShapeFactory.fromShape(r))
+                : [ShapeFactory.fromShape(raw)]);
+        };
+        captureRemap(firstFaceRaw);
+        captureRemap(lastFaceRaw);
+        for (const ex of excludeRaw) {
+            captureRemap(ex);
+        }
+        for (const sf of sideFaces) {
+            captureRemap(sf);
+        }
         const result = draftMaker.Shape();
         draftMaker.delete();
         disposeDir();
         disposePln();
+        const remapFace = (face) => {
+            const raw = face.getShape();
+            for (const [k, v] of remapMap) {
+                if (k.IsSame(raw)) {
+                    return v;
+                }
+            }
+            return [face];
+        };
         return {
             solid: ShapeFactory.fromShape(result),
             firstFace: newFirstFace,
             lastFace: newLastFace,
+            remapFace,
         };
     }
     static applyDraft(shape, direction, angle) {

package/lib/dist/oc/mesh.d.ts

@@ -7,6 +7,11 @@ export interface MeshData {
     indices: number[];
     count?: number;
 }
+export interface MeshConfig {
+    linDefl: number;
+    angDefl: number;
+}
+export declare const DEFAULT_MESH_CONFIG: MeshConfig;
 export interface EnsureTriangulatedOptions {
     linDefl?: number;
     angDefl?: number;
@@ -15,15 +20,15 @@ export interface EnsureTriangulatedOptions {
     checkFreeEdges?: boolean;
 }
 export declare class Mesh {
-    static triangulateFace(face: Face, vertexOffset?: number): MeshData | null;
-    static discretizeEdge(edge: Shape): MeshData;
+    static triangulateFace(face: Face, vertexOffset?: number, opts?: EnsureTriangulatedOptions): MeshData | null;
+    static discretizeEdge(edge: Shape, opts?: EnsureTriangulatedOptions): MeshData;
     /**
      * Triangulates `shape` only if it doesn't already have an up-to-date
      * triangulation at the requested deflection. Returns true when a fresh
      * mesh was built, false when the stored one was reused.
      */
     static ensureTriangulated(shape: TopoDS_Shape, opts?: EnsureTriangulatedOptions): boolean;
-    static triangulateFaceRaw(face: TopoDS_Face, vertexOffset?: number): MeshData | null;
+    static triangulateFaceRaw(face: TopoDS_Face, vertexOffset?: number, opts?: EnsureTriangulatedOptions): MeshData | null;
     static extractFaceTriangulationRaw(face: TopoDS_Face, vertexOffset?: number): MeshData | null;
     /**
      * Reads the polyline stored for `edge` as a polygon-on-triangulation of
@@ -36,5 +41,5 @@ export declare class Mesh {
      * meshed face). Caller must have already run `ensureTriangulated` on the
      * edge or its parent wire.
      */
-    static discretizeEdgeRaw(edge: TopoDS_Shape): MeshData;
+    static discretizeEdgeRaw(edge: TopoDS_Shape, opts?: EnsureTriangulatedOptions): MeshData;
 }

package/lib/dist/oc/mesh.js

@@ -1,15 +1,16 @@
 import { getOC } from "./init.js";
 import { Explorer } from "./explorer.js";
-// Flip to false to benchmark single-threaded meshing.
-const DEFAULT_LIN_DEFLECTION = 0.1;
-const DEFAULT_ANG_DEFLECTION = 0.5;
+export const DEFAULT_MESH_CONFIG = {
+    linDefl: 0.1,
+    angDefl: 0.5,
+};
 export class Mesh {
     // Wrapper methods (public API for external callers)
-    static triangulateFace(face, vertexOffset = 0) {
-        return Mesh.triangulateFaceRaw(face.getShape(), vertexOffset);
+    static triangulateFace(face, vertexOffset = 0, opts) {
+        return Mesh.triangulateFaceRaw(face.getShape(), vertexOffset, opts);
     }
-    static discretizeEdge(edge) {
-        return Mesh.discretizeEdgeRaw(edge.getShape());
+    static discretizeEdge(edge, opts) {
+        return Mesh.discretizeEdgeRaw(edge.getShape(), opts);
     }
     /**
      * Triangulates `shape` only if it doesn't already have an up-to-date
@@ -18,8 +19,8 @@ export class Mesh {
      */
     static ensureTriangulated(shape, opts = {}) {
         const oc = getOC();
-        const linDefl = opts.linDefl ?? DEFAULT_LIN_DEFLECTION;
-        const angDefl = opts.angDefl ?? DEFAULT_ANG_DEFLECTION;
+        const linDefl = opts.linDefl ?? DEFAULT_MESH_CONFIG.linDefl;
+        const angDefl = opts.angDefl ?? DEFAULT_MESH_CONFIG.angDefl;
         const relative = opts.relative ?? false;
         const checkFreeEdges = opts.checkFreeEdges ?? true;
         if (oc.BRepTools.Triangulation(shape, linDefl, checkFreeEdges)) {
@@ -31,9 +32,9 @@ export class Mesh {
         return true;
     }
     // Raw methods (for oc-internal use)
-    static triangulateFaceRaw(face, vertexOffset = 0) {
+    static triangulateFaceRaw(face, vertexOffset = 0, opts) {
         try {
-            Mesh.ensureTriangulated(face);
+            Mesh.ensureTriangulated(face, opts);
         }
         catch (e) {
             console.error("Face mesh failed", e);
@@ -151,14 +152,14 @@ export class Mesh {
      * meshed face). Caller must have already run `ensureTriangulated` on the
      * edge or its parent wire.
      */
-    static discretizeEdgeRaw(edge) {
+    static discretizeEdgeRaw(edge, opts) {
         const oc = getOC();
         const ocEdge = oc.TopoDS.Edge(edge);
         if (oc.BRep_Tool.Degenerated(ocEdge)) {
             ocEdge.delete();
             return { vertices: [], normals: [], indices: [] };
         }
-        Mesh.ensureTriangulated(edge);
+        Mesh.ensureTriangulated(edge, opts);
         const loc = new oc.TopLoc_Location();
         const polyHandle = oc.BRep_Tool.Polygon3D(ocEdge, loc);
         if (polyHandle.IsNull()) {

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

@@ -0,0 +1,35 @@
+import { Face } from "../common/face.js";
+import { Wire } from "../common/wire.js";
+import { Shape } from "../common/shape.js";
+import { Point } from "../math/point.js";
+import { Plane } from "../math/plane.js";
+import { Vector3d } from "../math/vector3d.js";
+export interface RibConformResult {
+    solids: Shape[];
+    startFaces: Face[];
+    endFaces: Face[];
+    sideFaces: Face[];
+    internalFaces: Face[];
+}
+export declare class RibOps {
+    static makeRibProfile(spineWire: Wire, thickness: number, plane: Plane): Face;
+    static makeRibProfileParallel(spineWire: Wire, thickness: number, plane: Plane): Face;
+    static makeParallelRibClosedWire(spineWire: Wire, thickness: number, plane: Plane): Wire;
+    static makeTaperedRibPrism(spineWire: Wire, thickness: number, plane: Plane, direction: Vector3d, extrudeLength: number, draftAngleRad: number): {
+        solid: Shape;
+        firstFace: Shape;
+        lastFace: Shape;
+    };
+    static computeSpinePerpendicularDirection(spineWire: Wire, plane: Plane): Vector3d;
+    static extendSpineWire(spineWire: Wire, scopeShapes: Shape[], _plane: Plane): Wire;
+    static computeExtrudeDistanceAlongDirection(direction: Vector3d, origin: Point, scopeShapes: Shape[]): number;
+    static computeExtrudeDistance(plane: Plane, scopeShapes: Shape[]): number;
+    static conformRibToScope(ribSolid: Shape, scopeShapes: Shape[], originalSpineWire: Wire, prismFirstFace: Shape, prismLastFace: Shape, extrudeDirection: Vector3d): RibConformResult;
+    private static collectFaceImages;
+    private static tryGetFacePlane;
+    private static buildBoundingBoxSlabs;
+    private static makeAxisAlignedSlab;
+    private static offsetWireOnPlane;
+    private static makeOpenFaceWithCaps;
+    private static makeClosedWireWithCaps;
+}