fluidcad 0.0.2

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

@@ -0,0 +1,81 @@
+import { getOC } from "./init.js";
+import { Explorer } from "./explorer.js";
+export class FaceProps {
+    static getProperties(face) {
+        const oc = getOC();
+        const ocFace = oc.TopoDS.Face(face);
+        const adaptor = new oc.BRepAdaptor_Surface(ocFace, true);
+        const type = adaptor.GetType();
+        if (type === oc.GeomAbs_SurfaceType.GeomAbs_Plane) {
+            adaptor.delete();
+            // Check if it's a circular face (plane with a single closed circular edge)
+            const edges = Explorer.findShapes(ocFace, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
+            let isCircle = false;
+            let circleRadius = 0;
+            if (edges.length >= 1) {
+                let allCircular = true;
+                let closedCircleFound = false;
+                for (const e of edges) {
+                    const curveAdaptor = new oc.BRepAdaptor_Curve(oc.TopoDS.Edge(e));
+                    const curveType = curveAdaptor.GetType();
+                    if (curveType !== oc.GeomAbs_CurveType.GeomAbs_Circle) {
+                        allCircular = false;
+                        curveAdaptor.delete();
+                        break;
+                    }
+                    if (curveAdaptor.IsClosed()) {
+                        const circle = curveAdaptor.Circle();
+                        circleRadius = circle.Radius();
+                        circle.delete();
+                        closedCircleFound = true;
+                    }
+                    curveAdaptor.delete();
+                }
+                isCircle = allCircular && closedCircleFound;
+            }
+            if (isCircle) {
+                return { surfaceType: 'circle', radius: circleRadius };
+            }
+            const surfaceProps = new oc.GProp_GProps();
+            oc.BRepGProp.SurfaceProperties(ocFace, surfaceProps, false, false);
+            const areaMm2 = surfaceProps.Mass();
+            surfaceProps.delete();
+            return { surfaceType: 'plane', areaMm2 };
+        }
+        if (type === oc.GeomAbs_SurfaceType.GeomAbs_Cylinder) {
+            const cylinder = adaptor.Cylinder();
+            const radius = cylinder.Radius();
+            cylinder.delete();
+            adaptor.delete();
+            return { surfaceType: 'cylinder', radius };
+        }
+        if (type === oc.GeomAbs_SurfaceType.GeomAbs_Sphere) {
+            const sphere = adaptor.Sphere();
+            const radius = sphere.Radius();
+            sphere.delete();
+            adaptor.delete();
+            return { surfaceType: 'sphere', radius };
+        }
+        if (type === oc.GeomAbs_SurfaceType.GeomAbs_Torus) {
+            const torus = adaptor.Torus();
+            const majorRadius = torus.MajorRadius();
+            const minorRadius = torus.MinorRadius();
+            torus.delete();
+            adaptor.delete();
+            return { surfaceType: 'torus', majorRadius, minorRadius };
+        }
+        if (type === oc.GeomAbs_SurfaceType.GeomAbs_Cone) {
+            const cone = adaptor.Cone();
+            const halfAngleDeg = cone.SemiAngle() * (180 / Math.PI);
+            cone.delete();
+            adaptor.delete();
+            return { surfaceType: 'cone', halfAngleDeg };
+        }
+        adaptor.delete();
+        const surfaceProps = new oc.GProp_GProps();
+        oc.BRepGProp.SurfaceProperties(ocFace, surfaceProps, false, false);
+        const areaMm2 = surfaceProps.Mass();
+        surfaceProps.delete();
+        return { surfaceType: 'other', areaMm2 };
+    }
+}

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

@@ -0,0 +1,35 @@
+import type { gp_Pln, gp_Cylinder, TopoDS_Shape } from "occjs-wrapper";
+import { Vector3d } from "../math/vector3d.js";
+import { Plane } from "../math/plane.js";
+import { Shape } from "../common/shape.js";
+import { Face } from "../common/face.js";
+export declare class FaceQuery {
+    static isCircleFace(face: Shape, diameter?: number): boolean;
+    static isConeFace(face: Shape): boolean;
+    static isCylinderFace(face: Shape, diameter?: number): boolean;
+    static isCylinderCurveFace(face: Shape, diameter?: number): boolean;
+    static isFaceOnPlane(face: Shape, plane: Plane): boolean;
+    static isFaceParallelToPlane(face: Shape, plane: Plane): boolean;
+    static isPlanarFace(face: Shape): boolean;
+    static getSurfaceType(face: Shape): string;
+    static getSurfacePlane(face: Shape): Plane;
+    static areFacePlanesParallel(face1: Shape, face2: Shape): boolean;
+    static getSignedPlaneDistance(startFace: Shape, targetFace: Shape): number;
+    static findFarthestCornerDistanceFromFace(targetFace: Shape, sourceFace: Shape): number;
+    static makeInfinitePlanarFace(face: Shape, offset?: number, offsetDirection?: Vector3d): Face;
+    static makeInfiniteCylindricalFace(face: Shape, offset?: number): Face;
+    static isCircleFaceRaw(face: TopoDS_Shape, diameter?: number): boolean;
+    static isConeFaceRaw(face: TopoDS_Shape): boolean;
+    static isCylinderFaceRaw(face: TopoDS_Shape, diameter?: number): boolean;
+    static isCylinderCurveFaceRaw(face: TopoDS_Shape, diameter?: number): boolean;
+    static isFaceOnPlaneRaw(face: TopoDS_Shape, plane: gp_Pln): boolean;
+    static isFaceParallelToPlaneRaw(face: TopoDS_Shape, plane: gp_Pln): boolean;
+    static isPlanarFaceRaw(face: TopoDS_Shape): boolean;
+    static getSurfaceTypeRaw(face: TopoDS_Shape): string;
+    static getSurfaceAdaptorPlaneRaw(face: TopoDS_Shape): gp_Pln;
+    static getSurfaceAdaptorCylinderRaw(face: TopoDS_Shape): gp_Cylinder;
+    static findFarthestCornerDistanceRaw(face: TopoDS_Shape, plane: gp_Pln): number;
+    static arePlanesParallelRaw(plane1: gp_Pln, plane2: gp_Pln): boolean;
+    static findFaceByDistance(faces: Face[], plane: Plane, mode: 'first' | 'last'): Face | null;
+    static getSignedPlaneDistanceRaw(startPlane: gp_Pln, targetPlane: gp_Pln): number;
+}

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

@@ -0,0 +1,341 @@
+import { getOC } from "./init.js";
+import { Explorer } from "./explorer.js";
+import { FaceOps } from "./face-ops.js";
+import { Convert } from "./convert.js";
+import { Face } from "../common/face.js";
+export class FaceQuery {
+    // Wrapper methods (public API for external callers)
+    static isCircleFace(face, diameter) {
+        return FaceQuery.isCircleFaceRaw(face.getShape(), diameter);
+    }
+    static isConeFace(face) {
+        return FaceQuery.isConeFaceRaw(face.getShape());
+    }
+    static isCylinderFace(face, diameter) {
+        return FaceQuery.isCylinderFaceRaw(face.getShape(), diameter);
+    }
+    static isCylinderCurveFace(face, diameter) {
+        return FaceQuery.isCylinderCurveFaceRaw(face.getShape(), diameter);
+    }
+    static isFaceOnPlane(face, plane) {
+        const [gpPln, dispose] = Convert.toGpPln(plane);
+        const result = FaceQuery.isFaceOnPlaneRaw(face.getShape(), gpPln);
+        dispose();
+        return result;
+    }
+    static isFaceParallelToPlane(face, plane) {
+        const [gpPln, dispose] = Convert.toGpPln(plane);
+        const result = FaceQuery.isFaceParallelToPlaneRaw(face.getShape(), gpPln);
+        dispose();
+        return result;
+    }
+    static isPlanarFace(face) {
+        return FaceQuery.isPlanarFaceRaw(face.getShape());
+    }
+    static getSurfaceType(face) {
+        return FaceQuery.getSurfaceTypeRaw(face.getShape());
+    }
+    static getSurfacePlane(face) {
+        const gpPln = FaceQuery.getSurfaceAdaptorPlaneRaw(face.getShape());
+        const result = Convert.toPlane(gpPln);
+        gpPln.delete();
+        return result;
+    }
+    static areFacePlanesParallel(face1, face2) {
+        const plane1 = FaceQuery.getSurfaceAdaptorPlaneRaw(face1.getShape());
+        const plane2 = FaceQuery.getSurfaceAdaptorPlaneRaw(face2.getShape());
+        const result = FaceQuery.arePlanesParallelRaw(plane1, plane2);
+        plane1.delete();
+        plane2.delete();
+        return result;
+    }
+    static getSignedPlaneDistance(startFace, targetFace) {
+        const startPlane = FaceQuery.getSurfaceAdaptorPlaneRaw(startFace.getShape());
+        const targetPlane = FaceQuery.getSurfaceAdaptorPlaneRaw(targetFace.getShape());
+        const result = FaceQuery.getSignedPlaneDistanceRaw(startPlane, targetPlane);
+        startPlane.delete();
+        targetPlane.delete();
+        return result;
+    }
+    static findFarthestCornerDistanceFromFace(targetFace, sourceFace) {
+        const sourcePlane = FaceQuery.getSurfaceAdaptorPlaneRaw(sourceFace.getShape());
+        const result = FaceQuery.findFarthestCornerDistanceRaw(targetFace.getShape(), sourcePlane);
+        sourcePlane.delete();
+        return result;
+    }
+    static makeInfinitePlanarFace(face, offset, offsetDirection) {
+        const gpPln = FaceQuery.getSurfaceAdaptorPlaneRaw(face.getShape());
+        if (offset && offsetDirection) {
+            const [vec, disposeVec] = Convert.toGpVec(offsetDirection);
+            vec.Multiply(offset);
+            gpPln.Translate(vec);
+            disposeVec();
+        }
+        const rawFace = FaceOps.makeFaceFromPlane(gpPln);
+        gpPln.delete();
+        return Face.fromTopoDSFace(rawFace);
+    }
+    static makeInfiniteCylindricalFace(face, offset) {
+        const oc = getOC();
+        const cylinder = FaceQuery.getSurfaceAdaptorCylinderRaw(face.getShape());
+        const cylMaker = new oc.gce_MakeCylinder(cylinder, offset || 0);
+        const rawFace = FaceOps.makeFaceFromCylinder(cylMaker.Value());
+        cylinder.delete();
+        cylMaker.delete();
+        return Face.fromTopoDSFace(rawFace);
+    }
+    // Raw methods (for oc-internal and common/ use)
+    static isCircleFaceRaw(face, diameter) {
+        const oc = getOC();
+        const ocFace = oc.TopoDS.Face(face);
+        const faceAdaptor = new oc.BRepAdaptor_Surface(ocFace, true);
+        const type = faceAdaptor.GetType();
+        if (type !== oc.GeomAbs_SurfaceType.GeomAbs_Plane) {
+            faceAdaptor.delete();
+            return false;
+        }
+        faceAdaptor.delete();
+        const edges = Explorer.findShapes(ocFace, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
+        for (const e of edges) {
+            const edge = oc.TopoDS.Edge(e);
+            const curveAdaptor = new oc.BRepAdaptor_Curve(edge);
+            const curveType = curveAdaptor.GetType();
+            if (curveType !== oc.GeomAbs_CurveType.GeomAbs_Circle) {
+                curveAdaptor.delete();
+                return false;
+            }
+            if (curveAdaptor.IsClosed()) {
+                if (diameter === undefined) {
+                    curveAdaptor.delete();
+                    return true;
+                }
+                const circle = curveAdaptor.Circle();
+                const r = circle.Radius();
+                circle.delete();
+                curveAdaptor.delete();
+                return Math.abs(r - diameter / 2) <= oc.Precision.Confusion();
+            }
+            curveAdaptor.delete();
+        }
+        return false;
+    }
+    static isConeFaceRaw(face) {
+        const oc = getOC();
+        const ocFace = oc.TopoDS.Face(face);
+        const faceAdaptor = new oc.BRepAdaptor_Surface(ocFace, true);
+        const type = faceAdaptor.GetType();
+        faceAdaptor.delete();
+        return type === oc.GeomAbs_SurfaceType.GeomAbs_Cone;
+    }
+    static isCylinderFaceRaw(face, diameter) {
+        const oc = getOC();
+        const ocFace = oc.TopoDS.Face(face);
+        const faceAdaptor = new oc.BRepAdaptor_Surface(ocFace, true);
+        const type = faceAdaptor.GetType();
+        faceAdaptor.delete();
+        if (type !== oc.GeomAbs_SurfaceType.GeomAbs_Cylinder) {
+            return false;
+        }
+        const edges = Explorer.findShapes(ocFace, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
+        for (const edge of edges) {
+            const curveAdaptor = new oc.BRepAdaptor_Curve(oc.TopoDS.Edge(edge));
+            const curveType = curveAdaptor.GetType();
+            if (curveAdaptor.IsClosed() && curveType === oc.GeomAbs_CurveType.GeomAbs_Circle) {
+                if (diameter === undefined) {
+                    curveAdaptor.delete();
+                    return true;
+                }
+                const circle = curveAdaptor.Circle();
+                const r = circle.Radius();
+                circle.delete();
+                curveAdaptor.delete();
+                return Math.abs(r - diameter / 2) <= oc.Precision.Confusion();
+            }
+            curveAdaptor.delete();
+        }
+        return false;
+    }
+    static isCylinderCurveFaceRaw(face, diameter) {
+        const oc = getOC();
+        const ocFace = oc.TopoDS.Face(face);
+        const faceAdaptor = new oc.BRepAdaptor_Surface(ocFace, true);
+        const type = faceAdaptor.GetType();
+        faceAdaptor.delete();
+        if (type !== oc.GeomAbs_SurfaceType.GeomAbs_Cylinder) {
+            return false;
+        }
+        const edges = Explorer.findShapes(ocFace, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
+        for (const edge of edges) {
+            const curveAdaptor = new oc.BRepAdaptor_Curve(oc.TopoDS.Edge(edge));
+            const curveType = curveAdaptor.GetType();
+            if (curveType === oc.GeomAbs_CurveType.GeomAbs_Circle && !curveAdaptor.IsClosed()) {
+                if (diameter === undefined) {
+                    curveAdaptor.delete();
+                    return true;
+                }
+                const circle = curveAdaptor.Circle();
+                const r = circle.Radius();
+                circle.delete();
+                curveAdaptor.delete();
+                return Math.abs(r - diameter / 2) <= oc.Precision.Confusion();
+            }
+            curveAdaptor.delete();
+        }
+        return false;
+    }
+    static isFaceOnPlaneRaw(face, plane) {
+        const oc = getOC();
+        return FaceOps.faceOnPlane(oc.TopoDS.Face(face), plane);
+    }
+    static isFaceParallelToPlaneRaw(face, plane) {
+        const oc = getOC();
+        const ocFace = oc.TopoDS.Face(face);
+        const faceAdaptor = new oc.BRepAdaptor_Surface(ocFace, true);
+        const facePlane = faceAdaptor.Plane();
+        const faceAxis = facePlane.Axis();
+        const targetAxis = plane.Axis();
+        const faceNormal = faceAxis.Direction();
+        const targetNormal = targetAxis.Direction();
+        const result = faceNormal.IsParallel(targetNormal, oc.Precision.Angular());
+        faceNormal.delete();
+        targetNormal.delete();
+        faceAxis.delete();
+        targetAxis.delete();
+        facePlane.delete();
+        faceAdaptor.delete();
+        return result;
+    }
+    static isPlanarFaceRaw(face) {
+        const oc = getOC();
+        const ocFace = oc.TopoDS.Face(face);
+        const adaptor = new oc.BRepAdaptor_Surface(ocFace, true);
+        const result = adaptor.GetType() === oc.GeomAbs_SurfaceType.GeomAbs_Plane;
+        adaptor.delete();
+        return result;
+    }
+    static getSurfaceTypeRaw(face) {
+        const oc = getOC();
+        const ocFace = oc.TopoDS.Face(face);
+        const adaptor = new oc.BRepAdaptor_Surface(ocFace, true);
+        const type = adaptor.GetType();
+        adaptor.delete();
+        if (type === oc.GeomAbs_SurfaceType.GeomAbs_Plane)
+            return "plane";
+        if (type === oc.GeomAbs_SurfaceType.GeomAbs_Cylinder)
+            return "cylinder";
+        if (type === oc.GeomAbs_SurfaceType.GeomAbs_Cone)
+            return "cone";
+        if (type === oc.GeomAbs_SurfaceType.GeomAbs_Sphere)
+            return "sphere";
+        if (type === oc.GeomAbs_SurfaceType.GeomAbs_Torus)
+            return "torus";
+        return "other";
+    }
+    static getSurfaceAdaptorPlaneRaw(face) {
+        const oc = getOC();
+        const ocFace = oc.TopoDS.Face(face);
+        const adaptor = new oc.BRepAdaptor_Surface(ocFace, true);
+        const plane = adaptor.Plane();
+        adaptor.delete();
+        return plane;
+    }
+    static getSurfaceAdaptorCylinderRaw(face) {
+        const oc = getOC();
+        const ocFace = oc.TopoDS.Face(face);
+        const adaptor = new oc.BRepAdaptor_Surface(ocFace, true);
+        const cylinder = adaptor.Cylinder();
+        adaptor.delete();
+        return cylinder;
+    }
+    static findFarthestCornerDistanceRaw(face, plane) {
+        const oc = getOC();
+        const bbox = new oc.Bnd_Box();
+        oc.BRepBndLib.Add(face, bbox, true);
+        const minPnt = bbox.CornerMin();
+        const maxPnt = bbox.CornerMax();
+        bbox.delete();
+        const corners = [
+            new oc.gp_Pnt(minPnt.X(), minPnt.Y(), minPnt.Z()),
+            new oc.gp_Pnt(maxPnt.X(), minPnt.Y(), minPnt.Z()),
+            new oc.gp_Pnt(minPnt.X(), maxPnt.Y(), minPnt.Z()),
+            new oc.gp_Pnt(minPnt.X(), minPnt.Y(), maxPnt.Z()),
+            new oc.gp_Pnt(maxPnt.X(), maxPnt.Y(), minPnt.Z()),
+            new oc.gp_Pnt(maxPnt.X(), minPnt.Y(), maxPnt.Z()),
+            new oc.gp_Pnt(minPnt.X(), maxPnt.Y(), maxPnt.Z()),
+            new oc.gp_Pnt(maxPnt.X(), maxPnt.Y(), maxPnt.Z())
+        ];
+        const planeAxis = plane.Axis();
+        const planePoint = planeAxis.Location();
+        const planeNormal = planeAxis.Direction();
+        let maxDistance = 0;
+        for (const corner of corners) {
+            const vectorToPoint = new oc.gp_Vec(planePoint, corner);
+            const distance = vectorToPoint.Dot(new oc.gp_Vec(planeNormal));
+            if (!maxDistance || Math.abs(distance) > Math.abs(maxDistance)) {
+                maxDistance = distance;
+            }
+            vectorToPoint.delete();
+            corner.delete();
+        }
+        planeAxis.delete();
+        planePoint.delete();
+        planeNormal.delete();
+        return maxDistance;
+    }
+    static arePlanesParallelRaw(plane1, plane2) {
+        const oc = getOC();
+        const dir1 = plane1.Axis().Direction();
+        const dir2 = plane2.Axis().Direction();
+        const result = dir1.IsParallel(dir2, oc.Precision.Angular());
+        dir1.delete();
+        dir2.delete();
+        return result;
+    }
+    static findFaceByDistance(faces, plane, mode) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Confusion();
+        let bestFace = null;
+        let bestDistance = mode === 'first' ? Infinity : -Infinity;
+        for (const face of faces) {
+            const distance = plane.distanceToPoint(face.center());
+            if (distance < tolerance) {
+                continue;
+            }
+            if (mode === 'first' ? distance < bestDistance : distance > bestDistance) {
+                bestDistance = distance;
+                bestFace = face;
+            }
+        }
+        return bestFace;
+    }
+    static getSignedPlaneDistanceRaw(startPlane, targetPlane) {
+        const startPlanePosition = startPlane.Location();
+        const targetPlanePosition = targetPlane.Location();
+        let normalizedStart = Convert.toVector3dFromGpPnt(startPlanePosition);
+        if (normalizedStart.length() === 0) {
+            const normal = startPlane.Axis().Direction();
+            normalizedStart = Convert.toVector3dFromGpDir(normal).normalize();
+            normal.delete();
+        }
+        else {
+            normalizedStart = normalizedStart.normalize();
+        }
+        let normalizedTarget = Convert.toVector3dFromGpPnt(targetPlanePosition);
+        if (normalizedTarget.length() === 0) {
+            const normal = targetPlane.Axis().Direction();
+            normalizedTarget = Convert.toVector3dFromGpDir(normal).normalize();
+            normal.delete();
+        }
+        else {
+            normalizedTarget = normalizedTarget.normalize();
+        }
+        const dot = normalizedStart.dot(normalizedTarget);
+        let distance = startPlane.Distance(targetPlane);
+        if (dot < 0) {
+            distance = -distance;
+        }
+        startPlanePosition.delete();
+        targetPlanePosition.delete();
+        return distance;
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { gp_Pln, TopoDS_Wire } from "occjs-wrapper";
+import { Shape } from "../common/shape.js";
+import { Edge } from "../common/edge.js";
+import { Face } from "../common/face.js";
+import { Wire } from "../common/wire.js";
+import { Plane } from "../math/plane.js";
+export declare class FilletOps {
+    static makeFillet(solid: Shape, edges: Edge[], radius: number): Shape;
+    static makeChamfer(solid: Shape, edges: Edge[], distance: number): Shape;
+    static makeChamferTwoDistances(solid: Shape, edges: Edge[], distance1: number, distance2: number, faces: Face[], isAngle?: boolean): Shape;
+    static fillet2d(shape: Wire | Edge, plane: Plane, radius: number): Wire;
+    static fillet2dRaw(wire: TopoDS_Wire, plane: gp_Pln, radius: number): TopoDS_Wire;
+}

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

@@ -0,0 +1,153 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { Wire } from "../common/wire.js";
+import { ShapeFactory } from "../common/shape-factory.js";
+import { WireOps } from "./wire-ops.js";
+import { rad } from "../helpers/math-helpers.js";
+export class FilletOps {
+    static makeFillet(solid, edges, radius) {
+        const oc = getOC();
+        const maker = new oc.BRepFilletAPI_MakeFillet(solid.getShape(), oc.ChFi3d_FilletShape.ChFi3d_Rational);
+        for (const edge of edges) {
+            maker.Add(radius, oc.TopoDS.Edge(edge.getShape()));
+        }
+        const progress = new oc.Message_ProgressRange();
+        maker.Build(progress);
+        progress.delete();
+        if (!maker.IsDone()) {
+            maker.delete();
+            throw new Error("Failed to create fillet.");
+        }
+        const result = maker.Shape();
+        maker.delete();
+        return ShapeFactory.fromShape(result);
+    }
+    static makeChamfer(solid, edges, distance) {
+        const oc = getOC();
+        const maker = new oc.BRepFilletAPI_MakeChamfer(solid.getShape());
+        for (const edge of edges) {
+            maker.Add(distance, oc.TopoDS.Edge(edge.getShape()));
+        }
+        const progress = new oc.Message_ProgressRange();
+        maker.Build(progress);
+        progress.delete();
+        if (!maker.IsDone()) {
+            maker.delete();
+            throw new Error("Failed to create chamfer.");
+        }
+        const result = maker.Shape();
+        maker.delete();
+        return ShapeFactory.fromShape(result);
+    }
+    static makeChamferTwoDistances(solid, edges, distance1, distance2, faces, isAngle = false) {
+        const oc = getOC();
+        const maker = new oc.BRepFilletAPI_MakeChamfer(solid.getShape());
+        for (let i = 0; i < edges.length; i++) {
+            const face = faces[i];
+            if (!face) {
+                throw new Error("Chamfer: Failed to find common face for chamfer.");
+            }
+            if (isAngle) {
+                maker.AddDA(distance1, rad(distance2), oc.TopoDS.Edge(edges[i].getShape()), oc.TopoDS.Face(face.getShape()));
+            }
+            else {
+                maker.Add(distance1, distance2, oc.TopoDS.Edge(edges[i].getShape()), oc.TopoDS.Face(face.getShape()));
+            }
+        }
+        const progress = new oc.Message_ProgressRange();
+        maker.Build(progress);
+        progress.delete();
+        if (!maker.IsDone()) {
+            maker.delete();
+            throw new Error("Failed to create chamfer.");
+        }
+        const result = maker.Shape();
+        maker.delete();
+        return ShapeFactory.fromShape(result);
+    }
+    static fillet2d(shape, plane, radius) {
+        const wire = shape instanceof Wire ? shape : WireOps.makeWireFromEdges([shape]);
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const result = FilletOps.fillet2dRaw(wire.getShape(), pln, radius);
+        disposePln();
+        return Wire.fromTopoDSWire(result);
+    }
+    static fillet2dRaw(wire, plane, radius) {
+        const oc = getOC();
+        let currentWire = wire;
+        let cornerIndex = 0;
+        const isClosed = wire.Closed();
+        try {
+            while (true) {
+                const edges = [];
+                const explorer = new oc.BRepTools_WireExplorer(currentWire);
+                while (explorer.More()) {
+                    edges.push(oc.TopoDS.Edge(explorer.Current()));
+                    explorer.Next();
+                }
+                explorer.delete();
+                const maxCorners = isClosed ? edges.length : edges.length - 1;
+                if (cornerIndex >= maxCorners) {
+                    edges.forEach(e => e.delete());
+                    break;
+                }
+                const edge1 = edges[cornerIndex];
+                const edge2 = edges[(cornerIndex + 1) % edges.length];
+                const sharedVertex = oc.TopExp.LastVertex(edge1, false);
+                const sharedPoint = oc.BRep_Tool.Pnt(sharedVertex);
+                sharedVertex.delete();
+                const pairWireBuilder = new oc.BRepBuilderAPI_MakeWire(edge1, edge2);
+                const pairWire = pairWireBuilder.Wire();
+                const filletAPI = new oc.ChFi2d_FilletAPI(pairWire, plane);
+                const success = filletAPI.Perform(radius);
+                if (!success) {
+                    filletAPI.delete();
+                    pairWire.delete();
+                    pairWireBuilder.delete();
+                    edges.forEach(e => e.delete());
+                    cornerIndex++;
+                    continue;
+                }
+                const modEdge1 = new oc.TopoDS_Edge();
+                const modEdge2 = new oc.TopoDS_Edge();
+                const filletEdge = filletAPI.Result(sharedPoint, modEdge1, modEdge2, -1);
+                sharedPoint.delete();
+                filletAPI.delete();
+                pairWire.delete();
+                pairWireBuilder.delete();
+                const newWireBuilder = new oc.BRepBuilderAPI_MakeWire();
+                const nextIndex = (cornerIndex + 1) % edges.length;
+                for (let i = 0; i < edges.length; i++) {
+                    if (i === cornerIndex) {
+                        newWireBuilder.Add(modEdge1);
+                        newWireBuilder.Add(filletEdge);
+                    }
+                    else if (i === nextIndex) {
+                        newWireBuilder.Add(modEdge2);
+                    }
+                    else {
+                        newWireBuilder.Add(edges[i]);
+                    }
+                }
+                const prevWire = currentWire;
+                currentWire = newWireBuilder.Wire();
+                newWireBuilder.delete();
+                if (prevWire !== wire) {
+                    prevWire.delete();
+                }
+                modEdge1.delete();
+                modEdge2.delete();
+                filletEdge.delete();
+                edges.forEach(e => e.delete());
+                cornerIndex += 2;
+            }
+            return currentWire;
+        }
+        catch (e) {
+            if (currentWire !== wire) {
+                currentWire.delete();
+            }
+            throw e;
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { Geom_BezierCurve, Geom_Circle, Geom_TrimmedCurve, TopoDS_Edge } from "occjs-wrapper";
+import { Point, Point2D } from "../math/point.js";
+import { Vector3d } from "../math/vector3d.js";
+import { Edge } from "../common/edge.js";
+export declare class Geometry {
+    static makeSegment(p1: Point, p2: Point): Geom_TrimmedCurve;
+    static makeArcThreePoints(start: Point, end: Point, p3: Point): Geom_TrimmedCurve;
+    static makeArc(center: Point, radius: number, normal: Vector3d, start: Point, end: Point): Geom_TrimmedCurve;
+    static makeArcFromAngle(center: Point, radius: number, normal: Vector3d, start: Point, angle: number): Geom_TrimmedCurve;
+    static makeArcFromTangent(start: Point, end: Point, tangent: Vector3d): Geom_TrimmedCurve;
+    static makeCircle(center: Point, radius: number, normal: Vector3d): Geom_Circle;
+    static makeBezierCurve(poles: Point[]): Geom_BezierCurve;
+    static makeEdgeFromBezier(curve: Geom_BezierCurve): Edge;
+    static makeEdge(geometry: Geom_TrimmedCurve): Edge;
+    static makeEdgeFromCurve(curve: Geom_TrimmedCurve): Edge;
+    static makeEdgeFromCircle(circle: Geom_Circle): Edge;
+    static makeEdgeRaw(geometry: Geom_TrimmedCurve): TopoDS_Edge;
+    static makeEdgeFromCurveRaw(curve: Geom_TrimmedCurve): TopoDS_Edge;
+    static makeEdgeFromCircleRaw(circle: Geom_Circle): TopoDS_Edge;
+    static getPointOnCircle(center: Point2D, radius: number, angle: number): Point2D;
+    static getCircleCenter(point: Point2D, radius: number, angle: number): Point2D;
+}