fluidcad 0.0.2

package/lib/dist/oc/geometry.js

@@ -0,0 +1,231 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { Point2D } from "../math/point.js";
+import { Edge } from "../common/edge.js";
+export class Geometry {
+    // ── Shape factories ────────────────────────────────────────────────────────
+    static makeSegment(p1, p2) {
+        const oc = getOC();
+        const [transformedP1, disposeP1] = Convert.toGpPnt(p1);
+        const [transformedP2, disposeP2] = Convert.toGpPnt(p2);
+        const segmentMaker = new oc.GC_MakeSegment(transformedP1, transformedP2);
+        if (!segmentMaker.IsDone()) {
+            const status = segmentMaker.Status();
+            segmentMaker.delete();
+            disposeP1();
+            disposeP2();
+            throw new Error("Failed to create segment: " + status);
+        }
+        const geometry = segmentMaker.Value().get();
+        segmentMaker.delete();
+        disposeP1();
+        disposeP2();
+        return geometry;
+    }
+    static makeArcThreePoints(start, end, p3) {
+        const oc = getOC();
+        const [gpStart, disposeStart] = Convert.toGpPnt(start);
+        const [gpEnd, disposeEnd] = Convert.toGpPnt(end);
+        const [gpP3, disposeP3] = Convert.toGpPnt(p3);
+        const arcMaker = new oc.GC_MakeArcOfCircle(gpStart, gpEnd, gpP3);
+        if (arcMaker.IsDone()) {
+            const curve = arcMaker.Value().get();
+            arcMaker.delete();
+            disposeStart();
+            disposeEnd();
+            disposeP3();
+            return curve;
+        }
+        const status = arcMaker.Status();
+        arcMaker.delete();
+        disposeStart();
+        disposeEnd();
+        disposeP3();
+        throw new Error('Failed to create arc edge from center: ' + status);
+    }
+    static makeArc(center, radius, normal, start, end) {
+        const oc = getOC();
+        const [c, disposeC] = Convert.toGpPnt(center);
+        const [s, disposeS] = Convert.toGpPnt(start);
+        const [e, disposeE] = Convert.toGpPnt(end);
+        const [dir, disposeDir] = Convert.toGpDir(normal);
+        const ax2 = new oc.gp_Ax2(c, dir);
+        const circle = new oc.gp_Circ(ax2, radius);
+        const arcMaker = new oc.GC_MakeArcOfCircle(circle, s, e, true);
+        let curve = null;
+        if (arcMaker.IsDone()) {
+            curve = arcMaker.Value().get();
+        }
+        disposeC();
+        disposeS();
+        disposeE();
+        disposeDir();
+        ax2.delete();
+        circle.delete();
+        arcMaker.delete();
+        if (!curve) {
+            throw new Error('Failed to create arc edge from center');
+        }
+        return curve;
+    }
+    static makeArcFromAngle(center, radius, normal, start, angle) {
+        const oc = getOC();
+        const [gpCenter, disposeCenter] = Convert.toGpPnt(center);
+        const [gpDir, disposeDir] = Convert.toGpDir(normal);
+        const [gpStart, disposeStart] = Convert.toGpPnt(start);
+        const ax2 = new oc.gp_Ax2(gpCenter, gpDir);
+        const circle = new oc.gp_Circ(ax2, radius);
+        const arcMaker = new oc.GC_MakeArcOfCircle(circle, gpStart, angle, true);
+        if (arcMaker.IsDone()) {
+            const curve = arcMaker.Value().get();
+            arcMaker.delete();
+            ax2.delete();
+            circle.delete();
+            disposeCenter();
+            disposeDir();
+            disposeStart();
+            return curve;
+        }
+        const status = arcMaker.Status();
+        arcMaker.delete();
+        ax2.delete();
+        circle.delete();
+        disposeCenter();
+        disposeDir();
+        disposeStart();
+        throw new Error('Failed to create arc edge from angle:' + status);
+    }
+    static makeArcFromTangent(start, end, tangent) {
+        const oc = getOC();
+        const [gpStart, disposeStart] = Convert.toGpPnt(start);
+        const [gpTangent, disposeTangent] = Convert.toGpVec(tangent);
+        const [gpEnd, disposeEnd] = Convert.toGpPnt(end);
+        const arcMaker = new oc.GC_MakeArcOfCircle(gpStart, gpTangent, gpEnd);
+        if (arcMaker.IsDone()) {
+            const curve = arcMaker.Value().get();
+            arcMaker.delete();
+            disposeStart();
+            disposeTangent();
+            disposeEnd();
+            return curve;
+        }
+        const status = arcMaker.Status();
+        arcMaker.delete();
+        disposeStart();
+        disposeTangent();
+        disposeEnd();
+        throw new Error('Failed to create arc edge from tangent: ' + status);
+    }
+    static makeCircle(center, radius, normal) {
+        const oc = getOC();
+        const [gpCenter, disposeCenter] = Convert.toGpPnt(center);
+        const [gpDir, disposeDir] = Convert.toGpDir(normal);
+        const ax2 = new oc.gp_Ax2(gpCenter, gpDir);
+        const gpCircle = new oc.gp_Circ(ax2, radius);
+        const circleMaker = new oc.GC_MakeCircle(gpCircle);
+        if (circleMaker.IsDone()) {
+            const circle = circleMaker.Value().get();
+            circleMaker.delete();
+            ax2.delete();
+            gpCircle.delete();
+            disposeCenter();
+            disposeDir();
+            return circle;
+        }
+        const status = circleMaker.Status();
+        circleMaker.delete();
+        ax2.delete();
+        gpCircle.delete();
+        disposeCenter();
+        disposeDir();
+        throw new Error('Failed to create circle edge: ' + status);
+    }
+    static makeBezierCurve(poles) {
+        const oc = getOC();
+        const polesArray = new oc.TColgp_Array1OfPnt(1, poles.length);
+        const disposers = [];
+        for (let i = 0; i < poles.length; i++) {
+            const [gpPnt, dispose] = Convert.toGpPnt(poles[i]);
+            polesArray.SetValue(i + 1, gpPnt);
+            disposers.push(dispose);
+        }
+        const curve = new oc.Geom_BezierCurve(polesArray);
+        polesArray.delete();
+        for (const dispose of disposers) {
+            dispose();
+        }
+        return curve;
+    }
+    static makeEdgeFromBezier(curve) {
+        const oc = getOC();
+        const handle = new oc.Handle_Geom_Curve(curve);
+        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(handle, curve.StartPoint(), curve.EndPoint());
+        if (edgeMaker.IsDone()) {
+            const edge = edgeMaker.Edge();
+            edgeMaker.delete();
+            handle.delete();
+            return Edge.fromTopoDSEdge(edge);
+        }
+        const status = edgeMaker.Error();
+        edgeMaker.delete();
+        handle.delete();
+        throw new Error('Failed to create edge from bezier curve: ' + status);
+    }
+    // ── Edge factories ─────────────────────────────────────────────────────────
+    static makeEdge(geometry) {
+        return Edge.fromTopoDSEdge(Geometry.makeEdgeRaw(geometry));
+    }
+    static makeEdgeFromCurve(curve) {
+        return Edge.fromTopoDSEdge(Geometry.makeEdgeFromCurveRaw(curve));
+    }
+    static makeEdgeFromCircle(circle) {
+        return Edge.fromTopoDSEdge(Geometry.makeEdgeFromCircleRaw(circle));
+    }
+    static makeEdgeRaw(geometry) {
+        const oc = getOC();
+        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(geometry.StartPoint(), geometry.EndPoint());
+        if (!edgeMaker.IsDone()) {
+            const status = edgeMaker.Error();
+            edgeMaker.delete();
+            throw new Error("Failed to create edge: " + status);
+        }
+        const edge = edgeMaker.Edge();
+        edgeMaker.delete();
+        geometry.delete();
+        return edge;
+    }
+    static makeEdgeFromCurveRaw(curve) {
+        const oc = getOC();
+        const handle = new oc.Handle_Geom_Curve(curve);
+        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(handle, curve.StartPoint(), curve.EndPoint());
+        if (edgeMaker.IsDone()) {
+            const edge = edgeMaker.Edge();
+            edgeMaker.delete();
+            handle.delete();
+            return edge;
+        }
+        const status = edgeMaker.Error();
+        edgeMaker.delete();
+        handle.delete();
+        throw new Error('Failed to create edge from arc: ' + status);
+    }
+    static makeEdgeFromCircleRaw(circle) {
+        const oc = getOC();
+        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(circle.Circ());
+        if (edgeMaker.IsDone()) {
+            const edge = edgeMaker.Edge();
+            edgeMaker.delete();
+            return edge;
+        }
+        const status = edgeMaker.Error();
+        edgeMaker.delete();
+        throw new Error('Failed to create edge from circle: ' + status);
+    }
+    // ── 2D math helpers ────────────────────────────────────────────────────────
+    static getPointOnCircle(center, radius, angle) {
+        return new Point2D(center.x + radius * Math.cos(angle), center.y + radius * Math.sin(angle));
+    }
+    static getCircleCenter(point, radius, angle) {
+        return new Point2D(point.x - radius * Math.cos(angle), point.y - radius * Math.sin(angle));
+    }
+}

package/lib/dist/oc/hit-test.d.ts

@@ -0,0 +1,11 @@
+import type { TopoDS_Shape } from "occjs-wrapper";
+export type HitTestResult = {
+    type: 'face';
+    index: number;
+} | {
+    type: 'edge';
+    index: number;
+} | null;
+export declare class OccHitTest {
+    static hitTest(shape: TopoDS_Shape, rayOrigin: [number, number, number], rayDir: [number, number, number], edgeThreshold: number): HitTestResult;
+}

package/lib/dist/oc/hit-test.js

@@ -0,0 +1,85 @@
+import { getOC } from "./init.js";
+import { Explorer } from "./explorer.js";
+export class OccHitTest {
+    static hitTest(shape, rayOrigin, rayDir, edgeThreshold) {
+        const oc = getOC();
+        // Build ray geometry
+        const origin = new oc.gp_Pnt(rayOrigin[0], rayOrigin[1], rayOrigin[2]);
+        const dir = new oc.gp_Dir(rayDir[0], rayDir[1], rayDir[2]);
+        const ray = new oc.gp_Lin(origin, dir);
+        // ---- Face hit ----
+        let bestFaceShape = null;
+        let bestW = Infinity;
+        const intersector = new oc.IntCurvesFace_ShapeIntersector();
+        intersector.Load(shape, 1e-7);
+        intersector.Perform(ray, -1e10, 1e10);
+        if (intersector.IsDone()) {
+            const nbPnts = intersector.NbPnt();
+            for (let i = 1; i <= nbPnts; i++) {
+                const w = intersector.WParameter(i);
+                if (w > 0 && w < bestW) {
+                    bestW = w;
+                    bestFaceShape = intersector.Face(i);
+                }
+            }
+        }
+        intersector.delete();
+        // Map bestFaceShape to a face index via IsSame comparison
+        let faceIndex = null;
+        if (bestFaceShape !== null) {
+            const faces = Explorer.findShapes(shape, oc.TopAbs_ShapeEnum.TopAbs_FACE);
+            for (let i = 0; i < faces.length; i++) {
+                if (bestFaceShape.IsSame(faces[i])) {
+                    faceIndex = i;
+                    break;
+                }
+            }
+        }
+        // ---- Edge check (runs regardless of face hit) ----
+        // Build a finite ray-segment edge so BRepExtrema can measure 3-D distance to it.
+        const FAR = 10000;
+        const pNear = new oc.gp_Pnt(rayOrigin[0], rayOrigin[1], rayOrigin[2]);
+        const pFar = new oc.gp_Pnt(rayOrigin[0] + rayDir[0] * FAR, rayOrigin[1] + rayDir[1] * FAR, rayOrigin[2] + rayDir[2] * FAR);
+        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(pNear, pFar);
+        const rayEdge = edgeMaker.Edge();
+        const edges = Explorer.findShapes(shape, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
+        let minEdgeDist = Infinity;
+        let minEdgeIndex = -1;
+        const progress = new oc.Message_ProgressRange();
+        for (let i = 0; i < edges.length; i++) {
+            const distCalc = new oc.BRepExtrema_DistShapeShape(rayEdge, edges[i], oc.Extrema_ExtFlag.Extrema_ExtFlag_MIN, oc.Extrema_ExtAlgo.Extrema_ExtAlgo_Grad, progress);
+            if (distCalc.IsDone()) {
+                const d = distCalc.Value();
+                if (d < minEdgeDist) {
+                    // Depth test: the closest point on the ray to this edge must be
+                    // at or in front of the face hit depth (bestW), mirroring the
+                    // Three.js edge depth check (edgeDist <= faceDist + epsilon).
+                    const closestOnRay = distCalc.PointOnShape1(1);
+                    const edgeDepth = (closestOnRay.X() - rayOrigin[0]) * rayDir[0] +
+                        (closestOnRay.Y() - rayOrigin[1]) * rayDir[1] +
+                        (closestOnRay.Z() - rayOrigin[2]) * rayDir[2];
+                    if (edgeDepth <= bestW + 1e-3) {
+                        minEdgeDist = d;
+                        minEdgeIndex = i;
+                    }
+                }
+            }
+            distCalc.delete();
+        }
+        progress.delete();
+        edgeMaker.delete();
+        pNear.delete();
+        pFar.delete();
+        origin.delete();
+        dir.delete();
+        ray.delete();
+        // Edge takes priority when close enough AND not behind the face
+        if (minEdgeIndex >= 0 && minEdgeDist <= edgeThreshold) {
+            return { type: 'edge', index: minEdgeIndex };
+        }
+        if (faceIndex !== null) {
+            return { type: 'face', index: faceIndex };
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,24 @@
+export { getOC, loadOC } from "./init.js";
+export { Convert } from "./convert.js";
+export type { Disposable } from "./convert.js";
+export { Explorer } from "./explorer.js";
+export { ShapeOps } from "./shape-ops.js";
+export { VertexOps } from "./vertex-ops.js";
+export { FaceOps } from "./face-ops.js";
+export { EdgeOps } from "./edge-ops.js";
+export { WireOps } from "./wire-ops.js";
+export { Geometry } from "./geometry.js";
+export { BooleanOps } from "./boolean-ops.js";
+export { ExtrudeOps } from "./extrude-ops.js";
+export { Primitives } from "./primitives.js";
+export { FilletOps } from "./fillet-ops.js";
+export { ShellOps } from "./shell-ops.js";
+export { EdgeQuery } from "./edge-query.js";
+export { FaceQuery } from "./face-query.js";
+export { ProjectionOps as Intersection } from "./intersection.js";
+export { Mesh } from "./mesh.js";
+export type { MeshData } from "./mesh.js";
+export { OcIO } from "./io.js";
+export { ShapeProps } from './props.js';
+export { SweepOps } from "./sweep-ops.js";
+export type { ShapeProperties } from './props.js';

package/lib/dist/oc/index.js

@@ -0,0 +1,21 @@
+export { getOC, loadOC } from "./init.js";
+export { Convert } from "./convert.js";
+export { Explorer } from "./explorer.js";
+export { ShapeOps } from "./shape-ops.js";
+export { VertexOps } from "./vertex-ops.js";
+export { FaceOps } from "./face-ops.js";
+export { EdgeOps } from "./edge-ops.js";
+export { WireOps } from "./wire-ops.js";
+export { Geometry } from "./geometry.js";
+export { BooleanOps } from "./boolean-ops.js";
+export { ExtrudeOps } from "./extrude-ops.js";
+export { Primitives } from "./primitives.js";
+export { FilletOps } from "./fillet-ops.js";
+export { ShellOps } from "./shell-ops.js";
+export { EdgeQuery } from "./edge-query.js";
+export { FaceQuery } from "./face-query.js";
+export { ProjectionOps as Intersection } from "./intersection.js";
+export { Mesh } from "./mesh.js";
+export { OcIO } from "./io.js";
+export { ShapeProps } from './props.js';
+export { SweepOps } from "./sweep-ops.js";

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

@@ -0,0 +1,3 @@
+import type { OpenCascadeInstance } from "occjs-wrapper/node/multi-threaded";
+export declare function getOC(): OpenCascadeInstance;
+export declare function loadOC(): Promise<OpenCascadeInstance>;

package/lib/dist/oc/init.js

@@ -0,0 +1,17 @@
+import initOpenCascade from "occjs-wrapper/node/multi-threaded";
+let oc = null;
+export function getOC() {
+    if (!oc) {
+        throw new Error("OpenCascade not initialized. Call loadOC() first.");
+    }
+    return oc;
+}
+export async function loadOC() {
+    if (oc) {
+        return oc;
+    }
+    console.debug("Loading OpenCascade...");
+    oc = await initOpenCascade();
+    console.debug("OpenCascade loaded successfully.");
+    return oc;
+}

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

@@ -0,0 +1,10 @@
+import { Plane } from "../math/plane.js";
+import { Face } from "../common/face.js";
+import { Wire } from "../common/wire.js";
+import { Edge } from "../common/edge.js";
+export declare class ProjectionOps {
+    static projectEdgeOntoPlane(targetPlane: Plane, edge: Edge): Wire[];
+    static projectWireOntoPlane(targetPlane: Plane, wire: Wire): Wire[];
+    static projectFaceOntoPlane(targetPlane: Plane, face: Face): Wire[];
+    private static normalProjectWire;
+}

package/lib/dist/oc/intersection.js

@@ -0,0 +1,107 @@
+import { getOC } from "./init.js";
+import { ShapeOps } from "./shape-ops.js";
+import { Convert } from "./convert.js";
+import { FaceOps } from "./face-ops.js";
+import { Wire } from "../common/wire.js";
+import { FaceQuery } from "./face-query.js";
+import { Matrix4 } from "../math/matrix4.js";
+import { WireOps } from "./wire-ops.js";
+export class ProjectionOps {
+    static projectEdgeOntoPlane(targetPlane, edge) {
+        const wire = WireOps.makeWireFromEdges([edge]);
+        const projected = ProjectionOps.projectWireOntoPlane(targetPlane, wire);
+        wire.getShape().delete();
+        return projected;
+    }
+    static projectWireOntoPlane(targetPlane, wire) {
+        const oc = getOC();
+        const topDSWire = wire.getShape();
+        const wirePlaneFinder = new oc.BRepBuilderAPI_FindPlane(topDSWire, oc.Precision.Confusion());
+        let wirePlane;
+        if (wirePlaneFinder.Found()) {
+            const handle = wirePlaneFinder.Plane();
+            const geomPln = handle.get();
+            const pln = geomPln.Pln();
+            wirePlane = Convert.toPlane(pln);
+            // geomPln.delete();
+            // handle.delete();
+        }
+        if (wirePlane && wirePlane.isParallelTo(targetPlane)) {
+            const distance = wirePlane.distanceToPlane(targetPlane);
+            console.log('Wire is coplanar with plane, applying translation if necessary');
+            const translation = targetPlane.normal.multiply(-distance);
+            const matrix = Matrix4.fromTranslation(translation.x, translation.y, translation.z);
+            const transformed = ShapeOps.transform(wire, matrix);
+            return [transformed];
+        }
+        const [pln, disposePln] = Convert.toGpPln(targetPlane);
+        const planeFace = FaceOps.makeFaceFromPlane(pln);
+        const projectedWires = [];
+        const projected = ProjectionOps.normalProjectWire(wire.getShape(), planeFace);
+        for (let projectedWire of projected) {
+            projectedWires.push(Wire.fromTopoDSWire(projectedWire));
+        }
+        disposePln();
+        return projectedWires;
+    }
+    static projectFaceOntoPlane(targetPlane, face) {
+        let facePlane = null;
+        try {
+            facePlane = face.getPlane();
+        }
+        catch {
+            // Non-planar face (cylinder, cone, sphere, etc.) — fall through to normal projection
+        }
+        if (facePlane) {
+            const parallel = FaceQuery.isFaceParallelToPlane(face, targetPlane);
+            const coplanar = FaceQuery.isFaceOnPlane(face, targetPlane);
+            if (parallel || coplanar) {
+                const wires = face.getWires();
+                const signedDist = targetPlane.signedDistanceToPoint(facePlane.origin);
+                const translation = targetPlane.normal.multiply(-signedDist);
+                let matrix = Matrix4.fromTranslation(translation.x, translation.y, translation.z);
+                const transformedWires = wires.map(wire => {
+                    const transformed = ShapeOps.transform(wire, matrix);
+                    return transformed;
+                });
+                return transformedWires;
+            }
+        }
+        const [pln, disposePln] = Convert.toGpPln(targetPlane);
+        const planeFace = FaceOps.makeFaceFromPlane(pln);
+        const wires = face.getWires();
+        const projectedWires = [];
+        for (const wire of wires) {
+            const projected = ProjectionOps.normalProjectWire(wire.getShape(), planeFace);
+            for (const projectedWire of projected) {
+                projectedWires.push(Wire.fromTopoDSWire(projectedWire));
+            }
+        }
+        disposePln();
+        return projectedWires;
+    }
+    static normalProjectWire(wire, targetFace) {
+        const oc = getOC();
+        const results = [];
+        try {
+            const projector = new oc.BRepAlgo_NormalProjection(targetFace);
+            projector.SetLimit(false);
+            projector.Add(wire);
+            projector.Build();
+            if (projector.IsDone()) {
+                const list = new oc.TopTools_ListOfShape();
+                projector.BuildWire(list);
+                const wires = ShapeOps.shapeListToArray(list).map(s => oc.TopoDS.Wire(s));
+                for (const projectedWire of wires) {
+                    results.push(projectedWire);
+                }
+            }
+            projector.delete();
+            return results;
+        }
+        catch (e) {
+            console.error('Normal projection failed for wire:', e);
+            return results;
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+import type { Handle_TDocStd_Document, TopoDS_Shape } from "occjs-wrapper";
+import { Shape } from "../common/shape.js";
+import { Solid } from "../common/solid.js";
+import { Face } from "../common/face.js";
+export declare class OcIO {
+    static readBRep(fileName: string, content: string): Shape;
+    static writeBRep(shape: Shape, fileName: string): string;
+    static readStep(fileName: string, data: Uint8Array): Shape;
+    static findSolids(shape: Shape): Solid[];
+    static findFaces(shape: Shape): Face[];
+    static makeCompound(shapes: Shape[]): Shape;
+    static readBRepSolids(fileName: string, content: string): Solid[];
+    static writeSolidsAsBRep(solids: Solid[], fileName: string): string;
+    static extractSolidsAndColors(docHandle: Handle_TDocStd_Document): {
+        solids: Array<{
+            shape: Solid;
+            faceColors: Array<{
+                faceIndex: number;
+                color: string;
+            }>;
+        }>;
+    };
+    static readBRepRaw(fileName: string, content: string): TopoDS_Shape;
+    static writeBRepRaw(shape: TopoDS_Shape, fileName: string): string;
+    static readStepRaw(fileName: string, data: Uint8Array): TopoDS_Shape;
+    static readStepXCAF(fileName: string, data: Uint8Array): {
+        docHandle: Handle_TDocStd_Document;
+        cleanup: () => void;
+    };
+    static castToSolid(shape: TopoDS_Shape): import("occjs-wrapper").TopoDS_Solid;
+    static findSolidsRaw(shape: TopoDS_Shape): TopoDS_Shape[];
+    static findFacesRaw(shape: TopoDS_Shape): TopoDS_Shape[];
+    static makeCompoundRaw(shapes: TopoDS_Shape[]): import("occjs-wrapper").TopoDS_Compound;
+    static extractSolidsAndColorsRaw(docHandle: Handle_TDocStd_Document): {
+        solids: Array<{
+            shape: TopoDS_Shape;
+            faceColors: Array<{
+                faceIndex: number;
+                color: string;
+            }>;
+        }>;
+    };
+    static writeStepRaw(compound: TopoDS_Shape, fileName: string): string;
+    static writeStepXCAF(solids: Solid[], fileName: string): string;
+    static writeStl(compound: TopoDS_Shape, fileName: string, linearDeflection: number, angularDeflection: number): Uint8Array;
+    private static hexToRgb;
+    private static findFaceColor;
+    private static rgbToHex;
+}