fluidcad 0.0.2

package/lib/dist/oc/face-maker.js

@@ -0,0 +1,191 @@
+import { getOC } from "./init.js";
+import { Explorer } from "./explorer.js";
+import { ShapeOps } from "./shape-ops.js";
+import { FaceOps } from "./face-ops.js";
+import { Face } from "../common/face.js";
+export class OcFaceMaker {
+    static createFacesFromWires(wires, gpPln) {
+        const oc = getOC();
+        if (wires.length === 0)
+            return [];
+        console.log("Creating faces from wires:", wires.length);
+        const faces = [];
+        for (let wire of wires) {
+            const face = FaceOps.makeFaceOnPlane(oc.TopoDS.Wire(wire), gpPln);
+            const fixer = new oc.ShapeFix_Face(face);
+            fixer.FixOrientation();
+            fixer.Perform();
+            const fixedFace = fixer.Face();
+            faces.push(fixedFace);
+            fixer.delete();
+            face.delete();
+        }
+        return faces;
+    }
+    static fuseIntersectingFaces(faces) {
+        const oc = getOC();
+        if (faces.length === 0)
+            return [];
+        if (faces.length === 1)
+            return faces;
+        const faceBoxes = faces.map((face, index) => ({
+            face,
+            index,
+            bbox: ShapeOps.getBoundingBox(face)
+        }));
+        const result = [];
+        const processedFaces = new Set();
+        for (let i = 0; i < faces.length; i++) {
+            const face1 = faces[i];
+            if (processedFaces.has(face1)) {
+                continue;
+            }
+            let fusedFace = face1;
+            const facesToFuse = [face1];
+            let bbox1 = faceBoxes[i].bbox;
+            for (let j = i + 1; j < faces.length; j++) {
+                const face2 = faces[j];
+                if (processedFaces.has(face2)) {
+                    continue;
+                }
+                const bbox2 = faceBoxes[j].bbox;
+                if (!OcFaceMaker.boundingBoxesIntersect(bbox1, bbox2)) {
+                    continue;
+                }
+                const progress = new oc.Message_ProgressRange();
+                const fuseMaker = new oc.BRepAlgoAPI_Fuse(fusedFace, face2, progress);
+                if (fuseMaker.IsDone()) {
+                    const newShape = fuseMaker.Shape();
+                    if (!newShape.IsNull()) {
+                        if (newShape.ShapeType() === oc.TopAbs_ShapeEnum.TopAbs_COMPOUND) {
+                            const facesInCompound = Explorer.findShapes(newShape, oc.TopAbs_ShapeEnum.TopAbs_FACE);
+                            console.log("Fused faces into a compound, found faces:", facesInCompound.length);
+                            if (facesInCompound.length > 2) {
+                                fusedFace = OcFaceMaker.unifyFaces(newShape);
+                                bbox1 = ShapeOps.getBoundingBox(fusedFace);
+                                facesToFuse.push(face2);
+                            }
+                        }
+                    }
+                }
+                progress.delete();
+                fuseMaker.delete();
+            }
+            result.push(fusedFace);
+            facesToFuse.forEach(face => processedFaces.add(face));
+        }
+        console.log("Fused faces count:", result.length);
+        return result;
+    }
+    static unifyFaces(facesCompound) {
+        console.log("Unifying faces compound:", facesCompound);
+        const oc = getOC();
+        const freeBounds = new oc.ShapeAnalysis_FreeBounds(facesCompound, oc.Precision.Confusion(), true, false);
+        const closedWiresCompound = freeBounds.GetClosedWires();
+        const firstWire = Explorer.findFirstShapeOfType(closedWiresCompound, oc.TopAbs_ShapeEnum.TopAbs_WIRE);
+        freeBounds.delete();
+        return FaceOps.makeFace(oc.TopoDS.Wire(firstWire));
+    }
+    static boundingBoxesIntersect(bbox1, bbox2) {
+        return !(bbox1.maxX < bbox2.minX || bbox2.maxX < bbox1.minX ||
+            bbox1.maxY < bbox2.minY || bbox2.maxY < bbox1.minY);
+    }
+    static getWiresFromFaces(faces) {
+        const oc = getOC();
+        const wires = [];
+        for (let face of faces) {
+            const faceWires = Explorer.findShapes(face, oc.TopAbs_ShapeEnum.TopAbs_WIRE);
+            console.log("Found wires in face:", faceWires.length);
+            for (const wire of faceWires) {
+                wires.push(oc.TopoDS.Wire(wire));
+            }
+        }
+        return wires;
+    }
+    static drillHoles(faceInfos) {
+        const oc = getOC();
+        const foundHoles = [];
+        let drilledFaces = [];
+        for (const faceInfo of faceInfos) {
+            if (foundHoles.includes(faceInfo)) {
+                continue;
+            }
+            const faceHoles = OcFaceMaker.getFaceHoles(faceInfo, faceInfos, foundHoles);
+            console.log("Found holes for face:", faceHoles.length);
+            if (faceHoles.length === 0) {
+                drilledFaces.push(faceInfo);
+                continue;
+            }
+            faceInfo.holes = faceHoles;
+            drilledFaces.push(faceInfo);
+            for (const hole of faceHoles) {
+                foundHoles.push(hole);
+            }
+        }
+        console.log("Found holes:", foundHoles.length);
+        console.log("Drilled faces before removing holes:", drilledFaces.length);
+        drilledFaces = drilledFaces.filter(info => !foundHoles.includes(info));
+        console.log("Drilled faces:", drilledFaces.length);
+        for (const info of drilledFaces) {
+            const holes = info.holes;
+            if (!holes?.length) {
+                continue;
+            }
+            const rawWire = info.wire.getShape();
+            const faceMaker = new oc.BRepLib_MakeFace(rawWire, false);
+            for (const hole of holes) {
+                const holeWire = hole.wire.getShape();
+                holeWire.Reverse();
+                faceMaker.Add(holeWire);
+            }
+            const newFace = faceMaker.Face();
+            info.face = Face.fromTopoDSFace(newFace);
+            for (const hole of holes) {
+                hole.wire.getShape().delete();
+                hole.face.getShape().delete();
+            }
+            info.holes = [];
+        }
+        return drilledFaces;
+    }
+    static getFaceHoles(faceInfo, allFaceInfos, exclude) {
+        const holes = [];
+        for (let fInfo of allFaceInfos) {
+            if (fInfo === faceInfo || exclude.includes(faceInfo)) {
+                continue;
+            }
+            if (OcFaceMaker.wireIsInsideFace(fInfo, faceInfo)) {
+                holes.push(fInfo);
+            }
+        }
+        return holes;
+    }
+    static wireIsInsideFace(inner, outer) {
+        const firstPoint = OcFaceMaker.getFirstPointOfWire(inner.wire.getShape());
+        return OcFaceMaker.hitTest(firstPoint, outer.face.getShape());
+    }
+    static getFirstPointOfWire(wire) {
+        const oc = getOC();
+        try {
+            const edges = Explorer.findShapes(wire, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
+            const firstEdge = oc.TopoDS.Edge(edges[0]);
+            const vertex = oc.TopExp.FirstVertex(firstEdge, true);
+            const point = oc.BRep_Tool.Pnt(vertex);
+            return point;
+        }
+        catch (error) {
+            console.error("Error getting first point of wire:", error);
+            return null;
+        }
+    }
+    static hitTest(point, face) {
+        const oc = getOC();
+        const classifier = new oc.BRepClass_FaceClassifier();
+        classifier.Perform(face, point, oc.Precision.Confusion(), true, oc.Precision.Confusion());
+        const state = classifier.State();
+        const isInside = state === oc.TopAbs_State.TopAbs_IN ||
+            state === oc.TopAbs_State.TopAbs_ON;
+        classifier.delete();
+        return isInside;
+    }
+}

package/lib/dist/oc/face-maker2.d.ts

@@ -0,0 +1,10 @@
+import { Edge } from "../common/edge.js";
+import { Wire } from "../common/wire.js";
+import { Plane } from "../math/plane.js";
+import { Face } from "../common/face.js";
+export declare class FaceMaker2 {
+    static getRegions(shapes: Array<Wire | Edge>, plane: Plane, drill?: boolean): Face[];
+    private static getDrilledFaces;
+    private static getFaces;
+    private static getSplitEdges;
+}

package/lib/dist/oc/face-maker2.js

@@ -0,0 +1,139 @@
+import { Edge } from "../common/edge.js";
+import { Explorer } from "./explorer.js";
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { FaceOps } from "./face-ops.js";
+import { Face } from "../common/face.js";
+import { ShapeOps } from "./shape-ops.js";
+export class FaceMaker2 {
+    static getRegions(shapes, plane, drill = true) {
+        const splitEdges = this.getSplitEdges(shapes);
+        if (drill) {
+            const faces = this.getDrilledFaces(splitEdges, plane);
+            return faces;
+        }
+        const faces = this.getFaces(splitEdges, plane);
+        return faces;
+    }
+    static getDrilledFaces(edges, plane) {
+        const allFaces = this.getFaces(edges, plane);
+        const oc = getOC();
+        // For each face, collect its outer wire edges and inner wire edges
+        const faceData = allFaces.map(face => {
+            const topoFace = oc.TopoDS.Face(face.getShape());
+            const outerWire = oc.BRepTools.OuterWire(topoFace);
+            const outerEdges = Explorer.findShapes(outerWire, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
+            const innerEdges = [];
+            const wires = Explorer.findShapes(topoFace, oc.TopAbs_ShapeEnum.TopAbs_WIRE);
+            for (const w of wires) {
+                const wire = oc.TopoDS.Wire(w);
+                if (!wire.IsSame(outerWire)) {
+                    innerEdges.push(...Explorer.findShapes(wire, oc.TopAbs_ShapeEnum.TopAbs_EDGE));
+                }
+            }
+            return { face, outerEdges, innerEdges };
+        });
+        // Build containment tree: face i is a child of face j if all of i's outer edges
+        // are inner edges of j
+        const parentOf = new Array(allFaces.length).fill(-1);
+        for (let i = 0; i < faceData.length; i++) {
+            for (let j = 0; j < faceData.length; j++) {
+                if (i === j) {
+                    continue;
+                }
+                const isChild = faceData[i].outerEdges.every(oe => faceData[j].innerEdges.some(ie => oe.IsSame(ie)));
+                if (isChild) {
+                    parentOf[i] = j;
+                    break;
+                }
+            }
+        }
+        // Compute nesting depth for each face
+        const depthCache = new Map();
+        const getDepth = (i) => {
+            if (parentOf[i] === -1) {
+                return 0;
+            }
+            if (depthCache.has(i)) {
+                return depthCache.get(i);
+            }
+            const d = 1 + getDepth(parentOf[i]);
+            depthCache.set(i, d);
+            return d;
+        };
+        // Even-odd rule: keep faces at even depth (0, 2, 4, ...)
+        return allFaces.filter((_, i) => getDepth(i) % 2 === 0);
+    }
+    static getFaces(edges, plane) {
+        const [gpPln, dispose] = Convert.toGpPln(plane);
+        const oc = getOC();
+        const planeFace = FaceOps.makeFaceFromPlane2(gpPln);
+        // Collect boundary edges of the big face before splitting
+        const boundaryEdges = Explorer.findShapes(planeFace, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
+        const splitter = new oc.BRepAlgoAPI_Splitter();
+        const args = new oc.TopTools_ListOfShape();
+        args.Append(planeFace);
+        splitter.SetArguments(args);
+        splitter.SetRunParallel(true);
+        const toolsList = new oc.TopTools_ListOfShape();
+        for (const edge of edges) {
+            toolsList.Append(edge.getShape());
+        }
+        splitter.SetTools(toolsList);
+        splitter.SetNonDestructive(true);
+        splitter.SetCheckInverted(true);
+        const progress = new oc.Message_ProgressRange();
+        splitter.Build(progress);
+        const result = splitter.Shape();
+        // Collect all modified boundary edges
+        const modifiedBoundaryEdges = [];
+        for (const bEdge of boundaryEdges) {
+            const modified = ShapeOps.shapeListToArray(splitter.Modified(bEdge));
+            for (const mod of modified) {
+                modifiedBoundaryEdges.push(mod);
+            }
+            // Also include the original if it wasn't modified
+            if (!splitter.IsDeleted(bEdge) && modified.length === 0) {
+                modifiedBoundaryEdges.push(bEdge);
+            }
+        }
+        // Filter: keep only faces with no boundary edges
+        const allFaces = Explorer.findShapes(result, oc.TopAbs_ShapeEnum.TopAbs_FACE);
+        const filtered = allFaces.filter(f => {
+            const faceEdges = Explorer.findShapes(f, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
+            return !faceEdges.some(fe => modifiedBoundaryEdges.some(be => oc.TopoDS.Edge(fe).IsSame(be)));
+        });
+        progress.delete();
+        splitter.delete();
+        dispose();
+        return filtered.map(f => Face.fromTopoDSFace(oc.TopoDS.Face(f)));
+    }
+    static getSplitEdges(shapes) {
+        const oc = getOC();
+        console.log('Getting split edges for shapes:', shapes.length);
+        if (shapes.length === 1) {
+            if (shapes[0] instanceof Edge) {
+                console.log('Single edge shape, using directly as split edge');
+                return [shapes[0]];
+            }
+        }
+        const cellsBuilder = new oc.BOPAlgo_CellsBuilder();
+        const argsList = new oc.TopTools_ListOfShape();
+        for (const shape of shapes) {
+            argsList.Append(shape.getShape());
+        }
+        cellsBuilder.SetArguments(argsList);
+        cellsBuilder.SetNonDestructive(true);
+        const progress = new oc.Message_ProgressRange();
+        cellsBuilder.Perform(progress);
+        if (cellsBuilder.HasErrors()) {
+            cellsBuilder.delete();
+            argsList.delete();
+            progress.delete();
+            return shapes;
+        }
+        cellsBuilder.AddAllToResult(0, false);
+        const allParts = cellsBuilder.GetAllParts();
+        return Explorer.findShapes(allParts, oc.TopAbs_ShapeEnum.TopAbs_EDGE).map(e => Edge.fromTopoDSEdge(oc.TopoDS.Edge(e)));
+    }
+}

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

@@ -0,0 +1,28 @@
+import type { gp_Cylinder, gp_Pln, TopoDS_Face, TopoDS_Wire } from "occjs-wrapper";
+import { Plane } from "../math/plane.js";
+import { Point } from "../math/point.js";
+import { Vector3d } from "../math/vector3d.js";
+import { Face } from "../common/face.js";
+import { Wire } from "../common/wire.js";
+export declare class FaceOps {
+    static getPlane(face: Face | TopoDS_Face): Plane;
+    static getPlaneRaw(face: TopoDS_Face): Plane;
+    static calculateNormal(face: Face | TopoDS_Face): Vector3d;
+    static calculateNormalRaw(face: TopoDS_Face): Vector3d;
+    static faceOnPlane(face: TopoDS_Face, plane: gp_Pln): boolean;
+    static faceOnPlaneWrapped(face: Face, plane: Plane): boolean;
+    static makeFace(wire: TopoDS_Wire): TopoDS_Face;
+    static makeFaceWrapped(wire: Wire): Face;
+    static makeFaceOnPlane(wire: TopoDS_Wire, plane: gp_Pln): TopoDS_Face;
+    static makeFaceOnPlaneWrapped(wire: Wire, plane: Plane): Face;
+    static planeFromFace(face: Face | TopoDS_Face, calculateNormalFn: () => Vector3d): Plane;
+    static makeFaceFromWires(wires: TopoDS_Wire[]): TopoDS_Face;
+    static fixFaceOrientation(face: Face | TopoDS_Face): Face;
+    static makeFaceWithHoles(outerWire: Wire, holes: Wire[]): Face;
+    static isPointInsideFace(point: Point, face: Face | TopoDS_Face): boolean;
+    static getFreeBoundsWire(compound: any): TopoDS_Wire | null;
+    static makeFaceFromPlane2(plane: gp_Pln): TopoDS_Face;
+    static makeFaceFromPlane(plane: gp_Pln): TopoDS_Face;
+    static makeFaceFromCylinder(cylinder: gp_Cylinder): TopoDS_Face;
+    static planeToFace(plane: Plane, center?: Point): Face;
+}

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

@@ -0,0 +1,252 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { Plane } from "../math/plane.js";
+import { Point } from "../math/point.js";
+import { Vector3d } from "../math/vector3d.js";
+import { Face } from "../common/face.js";
+export class FaceOps {
+    static getPlane(face) {
+        const rawFace = face instanceof Face ? face.getShape() : face;
+        return FaceOps.getPlaneRaw(rawFace);
+    }
+    static getPlaneRaw(face) {
+        console.log("Extracting plane from face...");
+        const oc = getOC();
+        const topoFace = oc.TopoDS.Face(face);
+        const adaptor = new oc.BRepAdaptor_Surface(topoFace, true);
+        const type = adaptor.GetType();
+        if (type !== oc.GeomAbs_SurfaceType.GeomAbs_Plane) {
+            adaptor.delete();
+            throw new Error("Face is not planar");
+        }
+        let pln = adaptor.Plane();
+        const ax3 = pln.Position();
+        const direction = ax3.Direction();
+        const location = ax3.Location();
+        const normal = FaceOps.calculateNormalRaw(face);
+        let loc = new Vector3d(location.X(), location.Y(), location.Z());
+        const xDir = ax3.XDirection();
+        const xDirection = new Vector3d(xDir.X(), xDir.Y(), xDir.Z());
+        const dot = loc.dot(normal);
+        const origin = normal.multiply(dot);
+        pln.delete();
+        adaptor.delete();
+        ax3.delete();
+        direction.delete();
+        location.delete();
+        const plane = new Plane(new Point(origin.x, origin.y, origin.z), xDirection, normal);
+        return plane;
+    }
+    static calculateNormal(face) {
+        const rawFace = face instanceof Face ? face.getShape() : face;
+        return FaceOps.calculateNormalRaw(rawFace);
+    }
+    static calculateNormalRaw(face) {
+        const oc = getOC();
+        const surface = oc.BRep_Tool.Surface(oc.TopoDS.Face(face));
+        const props = new oc.GeomLProp_SLProps(surface, 0, 0, 1, 1e-6);
+        let normal = props.Normal();
+        if (face.Orientation() === oc.TopAbs_Orientation.TopAbs_REVERSED) {
+            normal = normal.Reversed();
+        }
+        const result = Convert.toVector3dFromGpDir(normal);
+        surface.delete();
+        props.delete();
+        normal.delete();
+        return result;
+    }
+    static faceOnPlane(face, plane) {
+        const oc = getOC();
+        const faceAdaptor = new oc.BRepAdaptor_Surface(face, true);
+        const type = faceAdaptor.GetType();
+        if (type !== oc.GeomAbs_SurfaceType.GeomAbs_Plane) {
+            return false;
+        }
+        const facePlane = faceAdaptor.Plane();
+        const location = facePlane.Location();
+        if (!plane.Contains(location, oc.Precision.Confusion())) {
+            faceAdaptor.delete();
+            location.delete();
+            return false;
+        }
+        const axis1 = plane.Axis().Direction();
+        const axis2 = facePlane.Axis().Direction();
+        const dot = axis1.Dot(axis2);
+        faceAdaptor.delete();
+        location.delete();
+        return Math.abs(Math.abs(dot) - 1.0) < oc.Precision.Angular();
+    }
+    static faceOnPlaneWrapped(face, plane) {
+        const oc = getOC();
+        const [gpPln, dispose] = Convert.toGpPln(plane);
+        const result = FaceOps.faceOnPlane(face.getShape(), gpPln);
+        dispose();
+        return result;
+    }
+    static makeFace(wire) {
+        const oc = getOC();
+        console.log("Creating face from wire:", wire);
+        const MakeFaceFn = new oc.BRepBuilderAPI_MakeFace(wire, false);
+        if (MakeFaceFn.IsDone()) {
+            const face = MakeFaceFn.Face();
+            MakeFaceFn.delete();
+            return face;
+        }
+        else {
+            const err = MakeFaceFn.Error();
+            throw new Error("Failed to create face: ", err);
+        }
+    }
+    static makeFaceWrapped(wire) {
+        const rawFace = FaceOps.makeFace(wire.getShape());
+        return Face.fromTopoDSFace(rawFace);
+    }
+    static makeFaceOnPlane(wire, plane) {
+        const oc = getOC();
+        const MakeFaceFn = new oc.BRepBuilderAPI_MakeFace(plane);
+        MakeFaceFn.Add(wire);
+        if (MakeFaceFn.IsDone()) {
+            const face = MakeFaceFn.Face();
+            MakeFaceFn.delete();
+            return face;
+        }
+        else {
+            const err = MakeFaceFn.Error();
+            throw new Error("Failed to create face: ", err);
+        }
+    }
+    static makeFaceOnPlaneWrapped(wire, plane) {
+        const oc = getOC();
+        const [gpPln, dispose] = Convert.toGpPln(plane);
+        const rawFace = FaceOps.makeFaceOnPlane(oc.TopoDS.Wire(wire.getShape()), gpPln);
+        dispose();
+        return Face.fromTopoDSFace(rawFace);
+    }
+    static planeFromFace(face, calculateNormalFn) {
+        const rawFace = face instanceof Face ? face.getShape() : face;
+        const oc = getOC();
+        const topoFace = oc.TopoDS.Face(rawFace);
+        const surfaceAdaptor = new oc.BRepAdaptor_Surface(topoFace, true);
+        if (surfaceAdaptor.GetType() === oc.GeomAbs_SurfaceType.GeomAbs_Plane) {
+            console.log("Face is a plane, extracting axis");
+            const plane = surfaceAdaptor.Plane();
+            surfaceAdaptor.delete();
+            const normal = calculateNormalFn();
+            const xAxis = plane.XAxis();
+            const zAxis = plane.Axis();
+            const planeOrigin = plane.Location();
+            const xDir = xAxis.Direction();
+            const projectedOrigin = Plane.projectPoint(Point.origin(), Convert.toPoint(planeOrigin), normal);
+            const pln = new Plane(projectedOrigin, Convert.toVector3dFromGpDir(xDir), normal);
+            xDir.delete();
+            planeOrigin.delete();
+            xAxis.delete();
+            zAxis.delete();
+            plane.delete();
+            return pln;
+        }
+        surfaceAdaptor.delete();
+        throw new Error("Face does not represent a planar face");
+    }
+    static makeFaceFromWires(wires) {
+        const oc = getOC();
+        if (wires.length === 0) {
+            throw new Error("No wires provided to create a face.");
+        }
+        console.log("Creating face from wires:");
+        const MakeFaceFn = new oc.BRepBuilderAPI_MakeFace(wires[0], true);
+        console.log("Number of wires:", wires.length);
+        for (let i = 1; i < wires.length; i++) {
+            console.log("Adding wire:", wires[i]);
+            MakeFaceFn.Add(wires[i]);
+        }
+        if (MakeFaceFn.IsDone()) {
+            return MakeFaceFn.Face();
+        }
+        else {
+            throw new Error("Failed to create face from wires: " + MakeFaceFn.Error());
+        }
+    }
+    static fixFaceOrientation(face) {
+        const rawFace = face instanceof Face ? face.getShape() : face;
+        const oc = getOC();
+        const fixer = new oc.ShapeFix_Face(rawFace);
+        fixer.FixOrientation();
+        fixer.Perform();
+        const fixedFace = fixer.Face();
+        fixer.delete();
+        return Face.fromTopoDSFace(fixedFace);
+    }
+    static makeFaceWithHoles(outerWire, holes) {
+        const oc = getOC();
+        const faceMaker = new oc.BRepLib_MakeFace(outerWire.getShape(), false);
+        for (const hole of holes) {
+            faceMaker.Add(hole.getShape());
+        }
+        return Face.fromTopoDSFace(faceMaker.Face());
+    }
+    static isPointInsideFace(point, face) {
+        const rawFace = face instanceof Face ? face.getShape() : face;
+        const oc = getOC();
+        const [gpPnt, disposePnt] = Convert.toGpPnt(point);
+        const classifier = new oc.BRepClass_FaceClassifier();
+        classifier.Perform(rawFace, gpPnt, oc.Precision.Confusion(), true, oc.Precision.Confusion());
+        const state = classifier.State();
+        const isInside = state === oc.TopAbs_State.TopAbs_IN;
+        classifier.delete();
+        disposePnt();
+        return isInside;
+    }
+    static getFreeBoundsWire(compound) {
+        const oc = getOC();
+        const freeBounds = new oc.ShapeAnalysis_FreeBounds(compound, oc.Precision.Confusion(), true, true);
+        const closedWiresCompound = freeBounds.GetClosedWires();
+        const explorer = new oc.TopExp_Explorer(closedWiresCompound, oc.TopAbs_ShapeEnum.TopAbs_WIRE, oc.TopAbs_ShapeEnum.TopAbs_SHAPE);
+        let result = null;
+        if (explorer.More()) {
+            result = oc.TopoDS.Wire(explorer.Current());
+        }
+        explorer.delete();
+        freeBounds.delete();
+        return result;
+    }
+    static makeFaceFromPlane2(plane) {
+        const oc = getOC();
+        const faceMaker = new oc.BRepBuilderAPI_MakeFace(plane, -1000, 1000, -1000, 1000);
+        const face = faceMaker.Face();
+        faceMaker.delete();
+        return face;
+    }
+    static makeFaceFromPlane(plane) {
+        const oc = getOC();
+        const faceMaker = new oc.BRepBuilderAPI_MakeFace(plane);
+        const face = faceMaker.Face();
+        faceMaker.delete();
+        return face;
+    }
+    static makeFaceFromCylinder(cylinder) {
+        const oc = getOC();
+        const faceMaker = new oc.BRepBuilderAPI_MakeFace(cylinder);
+        if (!faceMaker.IsDone()) {
+            faceMaker.delete();
+            throw new Error("Failed to create face from cylinder");
+        }
+        const face = faceMaker.Face();
+        faceMaker.delete();
+        return face;
+    }
+    static planeToFace(plane, center) {
+        const oc = getOC();
+        const size = 100;
+        if (center) {
+            const translation = center.subtract(plane.origin);
+            plane = plane.translate(translation.x, translation.y, translation.z);
+        }
+        const [pln, dispose] = Convert.toGpPln(plane);
+        const faceMaker = new oc.BRepBuilderAPI_MakeFace(pln, -size, size, -size, size);
+        const face = faceMaker.Face();
+        faceMaker.delete();
+        dispose();
+        return Face.fromTopoDSFace(face);
+    }
+}

package/lib/dist/oc/face-props.d.ts

@@ -0,0 +1,12 @@
+import type { TopoDS_Shape } from "occjs-wrapper";
+export interface FaceProperties {
+    surfaceType: 'plane' | 'circle' | 'cylinder' | 'sphere' | 'torus' | 'cone' | 'other';
+    areaMm2?: number;
+    radius?: number;
+    majorRadius?: number;
+    minorRadius?: number;
+    halfAngleDeg?: number;
+}
+export declare class FaceProps {
+    static getProperties(face: TopoDS_Shape): FaceProperties;
+}