fluidcad 0.0.2

package/lib/dist/oc/convert.js

@@ -0,0 +1,231 @@
+import { getOC } from "./init.js";
+import { Point, Point2D } from "../math/point.js";
+import { Vector3d } from "../math/vector3d.js";
+import { Axis } from "../math/axis.js";
+import { Plane } from "../math/plane.js";
+import { CoordinateSystem } from "../math/coordinate-system.js";
+import { Matrix4 } from "../math/matrix4.js";
+import { Quaternion } from "../math/quaternion.js";
+export class Convert {
+    static toGpPnt(point) {
+        const oc = getOC();
+        const result = new oc.gp_Pnt(point.x, point.y, point.z);
+        return [result, () => result.delete()];
+    }
+    static toPoint(gpPnt, deleteSource = false) {
+        const result = new Point(gpPnt.X(), gpPnt.Y(), gpPnt.Z());
+        if (deleteSource) {
+            gpPnt.delete();
+        }
+        return result;
+    }
+    static toGpPnt2d(point) {
+        const oc = getOC();
+        const result = new oc.gp_Pnt2d(point.x, point.y);
+        return [result, () => result.delete()];
+    }
+    static toPoint2D(gpPnt2d, deleteSource = false) {
+        const result = new Point2D(gpPnt2d.X(), gpPnt2d.Y());
+        if (deleteSource) {
+            gpPnt2d.delete();
+        }
+        return result;
+    }
+    static toGpPntFrom2D(point) {
+        const oc = getOC();
+        const result = new oc.gp_Pnt(point.x, point.y, 0);
+        return [result, () => result.delete()];
+    }
+    static toPoint2DFromGpPnt(gpPnt, deleteSource = false) {
+        const result = new Point2D(gpPnt.X(), gpPnt.Y());
+        if (deleteSource) {
+            gpPnt.delete();
+        }
+        return result;
+    }
+    static toGpVec(vector) {
+        const oc = getOC();
+        const result = new oc.gp_Vec(vector.x, vector.y, vector.z);
+        return [result, () => result.delete()];
+    }
+    static toVector3d(gpVec, deleteSource = false) {
+        const result = new Vector3d(gpVec.X(), gpVec.Y(), gpVec.Z());
+        if (deleteSource) {
+            gpVec.delete();
+        }
+        return result;
+    }
+    static toGpDir(vector) {
+        const oc = getOC();
+        const result = new oc.gp_Dir(vector.x, vector.y, vector.z);
+        return [result, () => result.delete()];
+    }
+    static toVector3dFromGpDir(gpDir, deleteSource = false) {
+        const result = new Vector3d(gpDir.X(), gpDir.Y(), gpDir.Z());
+        if (deleteSource) {
+            gpDir.delete();
+        }
+        return result;
+    }
+    static toGpVecFromPoint(point) {
+        const oc = getOC();
+        const result = new oc.gp_Vec(point.x, point.y, point.z);
+        return [result, () => result.delete()];
+    }
+    static toVector3dFromGpPnt(gpPnt, deleteSource = false) {
+        const result = new Vector3d(gpPnt.X(), gpPnt.Y(), gpPnt.Z());
+        if (deleteSource) {
+            gpPnt.delete();
+        }
+        return result;
+    }
+    static toGpAx1(axis) {
+        const oc = getOC();
+        const [pnt, disposePnt] = Convert.toGpPnt(axis.origin);
+        const [dir, disposeDir] = Convert.toGpDir(axis.direction);
+        const result = new oc.gp_Ax1(pnt, dir);
+        return [result, () => { result.delete(); disposePnt(); disposeDir(); }];
+    }
+    static toAxis(gpAx1, deleteSource = false) {
+        const origin = Convert.toPoint(gpAx1.Location(), true);
+        const direction = Convert.toVector3dFromGpDir(gpAx1.Direction(), true);
+        if (deleteSource) {
+            gpAx1.delete();
+        }
+        return new Axis(origin, direction);
+    }
+    static toGpAx2(cs) {
+        const oc = getOC();
+        const [pnt, disposePnt] = Convert.toGpPnt(cs.origin);
+        const [mainDir, disposeMainDir] = Convert.toGpDir(cs.mainDirection);
+        const [xDir, disposeXDir] = Convert.toGpDir(cs.xDirection);
+        const result = new oc.gp_Ax2(pnt, mainDir, xDir);
+        return [result, () => { result.delete(); disposePnt(); disposeMainDir(); disposeXDir(); }];
+    }
+    static toCoordinateSystem(gpAx2, deleteSource = false) {
+        const origin = Convert.toPoint(gpAx2.Location(), true);
+        const mainDirection = Convert.toVector3dFromGpDir(gpAx2.Direction(), true);
+        const xDirection = Convert.toVector3dFromGpDir(gpAx2.XDirection(), true);
+        if (deleteSource) {
+            gpAx2.delete();
+        }
+        return new CoordinateSystem(origin, mainDirection, xDirection);
+    }
+    static toGpAx3(cs) {
+        const oc = getOC();
+        const [pnt, disposePnt] = Convert.toGpPnt(cs.origin);
+        const [mainDir, disposeMainDir] = Convert.toGpDir(cs.mainDirection);
+        const [xDir, disposeXDir] = Convert.toGpDir(cs.xDirection);
+        const result = new oc.gp_Ax3(pnt, mainDir, xDir);
+        return [result, () => { result.delete(); disposePnt(); disposeMainDir(); disposeXDir(); }];
+    }
+    static toCoordinateSystemFromGpAx3(gpAx3, deleteSource = false) {
+        const origin = Convert.toPoint(gpAx3.Location(), true);
+        const mainDirection = Convert.toVector3dFromGpDir(gpAx3.Direction(), true);
+        const xDirection = Convert.toVector3dFromGpDir(gpAx3.XDirection(), true);
+        if (deleteSource) {
+            gpAx3.delete();
+        }
+        return new CoordinateSystem(origin, mainDirection, xDirection);
+    }
+    static toGpPln(plane) {
+        const oc = getOC();
+        const [pnt, disposePnt] = Convert.toGpPnt(plane.origin);
+        const [normalDir, disposeNormalDir] = Convert.toGpDir(plane.normal);
+        const [xDir, disposeXDir] = Convert.toGpDir(plane.xDirection);
+        const ax3 = new oc.gp_Ax3(pnt, normalDir, xDir);
+        const result = new oc.gp_Pln(ax3);
+        return [result, () => { result.delete(); ax3.delete(); disposePnt(); disposeNormalDir(); disposeXDir(); }];
+    }
+    static toPlane(gpPln, deleteSource = false) {
+        const origin = Convert.toPoint(gpPln.Location(), true);
+        const xDirection = Convert.toVector3dFromGpDir(gpPln.XAxis().Direction(), true);
+        const normal = Convert.toVector3dFromGpDir(gpPln.Axis().Direction(), true);
+        if (deleteSource) {
+            gpPln.delete();
+        }
+        return new Plane(origin, xDirection, normal);
+    }
+    static toGpTrsf(matrix) {
+        const oc = getOC();
+        const trsf = new oc.gp_Trsf();
+        const m = matrix.elements;
+        trsf.SetValues(m[0], m[4], m[8], m[12], m[1], m[5], m[9], m[13], m[2], m[6], m[10], m[14]);
+        return [trsf, () => trsf.delete()];
+    }
+    static toMatrix4(gpTrsf, deleteSource = false) {
+        const elements = [
+            gpTrsf.Value(1, 1), gpTrsf.Value(2, 1), gpTrsf.Value(3, 1), 0,
+            gpTrsf.Value(1, 2), gpTrsf.Value(2, 2), gpTrsf.Value(3, 2), 0,
+            gpTrsf.Value(1, 3), gpTrsf.Value(2, 3), gpTrsf.Value(3, 3), 0,
+            gpTrsf.Value(1, 4), gpTrsf.Value(2, 4), gpTrsf.Value(3, 4), 1,
+        ];
+        if (deleteSource) {
+            gpTrsf.delete();
+        }
+        return new Matrix4(elements);
+    }
+    static toGpQuaternion(quaternion) {
+        const oc = getOC();
+        const result = new oc.gp_Quaternion(quaternion.x, quaternion.y, quaternion.z, quaternion.w);
+        return [result, () => result.delete()];
+    }
+    static toQuaternion(gpQuaternion, deleteSource = false) {
+        const result = new Quaternion(gpQuaternion.X(), gpQuaternion.Y(), gpQuaternion.Z(), gpQuaternion.W());
+        if (deleteSource) {
+            gpQuaternion.delete();
+        }
+        return result;
+    }
+    static toGpTrsfTranslation(dx, dy, dz) {
+        const oc = getOC();
+        const trsf = new oc.gp_Trsf();
+        const vec = new oc.gp_Vec(dx, dy, dz);
+        trsf.SetTranslation(vec);
+        return [trsf, () => { trsf.delete(); vec.delete(); }];
+    }
+    static toGpTrsfTranslationVec(vector) {
+        const oc = getOC();
+        const trsf = new oc.gp_Trsf();
+        const [vec, disposeVec] = Convert.toGpVec(vector);
+        trsf.SetTranslation(vec);
+        return [trsf, () => { trsf.delete(); disposeVec(); }];
+    }
+    static toGpTrsfRotation(axis, angle) {
+        const oc = getOC();
+        const trsf = new oc.gp_Trsf();
+        const [ax1, disposeAx1] = Convert.toGpAx1(axis);
+        trsf.SetRotation(ax1, angle);
+        return [trsf, () => { trsf.delete(); disposeAx1(); }];
+    }
+    static toGpTrsfScale(center, factor) {
+        const oc = getOC();
+        const trsf = new oc.gp_Trsf();
+        const [pnt, disposePnt] = Convert.toGpPnt(center);
+        trsf.SetScale(pnt, factor);
+        return [trsf, () => { trsf.delete(); disposePnt(); }];
+    }
+    static toGpTrsfMirrorPoint(point) {
+        const oc = getOC();
+        const trsf = new oc.gp_Trsf();
+        const [pnt, disposePnt] = Convert.toGpPnt(point);
+        trsf.SetMirror(pnt);
+        return [trsf, () => { trsf.delete(); disposePnt(); }];
+    }
+    static toGpTrsfMirrorAxis(axis) {
+        const oc = getOC();
+        const trsf = new oc.gp_Trsf();
+        const [ax1, disposeAx1] = Convert.toGpAx1(axis);
+        trsf.SetMirror(ax1);
+        return [trsf, () => { trsf.delete(); disposeAx1(); }];
+    }
+    static toGpTrsfMirrorPlane(plane) {
+        const oc = getOC();
+        const trsf = new oc.gp_Trsf();
+        const [pnt, disposePnt] = Convert.toGpPnt(plane.origin);
+        const [dir, disposeDir] = Convert.toGpDir(plane.normal);
+        const ax2 = new oc.gp_Ax2(pnt, dir);
+        trsf.SetMirror(ax2);
+        return [trsf, () => { trsf.delete(); ax2.delete(); disposePnt(); disposeDir(); }];
+    }
+}

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

@@ -0,0 +1,37 @@
+import type { TopoDS_Edge, TopoDS_Vertex } from "occjs-wrapper";
+import { Axis } from "../math/axis.js";
+import { Point } from "../math/point.js";
+import { Vector3d } from "../math/vector3d.js";
+import { Edge } from "../common/edge.js";
+import { Vertex } from "../common/vertex.js";
+export declare class EdgeOps {
+    static getFirstVertex(edge: Edge): Vertex;
+    static getLastVertex(edge: Edge): Vertex;
+    static edgeToAxis(edge: Edge): Axis;
+    static axisToEdge(axis: Axis): Edge;
+    static getVertexPoint(vertex: Vertex): Point;
+    static getEdgeMidPoint(edge: Edge): Point;
+    static reverseEdge(edge: Edge): Edge;
+    static getEdgeOrientation(edge: Edge): number;
+    static getEdgeTangentAtEnd(edge: Edge): Vector3d;
+    static makeEdgeFromCurveAndVertices(curve: any, v1: Vertex, v2: Vertex): Edge;
+    static getFirstVertexRaw(edge: TopoDS_Edge): TopoDS_Vertex;
+    static getLastVertexRaw(edge: TopoDS_Edge): TopoDS_Vertex;
+    static edgeToAxisRaw(edge: TopoDS_Edge): Axis;
+    static axisToEdgeRaw(axis: Axis): TopoDS_Edge;
+    static edgeMiddlePoint(edge: TopoDS_Edge): import("occjs-wrapper").gp_Pnt;
+    static getVertexPointRaw(vertex: TopoDS_Vertex): Point;
+    static getEdgeMidPointRaw(edge: TopoDS_Edge): Point;
+    static reverseEdgeRaw(edge: TopoDS_Edge): TopoDS_Edge;
+    static getEdgeOrientationRaw(edge: TopoDS_Edge): number;
+    static getEdgeTangentAtEndRaw(edge: TopoDS_Edge): Vector3d;
+    static makeEdgeFromCurveAndVerticesRaw(curve: any, v1: TopoDS_Vertex, v2: TopoDS_Vertex): TopoDS_Edge;
+    static splitEdges(edges: Edge[]): Edge[];
+    static splitEdgesWithMapping(edges: Edge[]): {
+        edges: Edge[];
+        sourceIndex: number[];
+    };
+    static findNearestEdgeIndex(edges: Edge[], point: Point, tolerance?: number): number;
+    static findNearestEdgeIndices(edges: Edge[], point: Point, tolerance?: number): number[];
+    static isClosed(edge: Edge): boolean;
+}

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

@@ -0,0 +1,306 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { Axis } from "../math/axis.js";
+import { Point } from "../math/point.js";
+import { Edge } from "../common/edge.js";
+import { Vertex } from "../common/vertex.js";
+import { Explorer } from "./explorer.js";
+export class EdgeOps {
+    // Wrapper methods (public API for external callers)
+    static getFirstVertex(edge) {
+        return Vertex.fromTopoDSVertex(EdgeOps.getFirstVertexRaw(edge.getShape()));
+    }
+    static getLastVertex(edge) {
+        return Vertex.fromTopoDSVertex(EdgeOps.getLastVertexRaw(edge.getShape()));
+    }
+    static edgeToAxis(edge) {
+        return EdgeOps.edgeToAxisRaw(edge.getShape());
+    }
+    static axisToEdge(axis) {
+        return Edge.fromTopoDSEdge(EdgeOps.axisToEdgeRaw(axis));
+    }
+    static getVertexPoint(vertex) {
+        return EdgeOps.getVertexPointRaw(vertex.getShape());
+    }
+    static getEdgeMidPoint(edge) {
+        return EdgeOps.getEdgeMidPointRaw(edge.getShape());
+    }
+    static reverseEdge(edge) {
+        return Edge.fromTopoDSEdge(EdgeOps.reverseEdgeRaw(edge.getShape()));
+    }
+    static getEdgeOrientation(edge) {
+        return EdgeOps.getEdgeOrientationRaw(edge.getShape());
+    }
+    static getEdgeTangentAtEnd(edge) {
+        return EdgeOps.getEdgeTangentAtEndRaw(edge.getShape());
+    }
+    static makeEdgeFromCurveAndVertices(curve, v1, v2) {
+        return Edge.fromTopoDSEdge(EdgeOps.makeEdgeFromCurveAndVerticesRaw(curve, v1.getShape(), v2.getShape()));
+    }
+    // Raw methods (for oc-internal and common/ use)
+    static getFirstVertexRaw(edge) {
+        const oc = getOC();
+        return oc.TopExp.FirstVertex(edge, true);
+    }
+    static getLastVertexRaw(edge) {
+        const oc = getOC();
+        return oc.TopExp.LastVertex(edge, true);
+    }
+    static edgeToAxisRaw(edge) {
+        const oc = getOC();
+        const topoEdge = oc.TopoDS.Edge(edge);
+        const curveAdaptor = new oc.BRepAdaptor_Curve(topoEdge);
+        if (curveAdaptor.GetType() === oc.GeomAbs_CurveType.GeomAbs_Line) {
+            const line = curveAdaptor.Line();
+            const axis = line.Position();
+            curveAdaptor.delete();
+            line.delete();
+            const axisLocation = axis.Location();
+            const axisDirection = axis.Direction();
+            const result = new Axis(Convert.toPoint(axisLocation), Convert.toVector3dFromGpDir(axisDirection));
+            axisLocation.delete();
+            axisDirection.delete();
+            axis.delete();
+            return result;
+        }
+        curveAdaptor.delete();
+        throw new Error("Edge does not represent a line and cannot be converted to an axis");
+    }
+    static axisToEdgeRaw(axis) {
+        const oc = getOC();
+        const length = 300;
+        const start = new oc.gp_Pnt(axis.origin.x + (axis.direction.x * -length), axis.origin.y + (axis.direction.y * -length), axis.origin.z + (axis.direction.z * -length));
+        const end = new oc.gp_Pnt(axis.origin.x + (axis.direction.x * length), axis.origin.y + (axis.direction.y * length), axis.origin.z + (axis.direction.z * length));
+        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(start, end);
+        const edge = edgeMaker.Edge();
+        edgeMaker.delete();
+        return edge;
+    }
+    static edgeMiddlePoint(edge) {
+        const oc = getOC();
+        const curveAdaptor = new oc.BRepAdaptor_Curve(oc.TopoDS.Edge(edge));
+        const curve = curveAdaptor.Curve();
+        const midParam = (curve.FirstParameter() + curve.LastParameter()) / 2.0;
+        const midPoint = curve.Value(midParam);
+        const result = new oc.gp_Pnt(midPoint.X(), midPoint.Y(), midPoint.Z());
+        curveAdaptor.delete();
+        return result;
+    }
+    static getVertexPointRaw(vertex) {
+        const oc = getOC();
+        const pnt = oc.BRep_Tool.Pnt(vertex);
+        const result = new Point(pnt.X(), pnt.Y(), pnt.Z());
+        pnt.delete();
+        return result;
+    }
+    static getEdgeMidPointRaw(edge) {
+        const oc = getOC();
+        const adaptor = new oc.BRepAdaptor_Curve(edge);
+        const mid = adaptor.Value((adaptor.FirstParameter() + adaptor.LastParameter()) / 2);
+        const result = new Point(mid.X(), mid.Y(), mid.Z());
+        mid.delete();
+        adaptor.delete();
+        return result;
+    }
+    static reverseEdgeRaw(edge) {
+        const oc = getOC();
+        return oc.TopoDS.Edge(edge.Reversed());
+    }
+    static getEdgeOrientationRaw(edge) {
+        const oc = getOC();
+        return edge.Orientation() === oc.TopAbs_Orientation.TopAbs_REVERSED ? -1 : 1;
+    }
+    static getEdgeTangentAtEndRaw(edge) {
+        const oc = getOC();
+        const isReversed = edge.Orientation() === oc.TopAbs_Orientation.TopAbs_REVERSED;
+        const curveHandle = oc.BRep_Tool.Curve(edge, 0, 1);
+        const curve = curveHandle.get();
+        const param = isReversed ? curve.FirstParameter() : curve.LastParameter();
+        const edgeSign = isReversed ? -1 : 1;
+        const tangentVec = new oc.gp_Vec();
+        const pnt = new oc.gp_Pnt();
+        curve.D1(param, pnt, tangentVec);
+        const result = Convert.toVector3d(tangentVec, true).multiply(edgeSign);
+        pnt.delete();
+        return result;
+    }
+    static makeEdgeFromCurveAndVerticesRaw(curve, v1, v2) {
+        const oc = getOC();
+        const handle = new oc.Handle_Geom_Curve(curve);
+        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(handle, v1, v2);
+        const edge = edgeMaker.Edge();
+        edgeMaker.delete();
+        handle.delete();
+        return edge;
+    }
+    static splitEdges(edges) {
+        return EdgeOps.splitEdgesWithMapping(edges).edges;
+    }
+    static splitEdgesWithMapping(edges) {
+        const oc = getOC();
+        const tol = 1e-7;
+        // Extract individual edges (expand wires passed at runtime)
+        const allEdges = [];
+        const inputIndex = []; // maps allEdges index → original edges[] index
+        for (let ei = 0; ei < edges.length; ei++) {
+            const shape = edges[ei].getShape();
+            if (shape.ShapeType() === oc.TopAbs_ShapeEnum.TopAbs_WIRE) {
+                const wireEdges = Explorer.findShapes(shape, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
+                for (const we of wireEdges) {
+                    allEdges.push(we);
+                    inputIndex.push(ei);
+                }
+            }
+            else {
+                allEdges.push(shape);
+                inputIndex.push(ei);
+            }
+        }
+        // Gather split parameters for each edge via IntTools_EdgeEdge
+        const splitParams = allEdges.map(() => []);
+        for (let i = 0; i < allEdges.length; i++) {
+            for (let j = i + 1; j < allEdges.length; j++) {
+                const tool = new oc.IntTools_EdgeEdge(allEdges[i], allEdges[j]);
+                tool.Perform();
+                if (tool.IsDone()) {
+                    const parts = tool.CommonParts();
+                    for (let k = 1; k <= parts.Length(); k++) {
+                        const cp = parts.Value(k);
+                        if (cp.Type() === oc.TopAbs_ShapeEnum.TopAbs_VERTEX) {
+                            splitParams[i].push(cp.VertexParameter1());
+                            splitParams[j].push(cp.VertexParameter2());
+                        }
+                    }
+                }
+                tool.delete();
+            }
+        }
+        // Split each edge at its collected intersection parameters
+        const result = [];
+        const sourceIndex = [];
+        for (let i = 0; i < allEdges.length; i++) {
+            const edge = allEdges[i];
+            const params = splitParams[i];
+            const srcIdx = inputIndex[i];
+            if (params.length === 0) {
+                result.push(Edge.fromTopoDSEdge(edge));
+                sourceIndex.push(srcIdx);
+                continue;
+            }
+            const adaptor = new oc.BRepAdaptor_Curve(edge);
+            const first = adaptor.FirstParameter();
+            const last = adaptor.LastParameter();
+            const isClosed = adaptor.IsClosed();
+            adaptor.delete();
+            // Deduplicate and sort
+            const sorted = [...params].sort((a, b) => a - b);
+            const unique = [];
+            for (const p of sorted) {
+                if (unique.length === 0 || Math.abs(p - unique[unique.length - 1]) > tol) {
+                    unique.push(p);
+                }
+            }
+            // For closed curves, deduplicate wrap-around (e.g. params near 0 and 2π are the same point)
+            if (isClosed && unique.length >= 2) {
+                const period = last - first;
+                if (Math.abs(unique[unique.length - 1] - unique[0] - period) < tol) {
+                    unique.pop();
+                }
+            }
+            // Filter out params at edge boundaries (skip for closed curves — their boundaries are the seam, not real endpoints)
+            const interior = isClosed
+                ? unique
+                : unique.filter(p => p > first + tol && p < last - tol);
+            if (interior.length === 0) {
+                result.push(Edge.fromTopoDSEdge(edge));
+                sourceIndex.push(srcIdx);
+                continue;
+            }
+            // Get the underlying curve for creating sub-edges
+            const curveHandle = oc.BRep_Tool.Curve(edge, 0, 1);
+            const curve = curveHandle.get();
+            const handle = new oc.Handle_Geom_Curve(curve);
+            if (isClosed && interior.length >= 2) {
+                // Closed curve: N split points → N arcs (no seam split)
+                const period = last - first;
+                for (let k = 0; k < interior.length; k++) {
+                    const u1 = interior[k];
+                    const u2 = k < interior.length - 1 ? interior[k + 1] : interior[0] + period;
+                    const maker = new oc.BRepBuilderAPI_MakeEdge(handle, u1, u2);
+                    if (maker.IsDone()) {
+                        result.push(Edge.fromTopoDSEdge(maker.Edge()));
+                        sourceIndex.push(srcIdx);
+                    }
+                    maker.delete();
+                }
+            }
+            else if (!isClosed) {
+                // Open curve: include edge endpoints as boundaries
+                const allParams = [first, ...interior, last];
+                for (let k = 0; k < allParams.length - 1; k++) {
+                    const maker = new oc.BRepBuilderAPI_MakeEdge(handle, allParams[k], allParams[k + 1]);
+                    if (maker.IsDone()) {
+                        result.push(Edge.fromTopoDSEdge(maker.Edge()));
+                        sourceIndex.push(srcIdx);
+                    }
+                    maker.delete();
+                }
+            }
+            else {
+                // Closed curve with < 2 split points: return as-is
+                result.push(Edge.fromTopoDSEdge(edge));
+                sourceIndex.push(srcIdx);
+            }
+            handle.delete();
+        }
+        return { edges: result, sourceIndex };
+    }
+    static findNearestEdgeIndex(edges, point, tolerance = -1) {
+        const indices = EdgeOps.findNearestEdgeIndices(edges, point, tolerance);
+        return indices.length > 0 ? indices[0] : -1;
+    }
+    static findNearestEdgeIndices(edges, point, tolerance = -1) {
+        const oc = getOC();
+        const DISTANCE_EPSILON = 1e-6;
+        const gpPnt = new oc.gp_Pnt(point.x, point.y, point.z);
+        const vertexMaker = new oc.BRepBuilderAPI_MakeVertex(gpPnt);
+        const vertexShape = vertexMaker.Shape();
+        gpPnt.delete();
+        let minDist = Infinity;
+        const distances = [];
+        const progress = new oc.Message_ProgressRange();
+        for (let i = 0; i < edges.length; i++) {
+            const distCalc = new oc.BRepExtrema_DistShapeShape(vertexShape, edges[i].getShape(), oc.Extrema_ExtFlag.Extrema_ExtFlag_MIN, oc.Extrema_ExtAlgo.Extrema_ExtAlgo_Grad, progress);
+            if (distCalc.IsDone()) {
+                const d = distCalc.Value();
+                distances[i] = d;
+                if (d < minDist) {
+                    minDist = d;
+                }
+            }
+            else {
+                distances[i] = Infinity;
+            }
+            distCalc.delete();
+        }
+        progress.delete();
+        vertexMaker.delete();
+        if (tolerance >= 0 && minDist > tolerance) {
+            return [];
+        }
+        const result = [];
+        for (let i = 0; i < edges.length; i++) {
+            if (distances[i] <= minDist + DISTANCE_EPSILON) {
+                result.push(i);
+            }
+        }
+        return result;
+    }
+    static isClosed(edge) {
+        const oc = getOC();
+        const adaptor = new oc.BRepAdaptor_Curve(edge.getShape());
+        const closed = adaptor.IsClosed();
+        adaptor.delete();
+        return closed;
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { TopoDS_Shape } from "occjs-wrapper";
+export interface EdgeProperties {
+    curveType: 'line' | 'circle' | 'arc' | 'ellipse' | 'other';
+    length?: number;
+    radius?: number;
+    majorRadius?: number;
+    minorRadius?: number;
+}
+export declare class EdgeProps {
+    static getProperties(edge: TopoDS_Shape): EdgeProperties;
+}

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

@@ -0,0 +1,45 @@
+import { getOC } from "./init.js";
+export class EdgeProps {
+    static getProperties(edge) {
+        const oc = getOC();
+        const ocEdge = oc.TopoDS.Edge(edge);
+        const adaptor = new oc.BRepAdaptor_Curve(ocEdge);
+        const curveType = adaptor.GetType();
+        const first = adaptor.FirstParameter();
+        const last = adaptor.LastParameter();
+        if (curveType === oc.GeomAbs_CurveType.GeomAbs_Line) {
+            const length = Math.abs(last - first);
+            adaptor.delete();
+            return { curveType: 'line', length };
+        }
+        if (curveType === oc.GeomAbs_CurveType.GeomAbs_Circle) {
+            const circle = adaptor.Circle();
+            const radius = circle.Radius();
+            circle.delete();
+            if (adaptor.IsClosed()) {
+                adaptor.delete();
+                return { curveType: 'circle', radius };
+            }
+            else {
+                const length = radius * Math.abs(last - first);
+                adaptor.delete();
+                return { curveType: 'arc', radius, length };
+            }
+        }
+        if (curveType === oc.GeomAbs_CurveType.GeomAbs_Ellipse) {
+            const ellipse = adaptor.Ellipse();
+            const majorRadius = ellipse.MajorRadius();
+            const minorRadius = ellipse.MinorRadius();
+            ellipse.delete();
+            adaptor.delete();
+            return { curveType: 'ellipse', majorRadius, minorRadius };
+        }
+        adaptor.delete();
+        // Fallback: use BRepGProp.LinearProperties for length
+        const linearProps = new oc.GProp_GProps();
+        oc.BRepGProp.LinearProperties(ocEdge, linearProps, false, false);
+        const length = linearProps.Mass();
+        linearProps.delete();
+        return { curveType: 'other', length };
+    }
+}

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

@@ -0,0 +1,44 @@
+import type { gp_Pln, gp_Vec, TopoDS_Edge, TopoDS_Shape } from "occjs-wrapper";
+import { Point } from "../math/point.js";
+import { Vector3d } from "../math/vector3d.js";
+import { Plane } from "../math/plane.js";
+import { Shape } from "../common/shape.js";
+import { Edge } from "../common/edge.js";
+export declare class EdgeQuery {
+    static isCircleEdge(edge: Shape, diameter?: number): boolean;
+    static isArcEdge(edge: Shape, radius?: number): boolean;
+    static isLineEdge(edge: Shape): boolean;
+    static isEdgeOnPlane(edge: Shape, plane: Plane): boolean;
+    static isEdgeParallelToPlane(edge: Shape, planeNormal: Vector3d): boolean;
+    static isEdgeAlignedWithNormal(edge: Shape, planeNormal: Vector3d): boolean;
+    static isEdgeClosedCurve(edge: Edge): boolean;
+    static getEdgeCurveType(edge: Edge): "line" | "circle" | "other";
+    static getEdgeCurveParams(edge: Edge): {
+        first: number;
+        last: number;
+    };
+    static sampleEdgeCurvePoint(edge: Edge, param: number): Point;
+    static getCircleDataFromEdge(edge: Edge): {
+        center: Point;
+        radius: number;
+        axisDirection: Vector3d;
+    };
+    static isCircleEdgeRaw(edge: TopoDS_Shape, diameter?: number): boolean;
+    static isArcEdgeRaw(edge: TopoDS_Shape, radius?: number): boolean;
+    static isLineEdgeRaw(edge: TopoDS_Shape): boolean;
+    static isEdgeOnPlaneRaw(edge: TopoDS_Shape, plane: gp_Pln): boolean;
+    static isEdgeParallelToPlaneRaw(edge: TopoDS_Shape, planeNormal: gp_Vec): boolean;
+    static isEdgeAlignedWithNormalRaw(edge: TopoDS_Shape, planeNormal: gp_Vec): boolean;
+    static isEdgeClosedCurveRaw(edge: TopoDS_Edge): boolean;
+    static getEdgeCurveTypeRaw(edge: TopoDS_Edge): "line" | "circle" | "other";
+    static getEdgeCurveParamsRaw(edge: TopoDS_Edge): {
+        first: number;
+        last: number;
+    };
+    static sampleEdgeCurvePointRaw(edge: TopoDS_Edge, param: number): Point;
+    static getCircleDataFromEdgeRaw(edge: TopoDS_Edge): {
+        center: Point;
+        radius: number;
+        axisDirection: Vector3d;
+    };
+}