fluidcad 0.0.35 → 0.0.37

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

@@ -0,0 +1,88 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { Edge } from "../common/edge.js";
+import { CoordinateSystem } from "../math/coordinate-system.js";
+/**
+ * Builds 3D helix edges with OCCT's TKHelix package. The analytic helix
+ * (`HelixGeom_HelixCurve`) is approximated as a single B-spline via
+ * `HelixGeom_Tools.ApprCurve3D`. Cylindrical and tapered (conical) helixes come
+ * from one uniform call — the taper is driven purely by the difference between
+ * the start and end radii over the axial range.
+ *
+ * NB: we deliberately do NOT use `HelixGeom_Tools.ApprHelix`, which hardcodes a
+ * 150-segment approximation budget. That is plenty for a cylinder (~3 segments
+ * per turn) but far too few for a many-turn tapered helix (~25+ per turn): the
+ * single-B-spline fit silently saturates the budget and oscillates wildly over
+ * the final turns while still reporting success (returnValue 0, theMaxError in
+ * the tens of mm). ApprCurve3D lets us scale the segment budget with the turn
+ * count so the adaptive fit can actually reach tolerance.
+ */
+export class HelixOps {
+    // B-spline approximation tolerance for the analytic helix, in mm.
+    static APPROX_TOLERANCE = 1e-4;
+    // Max B-spline degree for the fit (matches OCCT's ApprHelix default).
+    static MAX_DEGREE = 8;
+    // Segment budget per turn. A tapered helix needs ~25 segments/turn to reach
+    // APPROX_TOLERANCE; 40 leaves headroom. This is only a ceiling — the adaptive
+    // fit stops as soon as tolerance is met (a cylinder converges far below it).
+    static SEGMENTS_PER_TURN = 40;
+    // Floor (OCCT's ApprHelix default, ample for few-turn helixes) and ceiling on
+    // the per-build segment budget.
+    static MIN_SEGMENTS = 150;
+    static MAX_SEGMENTS = 4000;
+    /**
+     * Build a helix edge running `turns` full revolutions, climbing along
+     * `cs.mainDirection` from axial coordinate `zStart` to `zEnd` and starting at
+     * angle 0 (the `cs.xDirection` ray). `startRadius` is the radius at `zStart`;
+     * when `endRadius` differs the radius tapers linearly to it at `zEnd`, yielding
+     * a conical helix (`endRadius === startRadius` gives a constant-radius cylinder).
+     */
+    static makeHelix(cs, startRadius, endRadius, zStart, zEnd, turns) {
+        const oc = getOC();
+        const height = zEnd - zStart;
+        const pitch = height / turns;
+        const taperAngle = Math.atan2(endRadius - startRadius, height);
+        const lastAngle = 2 * Math.PI * turns;
+        const maxSegments = Math.min(HelixOps.MAX_SEGMENTS, Math.max(HelixOps.MIN_SEGMENTS, Math.ceil(turns) * HelixOps.SEGMENTS_PER_TURN));
+        // Build the analytic helix in the canonical frame (axis +Z through the
+        // origin, angle 0 on +X) and approximate it as one B-spline spanning every
+        // turn. ApprCurve3D (not ApprHelix) so the segment budget scales with turns.
+        const adaptor = new oc.HelixGeom_HelixCurve();
+        adaptor.Load(0, lastAngle, pitch, startRadius, taperAngle, false);
+        const appr = oc.HelixGeom_Tools.ApprCurve3D(adaptor, HelixOps.APPROX_TOLERANCE, oc.GeomAbs_Shape.GeomAbs_C2, maxSegments, HelixOps.MAX_DEGREE);
+        if (appr.returnValue !== 0) {
+            appr[Symbol.dispose]();
+            adaptor.delete();
+            throw new Error(`HelixOps: helix approximation failed (status ${appr.returnValue}).`);
+        }
+        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(appr.theBSpl);
+        const canonicalEdge = edgeMaker.Edge();
+        // Relocate the canonical helix into the target frame (copies the geometry, so
+        // the result is independent of the approximation envelope released below).
+        const placedEdge = HelixOps.placeInFrame(canonicalEdge, cs, zStart);
+        edgeMaker.delete();
+        canonicalEdge.delete();
+        appr[Symbol.dispose]();
+        adaptor.delete();
+        return Edge.fromTopoDSEdge(placedEdge);
+    }
+    /**
+     * Rigidly move an edge built in the canonical frame (axis +Z through the
+     * origin) so it sits in `cs`, lifted along `cs.mainDirection` by `zStart`.
+     */
+    static placeInFrame(edge, cs, zStart) {
+        const oc = getOC();
+        const origin = cs.origin.add(cs.mainDirection.normalize().multiply(zStart));
+        const placedCs = new CoordinateSystem(origin, cs.mainDirection, cs.xDirection);
+        const [ax3, disposeAx3] = Convert.toGpAx3(placedCs);
+        const trsf = new oc.gp_Trsf();
+        trsf.SetTransformation(ax3); // global coords → target frame …
+        trsf.Invert(); // … inverted places canonical geometry at the target frame
+        const transform = new oc.BRepBuilderAPI_Transform(edge, trsf, true);
+        const placedEdge = oc.TopoDS.Edge(transform.Shape());
+        transform.delete();
+        trsf.delete();
+        disposeAx3();
+        return placedEdge;
+    }
+}

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

@@ -1,4 +1,4 @@
-import type { TopoDS_Shape } from "occjs-wrapper";
+import type { TopoDS_Shape } from "ocjs-fluidcad";
 export type HitTestResult = {
     type: 'face';
     index: number;

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

@@ -22,4 +22,8 @@ export { OcIO } from "./io.js";
 export { ShapeProps } from './props.js';
 export { SweepOps } from "./sweep-ops.js";
 export { SectionOps } from "./section-ops.js";
+export { HelixOps } from "./helix-ops.js";
 export type { ShapeProperties } from './props.js';
+export { MeasureOps } from "./measure/measure-ops.js";
+export type { MeasureInput } from "./measure/measure-ops.js";
+export type { MeasureResult, MeasureEntityRef, MeasureEntityInfo, MeasureEntityKind, MeasureDistanceValue, MeasurePrimaryKey, MeasureVec, } from "./measure/measure-types.js";

package/lib/dist/oc/index.js

@@ -20,3 +20,5 @@ export { OcIO } from "./io.js";
 export { ShapeProps } from './props.js';
 export { SweepOps } from "./sweep-ops.js";
 export { SectionOps } from "./section-ops.js";
+export { HelixOps } from "./helix-ops.js";
+export { MeasureOps } from "./measure/measure-ops.js";

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

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

package/lib/dist/oc/init.js

@@ -1,4 +1,4 @@
-import initOpenCascade from "occjs-wrapper/node/multi-threaded";
+import initOpenCascade from "ocjs-fluidcad";
 let oc = null;
 export function getOC() {
     if (!oc) {

package/lib/dist/oc/intersection.js

@@ -20,7 +20,7 @@ export class ProjectionOps {
         let wirePlane;
         if (wirePlaneFinder.Found()) {
             const handle = wirePlaneFinder.Plane();
-            const geomPln = handle.get();
+            const geomPln = handle;
             const pln = geomPln.Pln();
             wirePlane = Convert.toPlane(pln);
             // geomPln.delete();

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

@@ -1,4 +1,4 @@
-import type { Handle_TDocStd_Document, TopoDS_Shape } from "occjs-wrapper";
+import type { TDocStd_Document, TopoDS_Shape } from "ocjs-fluidcad";
 import { Shape } from "../common/shape.js";
 import { Solid } from "../common/solid.js";
 import { Face } from "../common/face.js";
@@ -11,7 +11,7 @@ export declare class OcIO {
     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): {
+    static extractSolidsAndColors(docHandle: TDocStd_Document): {
         solids: Array<{
             shape: Solid;
             faceColors: Array<{
@@ -24,14 +24,14 @@ export declare class OcIO {
     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;
+        docHandle: TDocStd_Document;
         cleanup: () => void;
     };
-    static castToSolid(shape: TopoDS_Shape): import("occjs-wrapper").TopoDS_Solid;
+    static castToSolid(shape: TopoDS_Shape): import("ocjs-fluidcad").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): {
+    static makeCompoundRaw(shapes: TopoDS_Shape[]): import("ocjs-fluidcad").TopoDS_Compound;
+    static extractSolidsAndColorsRaw(docHandle: TDocStd_Document): {
         solids: Array<{
             shape: TopoDS_Shape;
             faceColors: Array<{

package/lib/dist/oc/io.js

@@ -1,4 +1,5 @@
 import { getOC } from "./init.js";
+import { ShapeHasher } from "./shape-hash.js";
 import { Explorer } from "./explorer.js";
 import { Solid } from "../common/solid.js";
 import { Face } from "../common/face.js";
@@ -79,7 +80,7 @@ export class OcIO {
     static readStepRaw(fileName, data) {
         const oc = getOC();
         const uint8 = new Uint8Array(data);
-        oc.FS.createDataFile("/", fileName, uint8, true, true, true);
+        oc.FS.writeFile("/" + fileName, uint8);
         const reader = new oc.STEPControl_Reader();
         const readResult = reader.ReadFile(fileName);
         if (readResult !== oc.IFSelect_ReturnStatus.IFSelect_RetDone) {
@@ -98,11 +99,11 @@ export class OcIO {
     static readStepXCAF(fileName, data) {
         const oc = getOC();
         const uint8 = new Uint8Array(data);
-        oc.FS.createDataFile("/", fileName, uint8, true, true, true);
+        oc.FS.writeFile("/" + fileName, uint8);
         const app = new oc.TDocStd_Application();
-        const docHandle = new oc.Handle_TDocStd_Document();
         const format = new oc.TCollection_ExtendedString('MDTV-XCAF');
-        app.NewDocument(format, docHandle);
+        const docHandle = new oc.TDocStd_Document(format);
+        app.InitDocument(docHandle);
         format.delete();
         const reader = new oc.STEPCAFControl_Reader();
         reader.SetColorMode(true);
@@ -132,7 +133,10 @@ export class OcIO {
         const cleanup = () => {
             reader.delete();
             oc.FS.unlink(fileName);
-            app.Close(docHandle);
+            // No app.Close(): the doc was created via `new TDocStd_Document` +
+            // InitDocument, which (in OCCT V8) does NOT open it in the application
+            // session. Close() therefore throws "cannot close a document that has not
+            // been opened"; deleting the handle releases it.
             docHandle.delete();
             app.delete();
         };
@@ -161,11 +165,11 @@ export class OcIO {
     }
     static extractSolidsAndColorsRaw(docHandle) {
         const oc = getOC();
-        const doc = docHandle.get();
+        const doc = docHandle;
         const shapeToolHandle = oc.XCAFDoc_DocumentTool.ShapeTool(doc.Main());
         const colorToolHandle = oc.XCAFDoc_DocumentTool.ColorTool(doc.Main());
-        const shapeTool = shapeToolHandle.get();
-        const colorTool = colorToolHandle.get();
+        const shapeTool = shapeToolHandle;
+        const colorTool = colorToolHandle;
         const surfType = oc.XCAFDoc_ColorType.XCAFDoc_ColorSurf;
         const colorLabels = new oc.TDF_LabelSequence();
         colorTool.GetColors(colorLabels);
@@ -173,6 +177,7 @@ export class OcIO {
         colorLabels.delete();
         const faceColorByHash = new Map();
         const solidColorByHash = new Map();
+        const shapeHasher = new ShapeHasher();
         const allLabels = new oc.TDF_LabelSequence();
         shapeTool.GetShapes(allLabels);
         let simpleShapeCount = 0;
@@ -184,15 +189,15 @@ export class OcIO {
             simpleShapeCount++;
             const shape = oc.XCAFDoc_ShapeTool.GetShape(label);
             const labelColor = new oc.Quantity_Color();
-            if (colorTool.GetColor(label, surfType, labelColor)) {
+            if (oc.XCAFDoc_ColorTool.GetColor(label, surfType, labelColor)) {
                 const hex = OcIO.rgbToHex(labelColor.Red(), labelColor.Green(), labelColor.Blue());
                 const labelSolids = OcIO.findSolidsRaw(shape);
                 for (const s of labelSolids) {
-                    solidColorByHash.set(s.HashCode(2147483647), hex);
+                    solidColorByHash.set(shapeHasher.key(s), hex);
                 }
                 const labelFaces = OcIO.findFacesRaw(shape);
                 for (const f of labelFaces) {
-                    faceColorByHash.set(f.HashCode(2147483647), hex);
+                    faceColorByHash.set(shapeHasher.key(f), hex);
                 }
             }
             labelColor.delete();
@@ -201,9 +206,9 @@ export class OcIO {
             for (let j = 1; j <= subLabels.Length(); j++) {
                 const subLabel = subLabels.Value(j);
                 const subColor = new oc.Quantity_Color();
-                if (colorTool.GetColor(subLabel, surfType, subColor)) {
+                if (oc.XCAFDoc_ColorTool.GetColor(subLabel, surfType, subColor)) {
                     const subShape = oc.XCAFDoc_ShapeTool.GetShape(subLabel);
-                    faceColorByHash.set(subShape.HashCode(2147483647), OcIO.rgbToHex(subColor.Red(), subColor.Green(), subColor.Blue()));
+                    faceColorByHash.set(shapeHasher.key(subShape), OcIO.rgbToHex(subColor.Red(), subColor.Green(), subColor.Blue()));
                     subShapeColorCount++;
                 }
                 subColor.delete();
@@ -224,7 +229,7 @@ export class OcIO {
                 const faceColors = [];
                 for (let fi = 0; fi < faces.length; fi++) {
                     const face = faces[fi];
-                    const color = OcIO.findFaceColor(face, solidShape, colorTool, shapeTool, oc, surfType, faceColorByHash, solidColorByHash);
+                    const color = OcIO.findFaceColor(face, solidShape, colorTool, shapeTool, oc, surfType, faceColorByHash, solidColorByHash, shapeHasher);
                     if (color) {
                         faceColors.push({ faceIndex: fi, color });
                     }
@@ -235,6 +240,7 @@ export class OcIO {
         freeLabels.delete();
         shapeToolHandle.delete();
         colorToolHandle.delete();
+        shapeHasher.delete();
         return { solids };
     }
     static writeStepRaw(compound, fileName) {
@@ -260,15 +266,15 @@ export class OcIO {
     static writeStepXCAF(solids, fileName) {
         const oc = getOC();
         const app = new oc.TDocStd_Application();
-        const docHandle = new oc.Handle_TDocStd_Document();
         const format = new oc.TCollection_ExtendedString('MDTV-XCAF');
-        app.NewDocument(format, docHandle);
+        const docHandle = new oc.TDocStd_Document(format);
+        app.InitDocument(docHandle);
         format.delete();
-        const doc = docHandle.get();
+        const doc = docHandle;
         const shapeToolHandle = oc.XCAFDoc_DocumentTool.ShapeTool(doc.Main());
         const colorToolHandle = oc.XCAFDoc_DocumentTool.ColorTool(doc.Main());
-        const shapeTool = shapeToolHandle.get();
-        const colorTool = colorToolHandle.get();
+        const shapeTool = shapeToolHandle;
+        const colorTool = colorToolHandle;
         const surfType = oc.XCAFDoc_ColorType.XCAFDoc_ColorSurf;
         // Use NewShape + SetShape (per OCC docs) instead of AddShape to avoid
         // compound wrapping that triggers multi-file assembly output.
@@ -286,7 +292,8 @@ export class OcIO {
         const cleanup = () => {
             shapeToolHandle.delete();
             colorToolHandle.delete();
-            app.Close(docHandle);
+            // No app.Close(): see readStepXCAF — an InitDocument'd (never opened) doc
+            // cannot be closed in OCCT V8; deleting the handle releases it.
             docHandle.delete();
         };
         const writer = new oc.STEPCAFControl_Writer();
@@ -364,8 +371,8 @@ export class OcIO {
             parseInt(h.substring(4, 6), 16) / 255,
         ];
     }
-    static findFaceColor(face, solidShape, colorTool, shapeTool, oc, surfType, faceColorByHash, solidColorByHash) {
-        const hashColor = faceColorByHash.get(face.HashCode(2147483647));
+    static findFaceColor(face, solidShape, colorTool, shapeTool, oc, surfType, faceColorByHash, solidColorByHash, shapeHasher) {
+        const hashColor = faceColorByHash.get(shapeHasher.key(face));
         if (hashColor)
             return hashColor;
         const color = new oc.Quantity_Color();
@@ -390,14 +397,14 @@ export class OcIO {
         identityLoc.delete();
         const faceLabel = new oc.TDF_Label();
         if (shapeTool.SearchUsingMap(face, faceLabel, true, true)) {
-            if (colorTool.GetColor(faceLabel, surfType, color)) {
+            if (oc.XCAFDoc_ColorTool.GetColor(faceLabel, surfType, color)) {
                 const hex = OcIO.rgbToHex(color.Red(), color.Green(), color.Blue());
                 color.delete();
                 return hex;
             }
         }
         color.delete();
-        const solidHash = solidColorByHash.get(solidShape.HashCode(2147483647));
+        const solidHash = solidColorByHash.get(shapeHasher.key(solidShape));
         if (solidHash)
             return solidHash;
         const solidColor = new oc.Quantity_Color();

package/lib/dist/oc/measure/classify.d.ts

@@ -0,0 +1,34 @@
+import type { TopoDS_Shape } from "ocjs-fluidcad";
+import type { MeasureEntityKind, MeasureVec } from "./measure-types.js";
+export type FaceForm = 'plane' | 'cylinder' | 'cone' | 'sphere' | 'torus' | 'surface';
+export type EdgeForm = 'line' | 'circle' | 'arc' | 'ellipse' | 'curve';
+/**
+ * Geometric summary of a selected face or edge, in plain JS values so all the
+ * pair math (angles, parallel distances, projections) runs without further
+ * OCCT calls.
+ */
+export interface ClassifiedEntity {
+    kind: MeasureEntityKind;
+    form: FaceForm | EdgeForm;
+    /** Unit direction characterizing the entity, or null when it has none. */
+    dir: MeasureVec | null;
+    /**
+     * How `dir` relates to the entity: a 'normal' is perpendicular to the entity
+     * (plane normal, circle-plane normal, torus axis), an 'axis' runs along it
+     * (line direction, cylinder/cone axis). Two entities lie parallel when
+     * normal∥normal, axis∥axis, or normal⊥axis.
+     */
+    dirKind: 'normal' | 'axis' | null;
+    /** A point on the entity's defining element (plane location, axis location). */
+    point: MeasureVec | null;
+    /** True geometric center (circle/arc/ellipse/sphere/torus), else null. */
+    center: MeasureVec | null;
+    /** Representative point on the entity (face area centroid, edge midpoint) used to anchor measurement lines. */
+    anchor: MeasureVec;
+    radius?: number;
+    area?: number;
+    length?: number;
+    shape: TopoDS_Shape;
+}
+export declare function classifyFace(shape: TopoDS_Shape): ClassifiedEntity;
+export declare function classifyEdge(shape: TopoDS_Shape): ClassifiedEntity;

package/lib/dist/oc/measure/classify.js

@@ -0,0 +1,246 @@
+import { getOC } from "../init.js";
+import { cross, dot, len, scale, sub } from "./vec.js";
+function vecFromPnt(p) {
+    const v = { x: p.X(), y: p.Y(), z: p.Z() };
+    p.delete();
+    return v;
+}
+function vecFromDir(d) {
+    const v = { x: d.X(), y: d.Y(), z: d.Z() };
+    d.delete();
+    return v;
+}
+function axisData(axis) {
+    const data = { point: vecFromPnt(axis.Location()), dir: vecFromDir(axis.Direction()) };
+    axis.delete();
+    return data;
+}
+// Booleans, text outlines, wraps and lofts often carry geometrically planar
+// faces / straight edges on fitted B-spline (or extruded-curve) geometry, so
+// the adaptor type alone misses them. These sampling fallbacks recover the
+// carrier plane/line numerically. (OCCT's GeomLib_IsPlanarSurface would do the
+// face check natively but is not in the current ocjs binding.)
+const CARRIER_FIT_TOL = 1e-6;
+const PLANAR_GRID_STEPS = 5;
+const STRAIGHT_EDGE_STEPS = 8;
+function detectPlanarSurface(adaptor) {
+    const u1 = adaptor.FirstUParameter();
+    const u2 = adaptor.LastUParameter();
+    const v1 = adaptor.FirstVParameter();
+    const v2 = adaptor.LastVParameter();
+    if (!isFinite(u1) || !isFinite(u2) || !isFinite(v1) || !isFinite(v2)) {
+        return null;
+    }
+    const points = [];
+    for (let i = 0; i <= PLANAR_GRID_STEPS; i++) {
+        for (let j = 0; j <= PLANAR_GRID_STEPS; j++) {
+            const p = adaptor.Value(u1 + ((u2 - u1) * i) / PLANAR_GRID_STEPS, v1 + ((v2 - v1) * j) / PLANAR_GRID_STEPS);
+            points.push({ x: p.X(), y: p.Y(), z: p.Z() });
+            p.delete();
+        }
+    }
+    const origin = points[0];
+    let span = points[0];
+    let spanDist = 0;
+    for (const p of points) {
+        const d = len(sub(p, origin));
+        if (d > spanDist) {
+            spanDist = d;
+            span = p;
+        }
+    }
+    if (spanDist < CARRIER_FIT_TOL) {
+        return null;
+    }
+    const e1 = scale(sub(span, origin), 1 / spanDist);
+    let normal = null;
+    let normalLen = 0;
+    for (const p of points) {
+        const n = cross(e1, sub(p, origin));
+        const nLen = len(n);
+        if (nLen > normalLen) {
+            normalLen = nLen;
+            normal = n;
+        }
+    }
+    if (!normal || normalLen < CARRIER_FIT_TOL * spanDist) {
+        return null;
+    }
+    const dir = scale(normal, 1 / normalLen);
+    const tol = CARRIER_FIT_TOL * (1 + spanDist);
+    for (const p of points) {
+        if (Math.abs(dot(sub(p, origin), dir)) > tol) {
+            return null;
+        }
+    }
+    return { point: origin, dir };
+}
+function detectStraightCurve(adaptor, first, last) {
+    const points = [];
+    for (let i = 0; i <= STRAIGHT_EDGE_STEPS; i++) {
+        const p = adaptor.Value(first + ((last - first) * i) / STRAIGHT_EDGE_STEPS);
+        points.push({ x: p.X(), y: p.Y(), z: p.Z() });
+        p.delete();
+    }
+    const chord = sub(points[points.length - 1], points[0]);
+    const chordLen = len(chord);
+    if (chordLen < CARRIER_FIT_TOL) {
+        return null;
+    }
+    const dir = scale(chord, 1 / chordLen);
+    const tol = CARRIER_FIT_TOL * (1 + chordLen);
+    for (const p of points) {
+        if (len(cross(sub(p, points[0]), dir)) > tol) {
+            return null;
+        }
+    }
+    return { point: points[0], dir };
+}
+export function classifyFace(shape) {
+    const oc = getOC();
+    const face = oc.TopoDS.Face(shape);
+    const props = new oc.GProp_GProps();
+    oc.BRepGProp.SurfaceProperties(face, props, false, false);
+    const area = props.Mass();
+    const anchor = vecFromPnt(props.CentreOfMass());
+    props.delete();
+    const result = {
+        kind: 'face',
+        form: 'surface',
+        dir: null,
+        dirKind: null,
+        point: null,
+        center: null,
+        anchor,
+        area,
+        shape,
+    };
+    const adaptor = new oc.BRepAdaptor_Surface(face, true);
+    const type = adaptor.GetType();
+    if (type === oc.GeomAbs_SurfaceType.GeomAbs_Plane) {
+        const plane = adaptor.Plane();
+        const { point, dir } = axisData(plane.Axis());
+        plane.delete();
+        result.form = 'plane';
+        result.point = point;
+        result.dir = dir;
+        result.dirKind = 'normal';
+    }
+    else if (type === oc.GeomAbs_SurfaceType.GeomAbs_Cylinder) {
+        const cylinder = adaptor.Cylinder();
+        const { point, dir } = axisData(cylinder.Axis());
+        result.radius = cylinder.Radius();
+        cylinder.delete();
+        result.form = 'cylinder';
+        result.point = point;
+        result.dir = dir;
+        result.dirKind = 'axis';
+    }
+    else if (type === oc.GeomAbs_SurfaceType.GeomAbs_Cone) {
+        const cone = adaptor.Cone();
+        const { point, dir } = axisData(cone.Axis());
+        cone.delete();
+        result.form = 'cone';
+        result.point = point;
+        result.dir = dir;
+        result.dirKind = 'axis';
+    }
+    else if (type === oc.GeomAbs_SurfaceType.GeomAbs_Sphere) {
+        const sphere = adaptor.Sphere();
+        const center = vecFromPnt(sphere.Location());
+        result.radius = sphere.Radius();
+        sphere.delete();
+        result.form = 'sphere';
+        result.point = center;
+        result.center = center;
+    }
+    else if (type === oc.GeomAbs_SurfaceType.GeomAbs_Torus) {
+        const torus = adaptor.Torus();
+        const { point, dir } = axisData(torus.Axis());
+        torus.delete();
+        result.form = 'torus';
+        result.point = point;
+        result.center = point;
+        result.dir = dir;
+        result.dirKind = 'normal';
+    }
+    else {
+        const planar = detectPlanarSurface(adaptor);
+        if (planar) {
+            result.form = 'plane';
+            result.point = planar.point;
+            result.dir = planar.dir;
+            result.dirKind = 'normal';
+        }
+    }
+    adaptor.delete();
+    return result;
+}
+export function classifyEdge(shape) {
+    const oc = getOC();
+    const edge = oc.TopoDS.Edge(shape);
+    const props = new oc.GProp_GProps();
+    oc.BRepGProp.LinearProperties(edge, props, false, false);
+    const length = props.Mass();
+    props.delete();
+    const adaptor = new oc.BRepAdaptor_Curve(edge);
+    const first = adaptor.FirstParameter();
+    const last = adaptor.LastParameter();
+    const anchor = vecFromPnt(adaptor.Value((first + last) / 2));
+    const result = {
+        kind: 'edge',
+        form: 'curve',
+        dir: null,
+        dirKind: null,
+        point: null,
+        center: null,
+        anchor,
+        length,
+        shape,
+    };
+    const type = adaptor.GetType();
+    if (type === oc.GeomAbs_CurveType.GeomAbs_Line) {
+        const line = adaptor.Line();
+        const point = vecFromPnt(line.Location());
+        const dir = vecFromDir(line.Direction());
+        line.delete();
+        result.form = 'line';
+        result.point = point;
+        result.dir = dir;
+        result.dirKind = 'axis';
+    }
+    else if (type === oc.GeomAbs_CurveType.GeomAbs_Circle) {
+        const circle = adaptor.Circle();
+        const center = vecFromPnt(circle.Location());
+        const { dir } = axisData(circle.Axis());
+        result.radius = circle.Radius();
+        circle.delete();
+        result.form = adaptor.IsClosed() ? 'circle' : 'arc';
+        result.point = center;
+        result.center = center;
+        result.dir = dir;
+        result.dirKind = 'normal';
+    }
+    else if (type === oc.GeomAbs_CurveType.GeomAbs_Ellipse) {
+        const ellipse = adaptor.Ellipse();
+        const center = vecFromPnt(ellipse.Location());
+        const { dir } = axisData(ellipse.Axis());
+        ellipse.delete();
+        result.form = 'ellipse';
+        result.point = center;
+        result.center = center;
+        result.dir = dir;
+        result.dirKind = 'normal';
+    }
+    else {
+        const straight = detectStraightCurve(adaptor, first, last);
+        if (straight) {
+            result.form = 'line';
+            result.point = straight.point;
+            result.dir = straight.dir;
+            result.dirKind = 'axis';
+        }
+    }
+    adaptor.delete();
+    return result;
+}

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

@@ -0,0 +1,9 @@
+import type { TopoDS_Shape } from "ocjs-fluidcad";
+import type { MeasureEntityRef, MeasureResult } from "./measure-types.js";
+export interface MeasureInput {
+    ref: MeasureEntityRef;
+    shape: TopoDS_Shape;
+}
+export declare class MeasureOps {
+    static measure(inputs: MeasureInput[]): MeasureResult;
+}