fluidcad 0.0.2

package/lib/dist/oc/measure.js

@@ -0,0 +1,256 @@
+import { getOC } from "./init.js";
+import { Explorer } from "./explorer.js";
+export class OccMeasure {
+    static compute(shapeA, typeA, indexA, shapeB, typeB, indexB) {
+        const oc = getOC();
+        // Extract sub-shapes by index
+        const subA = typeA === 'face'
+            ? Explorer.findShapes(shapeA, oc.TopAbs_ShapeEnum.TopAbs_FACE)[indexA]
+            : Explorer.findShapes(shapeA, oc.TopAbs_ShapeEnum.TopAbs_EDGE)[indexA];
+        const subB = typeB === 'face'
+            ? Explorer.findShapes(shapeB, oc.TopAbs_ShapeEnum.TopAbs_FACE)[indexB]
+            : Explorer.findShapes(shapeB, oc.TopAbs_ShapeEnum.TopAbs_EDGE)[indexB];
+        if (!subA || !subB) {
+            return null;
+        }
+        // Compute minimum distance and reference points via BRepExtrema
+        const progress = new oc.Message_ProgressRange();
+        const distCalc = new oc.BRepExtrema_DistShapeShape(subA, subB, oc.Extrema_ExtFlag.Extrema_ExtFlag_MIN, oc.Extrema_ExtAlgo.Extrema_ExtAlgo_Grad, progress);
+        let minDist = 0;
+        let refPointA = [0, 0, 0];
+        let refPointB = [0, 0, 0];
+        if (distCalc.IsDone() && distCalc.NbSolution() > 0) {
+            minDist = distCalc.Value();
+            const pA = distCalc.PointOnShape1(1);
+            const pB = distCalc.PointOnShape2(1);
+            refPointA = [pA.X(), pA.Y(), pA.Z()];
+            refPointB = [pB.X(), pB.Y(), pB.Z()];
+        }
+        distCalc.delete();
+        progress.delete();
+        const dx = refPointB[0] - refPointA[0];
+        const dy = refPointB[1] - refPointA[1];
+        const dz = refPointB[2] - refPointA[2];
+        const axisBreakdown = { dx, dy, dz };
+        const minDistEntry = {
+            label: 'Min Distance',
+            value: minDist,
+            unit: 'mm',
+            icon: 'distance',
+            axisBreakdown,
+        };
+        const others = [];
+        let headline = minDistEntry;
+        let headlineSet = false;
+        if (typeA === 'face' && typeB === 'face') {
+            const ocFaceA = oc.TopoDS.Face(subA);
+            const ocFaceB = oc.TopoDS.Face(subB);
+            const adaptorA = new oc.BRepAdaptor_Surface(ocFaceA, true);
+            const adaptorB = new oc.BRepAdaptor_Surface(ocFaceB, true);
+            const gTypeA = adaptorA.GetType();
+            const gTypeB = adaptorB.GetType();
+            if (gTypeA === oc.GeomAbs_SurfaceType.GeomAbs_Plane &&
+                gTypeB === oc.GeomAbs_SurfaceType.GeomAbs_Plane) {
+                // Plane + Plane
+                const planeA = adaptorA.Plane();
+                const planeB = adaptorB.Plane();
+                const axA = planeA.Axis();
+                const axB = planeB.Axis();
+                const dirA = axA.Direction();
+                const dirB = axB.Direction();
+                const nax = dirA.X(), nay = dirA.Y(), naz = dirA.Z();
+                const nbx = dirB.X(), nby = dirB.Y(), nbz = dirB.Z();
+                const dot = Math.abs(nax * nbx + nay * nby + naz * nbz);
+                if (dot > 0.9999) {
+                    // Parallel planes → face distance
+                    headline = {
+                        label: 'Face Distance',
+                        value: minDist,
+                        unit: 'mm',
+                        icon: 'distance',
+                        axisBreakdown,
+                    };
+                    headlineSet = true;
+                }
+                else {
+                    // Non-parallel → dihedral angle
+                    const angleRad = Math.acos(Math.min(1, dot));
+                    const angleDeg = angleRad * (180 / Math.PI);
+                    headline = {
+                        label: 'Dihedral Angle',
+                        value: angleDeg,
+                        unit: 'deg',
+                        icon: 'angle',
+                    };
+                    headlineSet = true;
+                    others.push(minDistEntry);
+                }
+                planeB.delete();
+                planeA.delete();
+            }
+            else if (gTypeA === oc.GeomAbs_SurfaceType.GeomAbs_Cylinder &&
+                gTypeB === oc.GeomAbs_SurfaceType.GeomAbs_Cylinder) {
+                // Cylinder + Cylinder
+                const cylA = adaptorA.Cylinder();
+                const cylB = adaptorB.Cylinder();
+                const axA = cylA.Axis();
+                const axB = cylB.Axis();
+                const dirA = axA.Direction();
+                const dirB = axB.Direction();
+                const adx = dirA.X(), ady = dirA.Y(), adz = dirA.Z();
+                const bdx = dirB.X(), bdy = dirB.Y(), bdz = dirB.Z();
+                const dot = Math.abs(adx * bdx + ady * bdy + adz * bdz);
+                const radA = cylA.Radius();
+                const radB = cylB.Radius();
+                if (dot > 0.9999) {
+                    // Parallel axes → compute axis distance
+                    const locA = cylA.Location();
+                    const locB = cylB.Location();
+                    const lax = locA.X(), lay = locA.Y(), laz = locA.Z();
+                    const lbx = locB.X(), lby = locB.Y(), lbz = locB.Z();
+                    const dv0 = lbx - lax, dv1 = lby - lay, dv2 = lbz - laz;
+                    const proj = dv0 * adx + dv1 * ady + dv2 * adz;
+                    const perpX = dv0 - proj * adx;
+                    const perpY = dv1 - proj * ady;
+                    const perpZ = dv2 - proj * adz;
+                    const axisDist = Math.sqrt(perpX * perpX + perpY * perpY + perpZ * perpZ);
+                    const radialGap = axisDist - radA - radB;
+                    headline = {
+                        label: 'Axis Distance',
+                        value: axisDist,
+                        unit: 'mm',
+                        icon: 'distance',
+                    };
+                    headlineSet = true;
+                    if (radialGap > -1e-6) {
+                        others.push({
+                            label: 'Radial Gap',
+                            value: Math.max(0, radialGap),
+                            unit: 'mm',
+                            icon: 'distance',
+                        });
+                    }
+                    others.push(minDistEntry);
+                }
+                else {
+                    others.push(minDistEntry);
+                }
+                cylA.delete();
+                cylB.delete();
+            }
+            else if (gTypeA === oc.GeomAbs_SurfaceType.GeomAbs_Sphere &&
+                gTypeB === oc.GeomAbs_SurfaceType.GeomAbs_Sphere) {
+                // Sphere + Sphere → center distance
+                const sphA = adaptorA.Sphere();
+                const sphB = adaptorB.Sphere();
+                const locA = sphA.Location();
+                const locB = sphB.Location();
+                const cx = locB.X() - locA.X();
+                const cy = locB.Y() - locA.Y();
+                const cz = locB.Z() - locA.Z();
+                const centerDist = Math.sqrt(cx * cx + cy * cy + cz * cz);
+                headline = {
+                    label: 'Center Distance',
+                    value: centerDist,
+                    unit: 'mm',
+                    icon: 'distance',
+                    axisBreakdown: { dx: cx, dy: cy, dz: cz },
+                };
+                headlineSet = true;
+                others.push(minDistEntry);
+                sphA.delete();
+                sphB.delete();
+            }
+            else {
+                // Mixed face types → min distance
+                others.push(minDistEntry);
+            }
+            adaptorA.delete();
+            adaptorB.delete();
+        }
+        else if (typeA === 'edge' && typeB === 'edge') {
+            const ocEdgeA = oc.TopoDS.Edge(subA);
+            const ocEdgeB = oc.TopoDS.Edge(subB);
+            const adaptorA = new oc.BRepAdaptor_Curve(ocEdgeA);
+            const adaptorB = new oc.BRepAdaptor_Curve(ocEdgeB);
+            const gTypeA = adaptorA.GetType();
+            const gTypeB = adaptorB.GetType();
+            if (gTypeA === oc.GeomAbs_CurveType.GeomAbs_Line &&
+                gTypeB === oc.GeomAbs_CurveType.GeomAbs_Line) {
+                // Line + Line
+                const linA = adaptorA.Line();
+                const linB = adaptorB.Line();
+                const dirA = linA.Direction();
+                const dirB = linB.Direction();
+                const adx = dirA.X(), ady = dirA.Y(), adz = dirA.Z();
+                const bdx = dirB.X(), bdy = dirB.Y(), bdz = dirB.Z();
+                const dot = Math.abs(adx * bdx + ady * bdy + adz * bdz);
+                linA.delete();
+                linB.delete();
+                if (dot > 0.9999) {
+                    // Parallel lines → parallel distance
+                    headline = {
+                        label: 'Parallel Distance',
+                        value: minDist,
+                        unit: 'mm',
+                        icon: 'distance',
+                        axisBreakdown,
+                    };
+                    headlineSet = true;
+                }
+                else {
+                    // Non-parallel → angle
+                    const angleRad = Math.acos(Math.min(1, dot));
+                    const angleDeg = angleRad * (180 / Math.PI);
+                    headline = {
+                        label: 'Angle',
+                        value: angleDeg,
+                        unit: 'deg',
+                        icon: 'angle',
+                    };
+                    headlineSet = true;
+                    others.push(minDistEntry);
+                }
+            }
+            else if (gTypeA === oc.GeomAbs_CurveType.GeomAbs_Circle &&
+                gTypeB === oc.GeomAbs_CurveType.GeomAbs_Circle) {
+                // Circle/Arc + Circle/Arc → center distance
+                const circA = adaptorA.Circle();
+                const circB = adaptorB.Circle();
+                const locA = circA.Location();
+                const locB = circB.Location();
+                const cx = locB.X() - locA.X();
+                const cy = locB.Y() - locA.Y();
+                const cz = locB.Z() - locA.Z();
+                const centerDist = Math.sqrt(cx * cx + cy * cy + cz * cz);
+                headline = {
+                    label: 'Center Distance',
+                    value: centerDist,
+                    unit: 'mm',
+                    icon: 'distance',
+                    axisBreakdown: { dx: cx, dy: cy, dz: cz },
+                };
+                headlineSet = true;
+                others.push(minDistEntry);
+                circA.delete();
+                circB.delete();
+            }
+            adaptorA.delete();
+            adaptorB.delete();
+        }
+        if (!headlineSet) {
+            headline = minDistEntry;
+        }
+        // Ensure minDistEntry is in others if it's not the headline
+        const othersHasMinDist = others.some(e => e === minDistEntry);
+        if (headline !== minDistEntry && !othersHasMinDist) {
+            others.push(minDistEntry);
+        }
+        return {
+            headline,
+            others,
+            refPointA,
+            refPointB,
+        };
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { TopoDS_Face, TopoDS_Shape } from "occjs-wrapper";
+import { Face } from "../common/face.js";
+import { Shape } from "../common/shape.js";
+export interface MeshData {
+    vertices: number[];
+    normals: number[];
+    indices: number[];
+    count?: number;
+}
+export declare class Mesh {
+    static triangulateFace(face: Face, vertexOffset?: number): MeshData | null;
+    static discretizeEdge(edge: Shape): MeshData;
+    static triangulateFaceRaw(face: TopoDS_Face, vertexOffset?: number): MeshData | null;
+    static discretizeEdgeRaw(edge: TopoDS_Shape): MeshData;
+}

package/lib/dist/oc/mesh.js

@@ -0,0 +1,110 @@
+import { getOC } from "./init.js";
+export class Mesh {
+    // Wrapper methods (public API for external callers)
+    static triangulateFace(face, vertexOffset = 0) {
+        return Mesh.triangulateFaceRaw(face.getShape(), vertexOffset);
+    }
+    static discretizeEdge(edge) {
+        return Mesh.discretizeEdgeRaw(edge.getShape());
+    }
+    // Raw methods (for oc-internal use)
+    static triangulateFaceRaw(face, vertexOffset = 0) {
+        const oc = getOC();
+        const vertices = [];
+        const normals = [];
+        const indices = [];
+        let inc;
+        try {
+            inc = new oc.BRepMesh_IncrementalMesh(face, 0.3, false, 0.3, true);
+        }
+        catch (e) {
+            console.error("Face mesh failed", e);
+            return null;
+        }
+        const aLocation = new oc.TopLoc_Location();
+        const myT = oc.BRep_Tool.Triangulation(face, aLocation, 0);
+        if (myT.IsNull()) {
+            aLocation.delete();
+            inc.delete();
+            throw new Error("No triangulation for face");
+        }
+        const pc = new oc.Poly_Connect(myT);
+        const triangulation = myT.get();
+        const nbNodes = triangulation.NbNodes();
+        for (let i = 1; i <= nbNodes; i++) {
+            const t1 = aLocation.Transformation();
+            const p = triangulation.Node(i);
+            const p1 = p.Transformed(t1);
+            vertices.push(p1.X(), p1.Y(), p1.Z());
+            p.delete();
+            p1.delete();
+            t1.delete();
+        }
+        const myNormal = new oc.TColgp_Array1OfDir(1, nbNodes);
+        oc.StdPrs_ToolTriangulatedShape.Normal(face, pc, myNormal);
+        for (let i = 1; i <= nbNodes; i++) {
+            const t1 = aLocation.Transformation();
+            const d1 = myNormal.Value(i);
+            const d = d1.Transformed(t1);
+            normals.push(d.X(), d.Y(), d.Z());
+            d1.delete();
+            d.delete();
+            t1.delete();
+        }
+        const orient = face.Orientation();
+        const triangles = triangulation.Triangles();
+        for (let nt = 1; nt <= triangulation.NbTriangles(); nt++) {
+            const t = triangles.Value(nt);
+            let n1 = t.Value(1) - 1;
+            let n2 = t.Value(2) - 1;
+            let n3 = t.Value(3) - 1;
+            if (orient !== oc.TopAbs_Orientation.TopAbs_FORWARD) {
+                [n1, n2] = [n2, n1];
+            }
+            indices.push(vertexOffset + n1, vertexOffset + n2, vertexOffset + n3);
+            t.delete();
+        }
+        pc.delete();
+        myNormal.delete();
+        triangles.delete();
+        myT.delete();
+        aLocation.delete();
+        inc.delete();
+        return { vertices, normals, indices, count: nbNodes };
+    }
+    static discretizeEdgeRaw(edge) {
+        const oc = getOC();
+        const ocEdge = oc.TopoDS.Edge(edge);
+        const adaptor = new oc.BRepAdaptor_Curve(ocEdge);
+        const type = adaptor.GetType();
+        const first = adaptor.FirstParameter();
+        const last = adaptor.LastParameter();
+        const points = [];
+        if (type === oc.GeomAbs_CurveType.GeomAbs_Line) {
+            const startPnt = adaptor.Value(first);
+            const endPnt = adaptor.Value(last);
+            points.push(startPnt.X(), startPnt.Y(), startPnt.Z());
+            points.push(endPnt.X(), endPnt.Y(), endPnt.Z());
+            startPnt.delete();
+            endPnt.delete();
+        }
+        else {
+            const numSegments = Math.max(1, Math.floor((last - first) / 0.01));
+            for (let i = 0; i <= numSegments; i++) {
+                const t = first + ((last - first) * i) / numSegments;
+                const pnt = adaptor.Value(t);
+                points.push(pnt.X(), pnt.Y(), pnt.Z());
+                pnt.delete();
+            }
+        }
+        adaptor.delete();
+        ocEdge.delete();
+        const pointCount = points.length / 3;
+        const indices = [];
+        for (let i = 0; i < pointCount - 1; i++) {
+            indices[2 * i] = i;
+            indices[2 * i + 1] = i + 1;
+        }
+        return { vertices: points, normals: [], indices };
+    }
+}

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

@@ -0,0 +1,5 @@
+import { Solid } from "../common/solid.js";
+export declare class Primitives {
+    static makeCylinder(radius: number, height: number): Solid;
+    static makeSphere(radius: number, angle: number): Solid;
+}

package/lib/dist/oc/primitives.js

@@ -0,0 +1,19 @@
+import { getOC } from "./init.js";
+import { Solid } from "../common/solid.js";
+import { Explorer } from "./explorer.js";
+export class Primitives {
+    static makeCylinder(radius, height) {
+        const oc = getOC();
+        const cylinderMaker = new oc.BRepPrimAPI_MakeCylinder(radius, height);
+        const shape = cylinderMaker.Shape();
+        cylinderMaker.delete();
+        return Solid.fromTopoDSSolid(Explorer.toSolid(shape));
+    }
+    static makeSphere(radius, angle) {
+        const oc = getOC();
+        const sphereMaker = new oc.BRepPrimAPI_MakeSphere(radius, angle);
+        const sphere = sphereMaker.Shape();
+        sphereMaker.delete();
+        return Solid.fromTopoDSSolid(Explorer.toSolid(sphere));
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { TopoDS_Shape } from "occjs-wrapper";
+export interface ShapeProperties {
+    volumeMm3: number;
+    surfaceAreaMm2: number;
+    centroid: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+export declare class ShapeProps {
+    static getProperties(shape: TopoDS_Shape): ShapeProperties;
+}

package/lib/dist/oc/props.js

@@ -0,0 +1,18 @@
+import { getOC } from "./init.js";
+export class ShapeProps {
+    static getProperties(shape) {
+        const oc = getOC();
+        const volumeProps = new oc.GProp_GProps();
+        oc.BRepGProp.VolumeProperties(shape, volumeProps, false, false, false);
+        const volumeMm3 = volumeProps.Mass();
+        const cog = volumeProps.CentreOfMass();
+        const centroid = { x: cog.X(), y: cog.Y(), z: cog.Z() };
+        cog.delete();
+        volumeProps.delete();
+        const surfaceProps = new oc.GProp_GProps();
+        oc.BRepGProp.SurfaceProperties(shape, surfaceProps, false, false);
+        const surfaceAreaMm2 = surfaceProps.Mass();
+        surfaceProps.delete();
+        return { volumeMm3, surfaceAreaMm2, centroid };
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { TopTools_ListOfShape, TopoDS_Edge, TopoDS_Face, TopoDS_Shape, TopoDS_Solid } from "occjs-wrapper";
+import { Matrix4 } from "../math/matrix4.js";
+import { Vector3d } from "../math/vector3d.js";
+import { Shape } from "../common/shape.js";
+import { Face } from "../common/face.js";
+import { Solid } from "../common/solid.js";
+import { BoundingBox } from "../helpers/types.js";
+import { Axis } from "../math/axis.js";
+export declare class ShapeOps {
+    static transform(shape: Shape, matrix: Matrix4): Shape;
+    static getBoundingBox(shape: Shape | TopoDS_Shape): BoundingBox;
+    static getBoundingBoxRaw(shape: TopoDS_Shape): BoundingBox;
+    static makeCompound(shapes: Shape[]): Shape;
+    static makeCompoundRaw(shapes: TopoDS_Shape[]): import("occjs-wrapper").TopoDS_Compound;
+    static cleanShape(shape: Shape): Shape;
+    static cleanShapeRaw(shape: TopoDS_Shape): TopoDS_Shape;
+    static getSolidOutwardNormal(face: Face, solid: Solid): Vector3d;
+    static getSolidOutwardNormalRaw(face: TopoDS_Face, solid: TopoDS_Solid): Vector3d;
+    static mirrorShape(shape: Shape, mirrorPoint: {
+        x: number;
+        y: number;
+        z: number;
+    }): Shape;
+    static mirrorShapeRaw(shape: TopoDS_Shape, mirrorPoint: {
+        x: number;
+        y: number;
+        z: number;
+    }): TopoDS_Shape;
+    static translateShape(shape: Shape, direction: Vector3d): Shape;
+    static translateShapeRaw(shape: TopoDS_Shape, direction: Vector3d): TopoDS_Shape;
+    static rotateShape(shape: TopoDS_Shape, axis: Axis, angle: number): TopoDS_Shape;
+    static shapeListToArray(list: TopTools_ListOfShape): TopoDS_Shape[];
+    static edgeMiddlePoint(edge: TopoDS_Edge): import("occjs-wrapper").gp_Pnt;
+}

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

@@ -0,0 +1,208 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { Vector3d } from "../math/vector3d.js";
+import { Shape } from "../common/shape.js";
+import { ShapeFactory } from "../common/shape-factory.js";
+export class ShapeOps {
+    static transform(shape, matrix) {
+        const oc = getOC();
+        const [trsf, disposeTrsf] = Convert.toGpTrsf(matrix);
+        const transformer = new oc.BRepBuilderAPI_Transform(trsf);
+        transformer.Perform(shape.getShape(), true);
+        const raw = transformer.Shape();
+        const transformed = ShapeFactory.fromShape(raw);
+        if (shape.hasColors()) {
+            const sourceFaces = shape.getSubShapes("face");
+            for (const sourceFace of sourceFaces) {
+                const faceColor = shape.getColor(sourceFace.getShape());
+                if (faceColor) {
+                    const modifiedFace = transformer.ModifiedShape(sourceFace.getShape());
+                    transformed.setColor(modifiedFace, faceColor);
+                }
+            }
+        }
+        if (shape.isMetaShape()) {
+            transformed.markAsMetaShape(shape.metaType);
+        }
+        if (shape.isGuideShape()) {
+            transformed.markAsGuide();
+        }
+        transformer.delete();
+        disposeTrsf();
+        return transformed;
+    }
+    static getBoundingBox(shape) {
+        const raw = shape instanceof Shape ? shape.getShape() : shape;
+        return ShapeOps.getBoundingBoxRaw(raw);
+    }
+    static getBoundingBoxRaw(shape) {
+        const oc = getOC();
+        const bbox = new oc.Bnd_Box();
+        oc.BRepBndLib.Add(shape, bbox, true);
+        const minPnt = bbox.CornerMin();
+        const maxPnt = bbox.CornerMax();
+        bbox.delete();
+        return {
+            minX: minPnt.X(),
+            minY: minPnt.Y(),
+            minZ: minPnt.Z(),
+            maxX: maxPnt.X(),
+            maxY: maxPnt.Y(),
+            maxZ: maxPnt.Z(),
+            centerX: (minPnt.X() + maxPnt.X()) / 2,
+            centerY: (minPnt.Y() + maxPnt.Y()) / 2,
+            centerZ: (minPnt.Z() + maxPnt.Z()) / 2,
+        };
+    }
+    static makeCompound(shapes) {
+        const raw = ShapeOps.makeCompoundRaw(shapes.map(s => s.getShape()));
+        return ShapeFactory.fromShape(raw);
+    }
+    static makeCompoundRaw(shapes) {
+        const oc = getOC();
+        const compoundBuilder = new oc.BRep_Builder();
+        const compound = new oc.TopoDS_Compound();
+        compoundBuilder.MakeCompound(compound);
+        for (const shape of shapes) {
+            compoundBuilder.Add(compound, shape);
+        }
+        return compound;
+    }
+    static cleanShape(shape) {
+        return ShapeFactory.fromShape(ShapeOps.cleanShapeRaw(shape.getShape()));
+    }
+    static cleanShapeRaw(shape) {
+        const oc = getOC();
+        // Full unification: merge redundant edges AND co-surface faces
+        const unify = new oc.ShapeUpgrade_UnifySameDomain(shape, false, true, false);
+        unify.Build();
+        let cleaned = unify.Shape();
+        unify.delete();
+        // Validate — UnifySameDomain can corrupt periodic surfaces (e.g. cylinders)
+        const checker = new oc.BRepCheck_Analyzer(cleaned, true, true);
+        if (checker.IsValid()) {
+            checker.delete();
+            return cleaned;
+        }
+        checker.delete();
+        // Repair with ShapeFix_Shape (fixes seam edges, wire orientation, SameParameter)
+        const fixer = new oc.ShapeFix_Shape(cleaned);
+        const progress = new oc.Message_ProgressRange();
+        fixer.Perform(progress);
+        const fixed = fixer.Shape();
+        fixer.delete();
+        progress.delete();
+        return fixed;
+    }
+    static getSolidOutwardNormal(face, solid) {
+        return ShapeOps.getSolidOutwardNormalRaw(face.getShape(), solid.getShape());
+    }
+    static getSolidOutwardNormalRaw(face, solid) {
+        const oc = getOC();
+        const surfaceAdaptor = new oc.BRepAdaptor_Surface(face, true);
+        const type = surfaceAdaptor.GetType();
+        if (type !== oc.GeomAbs_SurfaceType.GeomAbs_Plane) {
+            surfaceAdaptor.delete();
+            throw new Error("Non-planar faces not supported for normal calculation");
+        }
+        const uFirst = surfaceAdaptor.FirstUParameter();
+        const uLast = surfaceAdaptor.LastUParameter();
+        const vFirst = surfaceAdaptor.FirstVParameter();
+        const vLast = surfaceAdaptor.LastVParameter();
+        const u = (uFirst + uLast) / 2.0;
+        const v = (vFirst + vLast) / 2.0;
+        const testPoint = new oc.gp_Pnt();
+        const du = new oc.gp_Vec();
+        const dv = new oc.gp_Vec();
+        surfaceAdaptor.D1(u, v, testPoint, du, dv);
+        const geometricNormal = surfaceAdaptor.Plane().Position().Direction();
+        if (face.Orientation() === oc.TopAbs_Orientation.TopAbs_REVERSED) {
+            geometricNormal.Reverse();
+        }
+        const offset = 1e-6;
+        const testPointOffset = new oc.gp_Pnt(testPoint.X() + geometricNormal.X() * offset, testPoint.Y() + geometricNormal.Y() * offset, testPoint.Z() + geometricNormal.Z() * offset);
+        const classifier = new oc.BRepClass3d_SolidClassifier(solid, testPointOffset, oc.Precision.Confusion());
+        const state = classifier.State();
+        let result;
+        if (state === oc.TopAbs_State.TopAbs_IN) {
+            result = new Vector3d(-geometricNormal.X(), -geometricNormal.Y(), -geometricNormal.Z());
+        }
+        else {
+            result = new Vector3d(geometricNormal.X(), geometricNormal.Y(), geometricNormal.Z());
+        }
+        classifier.delete();
+        testPointOffset.delete();
+        geometricNormal.delete();
+        du.delete();
+        dv.delete();
+        testPoint.delete();
+        surfaceAdaptor.delete();
+        return result;
+    }
+    static mirrorShape(shape, mirrorPoint) {
+        const result = ShapeOps.mirrorShapeRaw(shape.getShape(), mirrorPoint);
+        return ShapeFactory.fromShape(result);
+    }
+    static mirrorShapeRaw(shape, mirrorPoint) {
+        const oc = getOC();
+        const point = new oc.gp_Pnt(mirrorPoint.x, mirrorPoint.y, mirrorPoint.z);
+        const trsf = new oc.gp_Trsf();
+        trsf.SetMirror(point);
+        const transformer = new oc.BRepBuilderAPI_Transform(trsf);
+        transformer.Perform(shape, true);
+        const result = transformer.Shape();
+        transformer.delete();
+        trsf.delete();
+        point.delete();
+        return result;
+    }
+    static translateShape(shape, direction) {
+        const result = ShapeOps.translateShapeRaw(shape.getShape(), direction);
+        return ShapeFactory.fromShape(result);
+    }
+    static translateShapeRaw(shape, direction) {
+        const oc = getOC();
+        const [vec, disposeVec] = Convert.toGpVec(direction);
+        const trsf = new oc.gp_Trsf();
+        trsf.SetTranslation(vec);
+        const transformer = new oc.BRepBuilderAPI_Transform(trsf);
+        transformer.Perform(shape, false);
+        const result = transformer.Shape();
+        transformer.delete();
+        trsf.delete();
+        disposeVec();
+        return result;
+    }
+    static rotateShape(shape, axis, angle) {
+        const oc = getOC();
+        const trsf = new oc.gp_Trsf();
+        const [gpAxis, disposeGpAxis] = Convert.toGpAx1(axis);
+        trsf.SetRotation(gpAxis, angle);
+        const transformer = new oc.BRepBuilderAPI_Transform(trsf);
+        transformer.Perform(shape, false);
+        const result = transformer.Shape();
+        transformer.delete();
+        trsf.delete();
+        disposeGpAxis();
+        return result;
+    }
+    static shapeListToArray(list) {
+        let res = [];
+        while (list.Size() > 0) {
+            res.push(list.First());
+            list.RemoveFirst();
+        }
+        list.delete();
+        return res;
+    }
+    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;
+    }
+}