fluidcad 0.0.2 → 0.0.4

package/lib/dist/oc/measure.js

@@ -1,256 +0,0 @@
-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/tangent-circle-solver.d.ts

@@ -1,17 +0,0 @@
-import { Edge } from "../common/edge.js";
-import { ConstraintQualifier } from "../features/2d/constraints/qualified-geometry.js";
-import { Plane } from "../math/plane.js";
-import { Shape } from "../common/shape.js";
-export declare class TangentCircleSolver {
-    static getTangentLines(plane: Plane, shape1: {
-        shape: Shape;
-        qualifier: ConstraintQualifier;
-    }, shape2: {
-        shape: Shape;
-        qualifier: ConstraintQualifier;
-    }): Edge[];
-    private static getPointCircleTangent;
-    private static getCircleCircleTangent;
-    private static collectSolverEdges;
-    private static getShapeGeometry;
-}

package/lib/dist/oc/tangent-circle-solver.js

@@ -1,72 +0,0 @@
-import { Convert } from "./convert.js";
-import { Geometry } from "./geometry.js";
-import { getOC } from "./init.js";
-import { ConstraintResolver } from "./constraint-resolver.js";
-export class TangentCircleSolver {
-    static getTangentLines(plane, shape1, shape2) {
-        return [];
-    }
-    static getPointCircleTangent(plane, vertex, circleShape) {
-        const oc = getOC();
-        // new oc.GccAna_Circ2d2TanRad()
-        const tolerance = oc.Precision.Angular();
-        const [pln, disposePln] = Convert.toGpPln(plane);
-        const [pnt, disposePnt] = Convert.toGpPnt2d(vertex.toPoint2D());
-        const geometry = this.getShapeGeometry(circleShape.shape);
-        const qualifiedGeometry = ConstraintResolver.getQualified(pln, geometry, circleShape.qualifier);
-        const solver = new oc.GccAna_Lin2d2Tan(qualifiedGeometry, pnt, tolerance);
-        disposePnt();
-        const edges = this.collectSolverEdges(solver, plane);
-        disposePln();
-        return edges;
-    }
-    static getCircleCircleTangent(plane, shape1, shape2) {
-        const oc = getOC();
-        const tolerance = oc.Precision.Angular();
-        const [pln, disposePln] = Convert.toGpPln(plane);
-        const geometry1 = this.getShapeGeometry(shape1.shape);
-        const geometry2 = this.getShapeGeometry(shape2.shape);
-        const qualifiedGeometry1 = ConstraintResolver.getQualified(pln, geometry1, shape1.qualifier);
-        const qualifiedGeometry2 = ConstraintResolver.getQualified(pln, geometry2, shape2.qualifier);
-        const solver = new oc.GccAna_Lin2d2Tan(qualifiedGeometry1, qualifiedGeometry2, tolerance);
-        const edges = this.collectSolverEdges(solver, plane);
-        disposePln();
-        return edges;
-    }
-    static collectSolverEdges(solver, plane) {
-        const oc = getOC();
-        const edges = [];
-        if (solver.IsDone()) {
-            const nSolutions = solver.NbSolutions();
-            for (let i = 1; i <= nSolutions; i++) {
-                const pnt1 = new oc.gp_Pnt2d();
-                const pnt2 = new oc.gp_Pnt2d();
-                solver.Tangency1(i, 0, 0, pnt1);
-                solver.Tangency2(i, 0, 0, pnt2);
-                const worldPnt1 = plane.localToWorld(Convert.toPoint2D(pnt1, true));
-                const worldPnt2 = plane.localToWorld(Convert.toPoint2D(pnt2, true));
-                const line = Geometry.makeSegment(worldPnt1, worldPnt2);
-                edges.push(Geometry.makeEdge(line));
-            }
-        }
-        return edges;
-    }
-    static getShapeGeometry(shape) {
-        const oc = getOC();
-        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
-        const type = adaptor.GetType();
-        let geometry;
-        if (type === oc.GeomAbs_CurveType.GeomAbs_Line) {
-            geometry = adaptor.Line();
-        }
-        else if (type === oc.GeomAbs_CurveType.GeomAbs_Circle && adaptor.IsClosed()) {
-            geometry = adaptor.Circle();
-        }
-        else {
-            adaptor.delete();
-            throw new Error('Unsupported shape type for tangent line solver');
-        }
-        adaptor.delete();
-        return geometry;
-    }
-}

package/lib/dist/oc/tangent-line-solver.d.ts

@@ -1,17 +0,0 @@
-import { Edge } from "../common/edge.js";
-import { ConstraintQualifier } from "../features/2d/constraints/qualified-geometry.js";
-import { Plane } from "../math/plane.js";
-import { Shape } from "../common/shape.js";
-export declare class TangentLineSolver {
-    static getTangentLines(plane: Plane, shape1: {
-        shape: Shape;
-        qualifier: ConstraintQualifier;
-    }, shape2: {
-        shape: Shape;
-        qualifier: ConstraintQualifier;
-    }): Edge[];
-    private static getPointCircleTangent;
-    private static getCircleCircleTangent;
-    private static collectSolverEdges;
-    private static getShapeGeometry;
-}

package/lib/dist/oc/tangent-line-solver.js

@@ -1,83 +0,0 @@
-import { getOC } from "./init.js";
-import { Convert } from "./convert.js";
-import { Geometry } from "./geometry.js";
-import { ConstraintResolver } from "./constraint-resolver.js";
-import { Vertex } from "../common/vertex.js";
-export class TangentLineSolver {
-    static getTangentLines(plane, shape1, shape2) {
-        if (shape1.shape instanceof Vertex || shape2.shape instanceof Vertex) {
-            const [vertex] = [shape1, shape2].filter(s => s.shape instanceof Vertex);
-            const [otherShape] = [shape1, shape2].filter(s => s !== vertex);
-            if (otherShape instanceof Vertex) {
-                // todo: create a line between the two points and return it as the single tangent solution
-                return [];
-            }
-            return this.getPointCircleTangent(plane, vertex.shape, otherShape);
-        }
-        else {
-            return this.getCircleCircleTangent(plane, shape1, shape2);
-        }
-    }
-    static getPointCircleTangent(plane, vertex, circleShape) {
-        const oc = getOC();
-        const tolerance = oc.Precision.Angular();
-        const [pln, disposePln] = Convert.toGpPln(plane);
-        const [pnt, disposePnt] = Convert.toGpPnt2d(vertex.toPoint2D());
-        const geometry = this.getShapeGeometry(circleShape.shape);
-        const qualifiedGeometry = ConstraintResolver.getQualified(pln, geometry, circleShape.qualifier);
-        const solver = new oc.GccAna_Lin2d2Tan(qualifiedGeometry, pnt, tolerance);
-        disposePnt();
-        const edges = this.collectSolverEdges(solver, plane);
-        disposePln();
-        return edges;
-    }
-    static getCircleCircleTangent(plane, shape1, shape2) {
-        const oc = getOC();
-        const tolerance = oc.Precision.Angular();
-        const [pln, disposePln] = Convert.toGpPln(plane);
-        const geometry1 = this.getShapeGeometry(shape1.shape);
-        const geometry2 = this.getShapeGeometry(shape2.shape);
-        const qualifiedGeometry1 = ConstraintResolver.getQualified(pln, geometry1, shape1.qualifier);
-        const qualifiedGeometry2 = ConstraintResolver.getQualified(pln, geometry2, shape2.qualifier);
-        const solver = new oc.GccAna_Lin2d2Tan(qualifiedGeometry1, qualifiedGeometry2, tolerance);
-        const edges = this.collectSolverEdges(solver, plane);
-        disposePln();
-        return edges;
-    }
-    static collectSolverEdges(solver, plane) {
-        const oc = getOC();
-        const edges = [];
-        if (solver.IsDone()) {
-            const nSolutions = solver.NbSolutions();
-            for (let i = 1; i <= nSolutions; i++) {
-                const pnt1 = new oc.gp_Pnt2d();
-                const pnt2 = new oc.gp_Pnt2d();
-                solver.Tangency1(i, 0, 0, pnt1);
-                solver.Tangency2(i, 0, 0, pnt2);
-                const worldPnt1 = plane.localToWorld(Convert.toPoint2D(pnt1, true));
-                const worldPnt2 = plane.localToWorld(Convert.toPoint2D(pnt2, true));
-                const line = Geometry.makeSegment(worldPnt1, worldPnt2);
-                edges.push(Geometry.makeEdge(line));
-            }
-        }
-        return edges;
-    }
-    static getShapeGeometry(shape) {
-        const oc = getOC();
-        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
-        const type = adaptor.GetType();
-        let geometry;
-        if (type === oc.GeomAbs_CurveType.GeomAbs_Line) {
-            geometry = adaptor.Line();
-        }
-        else if (type === oc.GeomAbs_CurveType.GeomAbs_Circle && adaptor.IsClosed()) {
-            geometry = adaptor.Circle();
-        }
-        else {
-            adaptor.delete();
-            throw new Error('Unsupported shape type for tangent line solver');
-        }
-        adaptor.delete();
-        return geometry;
-    }
-}

package/lib/dist/oc/tangent-solver.d.ts

@@ -1,14 +0,0 @@
-import { Point2D } from "../math/point.js";
-import { Edge } from "../common/edge.js";
-import { QualifiedGeometry } from "../features/2d/constraints/qualified-geometry.js";
-import { Plane } from "../math/plane.js";
-export declare class TangentSolver {
-    static getTangentLines(plane: Plane, qualifiedC1: QualifiedGeometry, qualifiedC2: QualifiedGeometry): Edge[];
-    static getTangentCircles(plane: Plane, qualifiedC1: QualifiedGeometry, qualifiedC2: QualifiedGeometry, radius: number): Edge[];
-    static getTangentArcs(plane: Plane, qualifiedC1: QualifiedGeometry, qualifiedC2: QualifiedGeometry, radius: number): {
-        edge: Edge;
-        endTangent: Point2D;
-    }[];
-    static getTangentCircles3Tan(plane: Plane, qualifiedC1: QualifiedGeometry, qualifiedC2: QualifiedGeometry, qualifiedC3: QualifiedGeometry): Edge[];
-    private static buildCirc2TanSolver;
-}

package/lib/dist/oc/tangent-solver.js

@@ -1,199 +0,0 @@
-import { getOC } from "./init.js";
-import { Convert } from "./convert.js";
-import { Point2D } from "../math/point.js";
-import { Geometry } from "./geometry.js";
-import { ConstraintResolver } from "./constraint-resolver.js";
-import { Wire } from "../common/wire.js";
-import { Vertex } from "../common/vertex.js";
-export class TangentSolver {
-    static getTangentLines(plane, qualifiedC1, qualifiedC2) {
-        const oc = getOC();
-        const tolerance = oc.Precision.Angular();
-        const [pln, disposePln] = Convert.toGpPln(plane);
-        let shape1 = qualifiedC1.object.getShapes({ excludeMeta: false })[0];
-        let shape2 = qualifiedC2.object.getShapes({ excludeMeta: false })[0];
-        if (shape1 instanceof Wire) {
-            shape1 = shape1.getEdges()[0];
-        }
-        if (shape2 instanceof Wire) {
-            shape2 = shape2.getEdges()[0];
-        }
-        let qc1;
-        let qc2;
-        if (shape1 instanceof Vertex || shape2 instanceof Vertex) {
-            // const oc = getOC();
-            // const vertex = shape.getShape() as TopoDS_Vertex;
-            // const pnt = oc.BRep_Tool.Pnt(vertex);
-            //       const localPoint = plane.worldToLocal(Convert.toPoint(c2.qualified as gp_Pnt));
-            // const [gpPnt, disposeGpPnt] = Convert.toGpPnt2d(localPoint);
-            // solver = new oc.GccAna_Lin2d2Tan(c1.qualified as any, gpPnt, tolerance);
-            // disposeGpPnt();
-            throw new Error('TODO');
-        }
-        const adaptor1 = new oc.BRepAdaptor_Curve(shape1.getShape());
-        const adaptor2 = new oc.BRepAdaptor_Curve(shape2.getShape());
-        const type1 = adaptor1.GetType();
-        const type2 = adaptor2.GetType();
-        let solver;
-        if (type1 === oc.GeomAbs_CurveType.GeomAbs_Circle && type2 === oc.GeomAbs_CurveType.GeomAbs_Circle && adaptor1.IsClosed() && adaptor2.IsClosed()) {
-            const c1 = ConstraintResolver.getQualified(pln, qualifiedC1);
-            const c2 = ConstraintResolver.getQualified(pln, qualifiedC2);
-            solver = new oc.GccAna_Lin2d2Tan(c1.qualified, c2.qualified, tolerance);
-        }
-        else {
-            const c1 = ConstraintResolver.getQualifiedAsCurve(pln, adaptor1, ConstraintResolver.getQualifier(qualifiedC1.qualifier));
-            const c2 = ConstraintResolver.getQualifiedAsCurve(pln, adaptor2, ConstraintResolver.getQualifier(qualifiedC2.qualifier));
-            solver = new oc.Geom2dGcc_Lin2d2Tan(c1, c2, tolerance);
-        }
-        disposePln();
-        const edges = [];
-        if (solver.IsDone()) {
-            const nSolutions = solver.NbSolutions();
-            for (let i = 1; i <= nSolutions; i++) {
-                const pnt1 = new oc.gp_Pnt2d();
-                const pnt2 = new oc.gp_Pnt2d();
-                solver.Tangency1(i, 0, 0, pnt1);
-                solver.Tangency2(i, 0, 0, pnt2);
-                const worldPnt1 = plane.localToWorld(Convert.toPoint2D(pnt1, true));
-                const worldPnt2 = plane.localToWorld(Convert.toPoint2D(pnt2, true));
-                const line = Geometry.makeSegment(worldPnt1, worldPnt2);
-                edges.push(Geometry.makeEdge(line));
-            }
-        }
-        return edges;
-    }
-    static getTangentCircles(plane, qualifiedC1, qualifiedC2, radius) {
-        const solver = TangentSolver.buildCirc2TanSolver(plane, qualifiedC1, qualifiedC2, radius);
-        const edges = [];
-        if (solver.IsDone()) {
-            for (let i = 1; i <= solver.NbSolutions(); i++) {
-                const circ2d = solver.ThisSolution(i);
-                const center2d = Convert.toPoint2D(circ2d.Location());
-                const worldCenter = plane.localToWorld(center2d);
-                const r = circ2d.Radius();
-                const circle = Geometry.makeCircle(worldCenter, r, plane.normal);
-                edges.push(Geometry.makeEdgeFromCircle(circle));
-            }
-        }
-        return edges;
-    }
-    static getTangentArcs(plane, qualifiedC1, qualifiedC2, radius) {
-        const oc = getOC();
-        const solver = TangentSolver.buildCirc2TanSolver(plane, qualifiedC1, qualifiedC2, radius);
-        const results = [];
-        if (solver.IsDone()) {
-            for (let i = 1; i <= solver.NbSolutions(); i++) {
-                const circ2d = solver.ThisSolution(i);
-                const center2d = Convert.toPoint2D(circ2d.Location());
-                const worldCenter = plane.localToWorld(center2d);
-                const r = circ2d.Radius();
-                const pnt1 = new oc.gp_Pnt2d();
-                const pnt2 = new oc.gp_Pnt2d();
-                solver.Tangency1(i, 0, 0, pnt1);
-                solver.Tangency2(i, 0, 0, pnt2);
-                const worldPnt1 = plane.localToWorld(Convert.toPoint2D(pnt1, false));
-                const worldPnt2 = plane.localToWorld(Convert.toPoint2D(pnt2, false));
-                const angle1 = Math.atan2(pnt1.Y() - center2d.y, pnt1.X() - center2d.x);
-                const angle2 = Math.atan2(pnt2.Y() - center2d.y, pnt2.X() - center2d.x);
-                pnt1.delete();
-                pnt2.delete();
-                let diff = angle2 - angle1;
-                if (diff > Math.PI) {
-                    diff -= 2 * Math.PI;
-                }
-                if (diff < -Math.PI) {
-                    diff += 2 * Math.PI;
-                }
-                const midAngle = angle1 + diff / 2;
-                const worldMid = plane.localToWorld(new Point2D(center2d.x + r * Math.cos(midAngle), center2d.y + r * Math.sin(midAngle)));
-                const arc = Geometry.makeArcThreePoints(worldPnt1, worldMid, worldPnt2);
-                const edge = Geometry.makeEdgeFromCurve(arc);
-                const sign = diff > 0 ? 1 : -1;
-                const endTangent = new Point2D(sign * (-Math.sin(angle2)), sign * Math.cos(angle2));
-                results.push({ edge, endTangent });
-            }
-        }
-        return results;
-    }
-    static getTangentCircles3Tan(plane, qualifiedC1, qualifiedC2, qualifiedC3) {
-        const oc = getOC();
-        const tolerance = oc.Precision.Confusion();
-        const [pln, disposePln] = Convert.toGpPln(plane);
-        const inputs = [
-            { q: qualifiedC1, r: ConstraintResolver.getQualified(pln, qualifiedC1) },
-            { q: qualifiedC2, r: ConstraintResolver.getQualified(pln, qualifiedC2) },
-            { q: qualifiedC3, r: ConstraintResolver.getQualified(pln, qualifiedC3) },
-        ];
-        const circles = inputs.filter(i => i.r.type === 'circle');
-        const lines = inputs.filter(i => i.r.type === 'line');
-        const curves = inputs.filter(i => i.r.type === 'curve');
-        let solver;
-        if (curves.length > 0) {
-            const qc1 = ConstraintResolver.getQualifiedAsCurve(pln, qualifiedC1);
-            const qc2 = ConstraintResolver.getQualifiedAsCurve(pln, qualifiedC2);
-            const qc3 = ConstraintResolver.getQualifiedAsCurve(pln, qualifiedC3);
-            solver = new oc.Geom2dGcc_Circ2d3Tan(qc1, qc2, qc3, tolerance, 0, 0, 0);
-        }
-        else if (circles.length === 3) {
-            solver = new oc.GccAna_Circ2d3Tan(circles[0].r.qualified, circles[1].r.qualified, circles[2].r.qualified, tolerance);
-        }
-        else if (circles.length === 2 && lines.length === 1) {
-            solver = new oc.GccAna_Circ2d3Tan(circles[0].r.qualified, circles[1].r.qualified, lines[0].r.qualified, tolerance);
-        }
-        else if (circles.length === 1 && lines.length === 2) {
-            solver = new oc.GccAna_Circ2d3Tan(circles[0].r.qualified, lines[0].r.qualified, lines[1].r.qualified, tolerance);
-        }
-        else {
-            solver = new oc.GccAna_Circ2d3Tan(lines[0].r.qualified, lines[1].r.qualified, lines[2].r.qualified, tolerance);
-        }
-        disposePln();
-        const edges = [];
-        if (solver.IsDone()) {
-            for (let i = 1; i <= solver.NbSolutions(); i++) {
-                const circ2d = solver.ThisSolution(i);
-                const center2d = Convert.toPoint2D(circ2d.Location());
-                const worldCenter = plane.localToWorld(center2d);
-                const r = circ2d.Radius();
-                const circle = Geometry.makeCircle(worldCenter, r, plane.normal);
-                edges.push(Geometry.makeEdgeFromCircle(circle));
-            }
-        }
-        return edges;
-    }
-    static buildCirc2TanSolver(plane, qualifiedC1, qualifiedC2, radius) {
-        const oc = getOC();
-        const tolerance = oc.Precision.Confusion();
-        const [pln, disposePln] = Convert.toGpPln(plane);
-        const c1 = ConstraintResolver.getQualified(pln, qualifiedC1);
-        const c2 = ConstraintResolver.getQualified(pln, qualifiedC2);
-        let solver;
-        if (c1.type === 'circle' && c2.type === 'circle') {
-            solver = new oc.GccAna_Circ2d2TanRad(c1.qualified, c2.qualified, radius, tolerance);
-        }
-        else if (c1.type === 'circle' && c2.type === 'line') {
-            solver = new oc.GccAna_Circ2d2TanRad(c1.qualified, c2.qualified, radius, tolerance);
-        }
-        else if (c1.type === 'line' && c2.type === 'circle') {
-            solver = new oc.GccAna_Circ2d2TanRad(c2.qualified, c1.qualified, radius, tolerance);
-        }
-        else if (c1.type === 'line' && c2.type === 'line') {
-            solver = new oc.GccAna_Circ2d2TanRad(c1.qualified, c2.qualified, radius, tolerance);
-        }
-        else if (c1.type === 'point' && c2.type === 'point') {
-            const localPoint1 = plane.worldToLocal(Convert.toPoint(c1.qualified));
-            const localPoint2 = plane.worldToLocal(Convert.toPoint(c2.qualified));
-            const [gpPnt1, disposeGpPnt1] = Convert.toGpPnt2d(localPoint1);
-            const [gpPnt2, disposeGpPnt2] = Convert.toGpPnt2d(localPoint2);
-            solver = new oc.GccAna_Circ2d2TanRad(gpPnt1, gpPnt2, radius, tolerance);
-            disposeGpPnt1();
-            disposeGpPnt2();
-        }
-        else {
-            const qc1 = ConstraintResolver.getQualifiedAsCurve(pln, qualifiedC1);
-            const qc2 = ConstraintResolver.getQualifiedAsCurve(pln, qualifiedC2);
-            solver = new oc.Geom2dGcc_Circ2d2TanRad(qc1, qc2, radius, tolerance);
-        }
-        disposePln();
-        return solver;
-    }
-}

package/lib/dist/rendering/builder-context.d.ts

@@ -1,16 +0,0 @@
-import { SceneObject } from "../common/scene-object.js";
-import { Shape, ShapeFilter } from "../common/shape.js";
-import { SelectSceneObject } from "../features/select.js";
-import { Extrudable } from "../helpers/types.js";
-export declare class SceneBuilderContext {
-    private sceneObjects;
-    constructor(sceneObjects: SceneObject[]);
-    getSceneObjects(): SceneObject[];
-    getObjectShapesMap(filter?: ShapeFilter): Map<SceneObject, Shape<import("occjs-wrapper").TopoDS_Shape>[]>;
-    getActiveSceneObjects(): SceneObject[];
-    getSceneObjectsFromTo(from: SceneObject, to: SceneObject): SceneObject[];
-    getLastExtrudable(): Extrudable;
-    getLastSelections(): any[];
-    getLastSelection(): SelectSceneObject;
-    addObject(obj: SceneObject): void;
-}