fluidcad 0.0.2

package/lib/dist/oc/constraints/constraint-helpers.d.ts

@@ -0,0 +1,33 @@
+import type { GccEnt_Position, gp_Circ, gp_Circ2d, gp_Lin, gp_Lin2d, gp_Pln, gp_Pnt, gp_Pnt2d, Handle_Geom_Curve } from "occjs-wrapper";
+import { ConstraintQualifier } from "../../features/2d/constraints/qualified-geometry.js";
+import { Point2D } from "../../math/point.js";
+import { Edge } from "../../common/edge.js";
+import { Shape } from "../../common/shape.js";
+import { Plane } from "../../math/plane.js";
+export declare function get2dGeometry<T extends gp_Circ | gp_Lin | gp_Pnt>(plane: gp_Pln, geometry: T): gp_Lin2d | gp_Circ2d | gp_Pnt2d;
+export declare function get2dCurve(plane: gp_Pln, curve: Handle_Geom_Curve): import("occjs-wrapper").Handle_Geom2d_Curve;
+export declare function getQualifier(qualifier: ConstraintQualifier): GccEnt_Position;
+export declare function getQualifiedCurve(plane: gp_Pln, curve: Handle_Geom_Curve, qualifier: ConstraintQualifier): import("occjs-wrapper").Geom2dGcc_QualifiedCurve;
+export declare function getQualifiedGeometry(plane: gp_Pln, geometry: gp_Circ | gp_Lin, qualifier: ConstraintQualifier): import("occjs-wrapper").GccEnt_QualifiedCirc | import("occjs-wrapper").GccEnt_QualifiedLin;
+export declare function calculateTangent(solutions: {
+    center: gp_Pnt2d;
+    radius: number;
+    tangentPoint1: gp_Pnt2d;
+    tangentPoint2: gp_Pnt2d;
+}[]): Point2D | null;
+export declare function toCircleEdges(solutions: {
+    center: gp_Pnt2d;
+    radius: number;
+    tangentPoint1: gp_Pnt2d;
+    tangentPoint2: gp_Pnt2d;
+}[], plane: Plane): Edge[];
+export declare function toArcEdges(solutions: {
+    center: gp_Pnt2d;
+    radius: number;
+    tangentPoint1: gp_Pnt2d;
+    tangentPoint2: gp_Pnt2d;
+}[], plane: Plane): Edge[];
+export declare function filterSolutionsByFiniteExtent<T extends {
+    tangentPoint1: gp_Pnt2d;
+    tangentPoint2: gp_Pnt2d;
+}>(solutions: T[], shape1: Shape, shape2: Shape, plane: Plane): T[];

package/lib/dist/oc/constraints/constraint-helpers.js

@@ -0,0 +1,252 @@
+import { getOC } from "../init.js";
+import { Point2D } from "../../math/point.js";
+import { Edge } from "../../common/edge.js";
+import { Convert } from "../convert.js";
+import { Geometry } from "../geometry.js";
+export function get2dGeometry(plane, geometry) {
+    const oc = getOC();
+    return oc.ProjLib.Project(plane, geometry);
+}
+export function get2dCurve(plane, curve) {
+    const oc = getOC();
+    return oc.GeomAPI.To2d(curve, plane);
+}
+export function getQualifier(qualifier) {
+    const oc = getOC();
+    switch (qualifier) {
+        case 'unqualified':
+            return oc.GccEnt_Position.GccEnt_unqualified;
+        case 'enclosed':
+            return oc.GccEnt_Position.GccEnt_enclosed;
+        case 'enclosing':
+            return oc.GccEnt_Position.GccEnt_enclosing;
+        case 'outside':
+            return oc.GccEnt_Position.GccEnt_outside;
+    }
+}
+export function getQualifiedCurve(plane, curve, qualifier) {
+    const oc = getOC();
+    const curve2dHandle = get2dCurve(plane, curve);
+    const handle = new oc.Geom2dAdaptor_Curve(curve2dHandle);
+    return new oc.Geom2dGcc_QualifiedCurve(handle, getQualifier(qualifier));
+}
+export function getQualifiedGeometry(plane, geometry, qualifier) {
+    const oc = getOC();
+    const geom = get2dGeometry(plane, geometry);
+    if (geom instanceof oc.gp_Circ2d) {
+        return new oc.GccEnt_QualifiedCirc(geom, getQualifier(qualifier));
+    }
+    else if (geom instanceof oc.gp_Lin2d) {
+        return new oc.GccEnt_QualifiedLin(geom, getQualifier(qualifier));
+    }
+    throw new Error('Unsupported geometry type');
+}
+export function calculateTangent(solutions) {
+    if (solutions.length === 0) {
+        return null;
+    }
+    const lastSolution = solutions[solutions.length - 1];
+    const cx = lastSolution.center.X();
+    const cy = lastSolution.center.Y();
+    const radius = lastSolution.radius;
+    let angle1 = Math.atan2(lastSolution.tangentPoint1.Y() - cy, lastSolution.tangentPoint1.X() - cx);
+    let angle2 = Math.atan2(lastSolution.tangentPoint2.Y() - cy, lastSolution.tangentPoint2.X() - cx);
+    const dist1 = Math.hypot(lastSolution.tangentPoint1.X() - cx, lastSolution.tangentPoint1.Y() - cy);
+    const dist2 = Math.hypot(lastSolution.tangentPoint2.X() - cx, lastSolution.tangentPoint2.Y() - cy);
+    if (dist1 < radius * 0.9) {
+        angle1 += Math.PI;
+    }
+    if (dist2 < radius * 0.9) {
+        angle2 += Math.PI;
+    }
+    let diff = angle2 - angle1;
+    if (diff > Math.PI) {
+        diff -= 2 * Math.PI;
+    }
+    if (diff < -Math.PI) {
+        diff += 2 * Math.PI;
+    }
+    // Determine whether the actual arc takes the short or long path, using the
+    // same heuristic as toArcEdges: pick the arc whose midpoint is closest to
+    // the midpoint of the original (raw) tangent points on the input geometries.
+    const rawMidX = (lastSolution.tangentPoint1.X() + lastSolution.tangentPoint2.X()) / 2;
+    const rawMidY = (lastSolution.tangentPoint1.Y() + lastSolution.tangentPoint2.Y()) / 2;
+    const midAngleShort = angle1 + diff / 2;
+    const midAngleLong = midAngleShort + Math.PI;
+    const shortMidX = cx + radius * Math.cos(midAngleShort);
+    const shortMidY = cy + radius * Math.sin(midAngleShort);
+    const longMidX = cx + radius * Math.cos(midAngleLong);
+    const longMidY = cy + radius * Math.sin(midAngleLong);
+    const distShort = Math.hypot(shortMidX - rawMidX, shortMidY - rawMidY);
+    const distLong = Math.hypot(longMidX - rawMidX, longMidY - rawMidY);
+    // If the long arc is chosen, the traversal direction is opposite to what
+    // the short-arc diff implies, so flip the sign.
+    const sign = (distShort <= distLong ? diff : -diff) > 0 ? 1 : -1;
+    return new Point2D(sign * (-Math.sin(angle2)), sign * Math.cos(angle2));
+}
+export function toCircleEdges(solutions, plane) {
+    return solutions.map(solution => {
+        const center2d = Convert.toPoint2D(solution.center);
+        const worldCenter = plane.localToWorld(center2d);
+        const circle = Geometry.makeCircle(worldCenter, solution.radius, plane.normal);
+        return Geometry.makeEdgeFromCircle(circle);
+    });
+}
+export function toArcEdges(solutions, plane) {
+    return solutions.map(solution => {
+        const pnt1 = Convert.toPoint2D(solution.tangentPoint1);
+        const pnt2 = Convert.toPoint2D(solution.tangentPoint2);
+        const center = Convert.toPoint2D(solution.center);
+        const radius = solution.radius;
+        let angle1 = Math.atan2(pnt1.y - center.y, pnt1.x - center.x);
+        let angle2 = Math.atan2(pnt2.y - center.y, pnt2.x - center.x);
+        // Solver tangent points lie on the input geometries, not on the solution
+        // circle. When a tangent point falls inside the solution circle (internal
+        // tangency), its direction from the center is opposite to the actual
+        // tangent point on the solution circle — correct by flipping the angle.
+        if (pnt1.distanceTo(center) < radius * 0.9) {
+            angle1 += Math.PI;
+        }
+        if (pnt2.distanceTo(center) < radius * 0.9) {
+            angle2 += Math.PI;
+        }
+        const worldPnt1 = plane.localToWorld(new Point2D(center.x + radius * Math.cos(angle1), center.y + radius * Math.sin(angle1)));
+        const worldPnt2 = plane.localToWorld(new Point2D(center.x + radius * Math.cos(angle2), center.y + radius * Math.sin(angle2)));
+        let diff = angle2 - angle1;
+        if (diff > Math.PI) {
+            diff -= 2 * Math.PI;
+        }
+        if (diff < -Math.PI) {
+            diff += 2 * Math.PI;
+        }
+        const midAngleShort = angle1 + diff / 2;
+        const midAngleLong = midAngleShort + Math.PI;
+        // Pick the arc whose midpoint is closest to the midpoint of the original
+        // tangent points (on the input geometries), so the arc bridges between them.
+        const rawMidX = (pnt1.x + pnt2.x) / 2;
+        const rawMidY = (pnt1.y + pnt2.y) / 2;
+        const shortMidX = center.x + radius * Math.cos(midAngleShort);
+        const shortMidY = center.y + radius * Math.sin(midAngleShort);
+        const longMidX = center.x + radius * Math.cos(midAngleLong);
+        const longMidY = center.y + radius * Math.sin(midAngleLong);
+        const distShort = Math.hypot(shortMidX - rawMidX, shortMidY - rawMidY);
+        const distLong = Math.hypot(longMidX - rawMidX, longMidY - rawMidY);
+        const midAngle = distShort <= distLong ? midAngleShort : midAngleLong;
+        const worldMid = plane.localToWorld(new Point2D(center.x + radius * Math.cos(midAngle), center.y + radius * Math.sin(midAngle)));
+        const arc = Geometry.makeArcThreePoints(worldPnt1, worldMid, worldPnt2);
+        return Geometry.makeEdgeFromCurve(arc);
+    });
+}
+export function filterSolutionsByFiniteExtent(solutions, shape1, shape2, plane) {
+    const edges = getFiniteEdgeExtents([shape1, shape2], plane);
+    if (edges.length === 0) {
+        return solutions;
+    }
+    return solutions.filter(solution => {
+        const tp1 = new Point2D(solution.tangentPoint1.X(), solution.tangentPoint1.Y());
+        const tp2 = new Point2D(solution.tangentPoint2.X(), solution.tangentPoint2.Y());
+        return isWithinFiniteEdges(tp1, edges) && isWithinFiniteEdges(tp2, edges);
+    });
+}
+function getFiniteEdgeExtents(shapes, plane) {
+    const oc = getOC();
+    const result = [];
+    for (const shape of shapes) {
+        if (!(shape instanceof Edge)) {
+            continue;
+        }
+        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+        const curveType = adaptor.GetType();
+        if (curveType === oc.GeomAbs_CurveType.GeomAbs_Line) {
+            adaptor.delete();
+            const start = plane.worldToLocal(shape.getFirstVertex().toPoint());
+            const end = plane.worldToLocal(shape.getLastVertex().toPoint());
+            const dx = end.x - start.x;
+            const dy = end.y - start.y;
+            const len2 = dx * dx + dy * dy;
+            if (len2 < oc.Precision.SquareConfusion()) {
+                continue;
+            }
+            result.push({ type: 'line', start, end, dx, dy, len2, len: Math.sqrt(len2) });
+        }
+        else if (curveType === oc.GeomAbs_CurveType.GeomAbs_Circle) {
+            if (shape.isClosed()) {
+                adaptor.delete();
+                continue; // Full circle, no filtering needed
+            }
+            const circle = adaptor.Circle();
+            const centerGp = circle.Location();
+            const center = plane.worldToLocal(Convert.toPoint(centerGp));
+            const radius = circle.Radius();
+            // Evaluate at midpoint parameter to determine arc direction
+            const firstParam = adaptor.FirstParameter();
+            const lastParam = adaptor.LastParameter();
+            const midParam = (firstParam + lastParam) / 2;
+            const midGp = adaptor.Value(midParam);
+            const mid = plane.worldToLocal(Convert.toPoint(midGp));
+            adaptor.delete();
+            const start = plane.worldToLocal(shape.getFirstVertex().toPoint());
+            const end = plane.worldToLocal(shape.getLastVertex().toPoint());
+            result.push({
+                type: 'arc',
+                center,
+                radius,
+                startAngle: Math.atan2(start.y - center.y, start.x - center.x),
+                midAngle: Math.atan2(mid.y - center.y, mid.x - center.x),
+                endAngle: Math.atan2(end.y - center.y, end.x - center.x),
+            });
+        }
+        else {
+            adaptor.delete();
+        }
+    }
+    return result;
+}
+// Returns false if the point lies on a curve's infinite extension but outside
+// its finite extent. Points not on any edge's geometry pass through.
+function isWithinFiniteEdges(point, edges) {
+    const oc = getOC();
+    for (const edge of edges) {
+        if (edge.type === 'line') {
+            const perpDist = Math.abs((point.x - edge.start.x) * (-edge.dy / edge.len) +
+                (point.y - edge.start.y) * (edge.dx / edge.len));
+            if (perpDist > oc.Precision.Approximation()) {
+                continue; // Point is not on this line's geometry
+            }
+            const t = ((point.x - edge.start.x) * edge.dx + (point.y - edge.start.y) * edge.dy) / edge.len2;
+            if (t < -oc.Precision.PConfusion() || t > 1 + oc.Precision.PConfusion()) {
+                return false;
+            }
+        }
+        else if (edge.type === 'arc') {
+            const dist = Math.hypot(point.x - edge.center.x, point.y - edge.center.y);
+            if (Math.abs(dist - edge.radius) > oc.Precision.Confusion()) {
+                continue; // Point is not on this circle's geometry
+            }
+            const angle = Math.atan2(point.y - edge.center.y, point.x - edge.center.x);
+            if (!isAngleOnArc(angle, edge.startAngle, edge.midAngle, edge.endAngle)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function isAngleOnArc(angle, startAngle, midAngle, endAngle) {
+    const oc = getOC();
+    function normAngle(a) {
+        let r = a % (2 * Math.PI);
+        if (r < 0) {
+            r += 2 * Math.PI;
+        }
+        return r;
+    }
+    const normMid = normAngle(midAngle - startAngle);
+    const normEnd = normAngle(endAngle - startAngle);
+    const normPoint = normAngle(angle - startAngle);
+    // The arc sweeps from 0 (start) through normMid to normEnd.
+    // Total sweep = startToMid + midToEnd (both measured CCW).
+    const startToMid = normMid;
+    const midToEnd = normAngle(endAngle - midAngle);
+    const totalSweep = startToMid + midToEnd;
+    return normPoint <= totalSweep + oc.Precision.Angular();
+}

package/lib/dist/oc/constraints/constraint-solver-adaptor.d.ts

@@ -0,0 +1,22 @@
+import { ConstraintSolver } from "./constraint-solver.js";
+import { QualifiedShape } from "../../features/2d/constraints/qualified-geometry.js";
+import { Edge } from "../../common/edge.js";
+import { Plane } from "../../math/plane.js";
+import { Shape } from "../../common/shape.js";
+import { GeometricConstraintSolver } from "./geometric/geometric-constraint-solver.js";
+import { CurveConstraintSolver } from "./curve/curve-constraint-solver.js";
+import { Point2D } from "../../math/point.js";
+export declare class ConstraintSolverAdaptor extends ConstraintSolver {
+    private geometricSolver;
+    private curveSolver;
+    private mustTouch;
+    constructor(geometricSolver: GeometricConstraintSolver, curveSolver: CurveConstraintSolver, mustTouch: boolean);
+    getTangentLines(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape): Edge[];
+    getTangentCircles(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number): Edge[];
+    getTangentArcs(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number): {
+        edges: Edge[];
+        endTangent: Point2D | null;
+    };
+    isCurve(shape: Shape): boolean;
+    private getShapeGeometry;
+}

package/lib/dist/oc/constraints/constraint-solver-adaptor.js

@@ -0,0 +1,62 @@
+import { ConstraintSolver } from "./constraint-solver.js";
+import { getOC } from "../init.js";
+import { Vertex } from "../../common/vertex.js";
+export class ConstraintSolverAdaptor extends ConstraintSolver {
+    geometricSolver;
+    curveSolver;
+    mustTouch;
+    constructor(geometricSolver, curveSolver, mustTouch) {
+        super();
+        this.geometricSolver = geometricSolver;
+        this.curveSolver = curveSolver;
+        this.mustTouch = mustTouch;
+    }
+    getTangentLines(plane, shape1, shape2) {
+        console.log('Determining which solver to use for tangent lines', shape1, shape2);
+        if (this.isCurve(shape1.shape) || this.isCurve(shape2.shape)) {
+            console.log('Using curve solver for tangent shapes');
+            return this.curveSolver.getTangentLines(plane, shape1, shape2, this.mustTouch);
+        }
+        console.log('Using geometric solver for tangent shapes');
+        return this.geometricSolver.getTangentLines(plane, shape1, shape2, this.mustTouch);
+    }
+    getTangentCircles(plane, shape1, shape2, radius) {
+        if (this.isCurve(shape1.shape) || this.isCurve(shape2.shape)) {
+            console.log('Using curve solver for tangent circles');
+            return this.curveSolver.getTangentCircles(plane, shape1, shape2, radius, this.mustTouch);
+        }
+        console.log('Using geometric solver for tangent circles');
+        return this.geometricSolver.getTangentCircles(plane, shape1, shape2, radius, this.mustTouch);
+    }
+    getTangentArcs(plane, shape1, shape2, radius) {
+        if (this.isCurve(shape1.shape) || this.isCurve(shape2.shape)) {
+            console.log('Using curve solver for tangent arcs');
+            return this.curveSolver.getTangentArcs(plane, shape1, shape2, radius, this.mustTouch);
+        }
+        console.log('Using geometric solver for tangent circles');
+        return this.geometricSolver.getTangentArcs(plane, shape1, shape2, radius, this.mustTouch);
+    }
+    isCurve(shape) {
+        return !(shape instanceof Vertex) && this.getShapeGeometry(shape) === 'curve';
+    }
+    getShapeGeometry(shape) {
+        const oc = getOC();
+        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+        const type = adaptor.GetType();
+        if (type === oc.GeomAbs_CurveType.GeomAbs_Line) {
+            adaptor.delete();
+            return 'line';
+        }
+        else if (type === oc.GeomAbs_CurveType.GeomAbs_Circle) {
+            if (adaptor.IsClosed()) {
+                console.log('Shape is a closed circle');
+                adaptor.delete();
+                return 'circle';
+            }
+            adaptor.delete();
+            return 'curve';
+        }
+        adaptor.delete();
+        throw new Error('Unsupported shape type for tangent line solver');
+    }
+}

package/lib/dist/oc/constraints/constraint-solver.d.ts

@@ -0,0 +1,18 @@
+import { Edge } from "../../common/edge.js";
+import { QualifiedShape } from "../../features/2d/constraints/qualified-geometry.js";
+import { Plane } from "../../math/plane.js";
+import { Point2D } from "../../math/point.js";
+export interface TangentLineSolver {
+    getTangentLines(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, mustTouch?: boolean): Edge[];
+}
+export interface TangentCircleSolver {
+    getTangentCircles(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number, mustTouch?: boolean): Edge[];
+}
+export declare abstract class ConstraintSolver implements TangentLineSolver, TangentCircleSolver {
+    abstract getTangentLines(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, mustTouch?: boolean): Edge[];
+    abstract getTangentCircles(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number, mustTouch?: boolean): Edge[];
+    abstract getTangentArcs(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number, mustTouch?: boolean): {
+        edges: Edge[];
+        endTangent: Point2D;
+    };
+}

package/lib/dist/oc/constraints/constraint-solver.js

@@ -0,0 +1,2 @@
+export class ConstraintSolver {
+}

package/lib/dist/oc/constraints/create-solver.d.ts

@@ -0,0 +1,2 @@
+import { ConstraintSolver } from "./constraint-solver.js";
+export declare function createConstraintSolver(mustTouch: boolean): ConstraintSolver;

package/lib/dist/oc/constraints/create-solver.js

@@ -0,0 +1,6 @@
+import { ConstraintSolverAdaptor } from "./constraint-solver-adaptor.js";
+import { CurveConstraintSolver } from "./curve/curve-constraint-solver.js";
+import { GeometricConstraintSolver } from "./geometric/geometric-constraint-solver.js";
+export function createConstraintSolver(mustTouch) {
+    return new ConstraintSolverAdaptor(new GeometricConstraintSolver(), new CurveConstraintSolver(), mustTouch);
+}

package/lib/dist/oc/constraints/curve/curve-constraint-solver.d.ts

@@ -0,0 +1,13 @@
+import { Edge } from "../../../common/edge.js";
+import { QualifiedShape } from "../../../features/2d/constraints/qualified-geometry.js";
+import { Plane } from "../../../math/plane.js";
+import { Point2D } from "../../../math/point.js";
+import { ConstraintSolver } from "../constraint-solver.js";
+export declare class CurveConstraintSolver extends ConstraintSolver {
+    getTangentCircles(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number, mustTouch: boolean): Edge[];
+    getTangentLines(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, mustTouch: boolean): Edge[];
+    getTangentArcs(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number, mustTouch: boolean): {
+        edges: Edge[];
+        endTangent: Point2D | null;
+    };
+}

package/lib/dist/oc/constraints/curve/curve-constraint-solver.js

@@ -0,0 +1,18 @@
+import { ConstraintSolver } from "../constraint-solver.js";
+import { CurveTangentCircleSolver } from "./tangent-circle-solver.js";
+import { CurveTangentLineSolver } from "./tangent-line-solver.js";
+export class CurveConstraintSolver extends ConstraintSolver {
+    getTangentCircles(plane, shape1, shape2, radius, mustTouch) {
+        const solver = new CurveTangentCircleSolver();
+        console.log('Getting tangent circles');
+        return solver.getTangentCircles(plane, shape1, shape2, radius, mustTouch);
+    }
+    getTangentLines(plane, shape1, shape2, mustTouch) {
+        const solver = new CurveTangentLineSolver();
+        return solver.getTangentLines(plane, shape1, shape2, mustTouch);
+    }
+    getTangentArcs(plane, shape1, shape2, radius, mustTouch) {
+        const solver = new CurveTangentCircleSolver();
+        return solver.getTangentArcs(plane, shape1, shape2, radius, mustTouch);
+    }
+}

package/lib/dist/oc/constraints/curve/tangent-circle-solver.d.ts

@@ -0,0 +1,16 @@
+import { Edge } from "../../../common/edge.js";
+import { QualifiedShape } from "../../../features/2d/constraints/qualified-geometry.js";
+import { Plane } from "../../../math/plane.js";
+import { TangentCircleSolver } from "../constraint-solver.js";
+import { Point2D } from "../../../math/point.js";
+export declare class CurveTangentCircleSolver implements TangentCircleSolver {
+    getTangentCircles(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number, mustTouch: boolean): Edge[];
+    getTangentArcs(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number, mustTouch: boolean): {
+        edges: Edge[];
+        endTangent: Point2D | null;
+    };
+    private getCurveCurveTangent;
+    private getCurvePointTangent;
+    private getSolutions;
+    private getCurve;
+}

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

@@ -0,0 +1,112 @@
+import { Vertex } from "../../../common/vertex.js";
+import { calculateTangent, filterSolutionsByFiniteExtent, getQualifiedCurve, toArcEdges, toCircleEdges } from "../constraint-helpers.js";
+import { Convert } from "../../convert.js";
+import { getOC } from "../../init.js";
+export class CurveTangentCircleSolver {
+    getTangentCircles(plane, shape1, shape2, radius, mustTouch) {
+        const isVertex1 = shape1.shape instanceof Vertex;
+        const isVertex2 = shape2.shape instanceof Vertex;
+        if (isVertex1 || isVertex2) {
+            const vertex = isVertex1 ? shape1 : shape2;
+            const other = isVertex1 ? shape2 : shape1;
+            let solutions = this.getCurvePointTangent(plane, vertex.shape, other, radius);
+            if (mustTouch) {
+                solutions = filterSolutionsByFiniteExtent(solutions, shape1.shape, shape2.shape, plane);
+            }
+            return toCircleEdges(solutions, plane);
+        }
+        let solutions = this.getCurveCurveTangent(plane, shape1, shape2, radius);
+        if (mustTouch) {
+            solutions = filterSolutionsByFiniteExtent(solutions, shape1.shape, shape2.shape, plane);
+        }
+        return toCircleEdges(solutions, plane);
+    }
+    getTangentArcs(plane, shape1, shape2, radius, mustTouch) {
+        const isVertex1 = shape1.shape instanceof Vertex;
+        const isVertex2 = shape2.shape instanceof Vertex;
+        if (isVertex1 || isVertex2) {
+            const vertex = isVertex1 ? shape1 : shape2;
+            const other = isVertex1 ? shape2 : shape1;
+            let solutions = this.getCurvePointTangent(plane, vertex.shape, other, radius);
+            if (mustTouch) {
+                solutions = filterSolutionsByFiniteExtent(solutions, shape1.shape, shape2.shape, plane);
+            }
+            const edges = toArcEdges(solutions, plane);
+            const endTangent = calculateTangent(solutions);
+            return {
+                edges,
+                endTangent
+            };
+        }
+        let solutions = this.getCurveCurveTangent(plane, shape1, shape2, radius);
+        if (mustTouch) {
+            solutions = filterSolutionsByFiniteExtent(solutions, shape1.shape, shape2.shape, plane);
+        }
+        const edges = toArcEdges(solutions, plane);
+        const endTangent = calculateTangent(solutions);
+        return {
+            edges,
+            endTangent
+        };
+    }
+    getCurveCurveTangent(plane, lineShape1, lineShape2, radius) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const curve1 = this.getCurve(lineShape1.shape);
+        const curve2 = this.getCurve(lineShape2.shape);
+        const qualifiedCurve1 = getQualifiedCurve(pln, curve1, lineShape1.qualifier);
+        const qualifiedCurve2 = getQualifiedCurve(pln, curve2, lineShape2.qualifier);
+        const solver = new oc.Geom2dGcc_Circ2d2TanRad(qualifiedCurve1, qualifiedCurve2, radius, tolerance);
+        const solutions = this.getSolutions(solver, plane);
+        disposePln();
+        return solutions;
+    }
+    getCurvePointTangent(plane, vertex, lineShape, radius) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const [pnt, disposePnt] = Convert.toGpPnt2d(vertex.toPoint2D());
+        const geom2dPnt = new oc.Geom2d_CartesianPoint(pnt);
+        const handle = new oc.Handle_Geom2d_Point(geom2dPnt);
+        disposePnt();
+        const curve = this.getCurve(lineShape.shape);
+        const qualifiedCurve = getQualifiedCurve(pln, curve, lineShape.qualifier);
+        const solver = new oc.Geom2dGcc_Circ2d2TanRad(qualifiedCurve, handle, radius, tolerance);
+        const solutions = this.getSolutions(solver, plane);
+        disposePln();
+        handle.delete();
+        return solutions;
+    }
+    getSolutions(solver, plane) {
+        const oc = getOC();
+        const result = [];
+        if (solver.IsDone()) {
+            for (let i = 1; i <= solver.NbSolutions(); i++) {
+                const circ2d = solver.ThisSolution(i);
+                const radius = circ2d.Radius();
+                const center = circ2d.Location();
+                const pnt1 = new oc.gp_Pnt2d();
+                const pnt2 = new oc.gp_Pnt2d();
+                solver.Tangency1(i, 0, 0, pnt1);
+                solver.Tangency2(i, 0, 0, pnt2);
+                result.push({
+                    center,
+                    radius,
+                    tangentPoint1: pnt1,
+                    tangentPoint2: pnt2
+                });
+            }
+        }
+        return result;
+    }
+    getCurve(shape) {
+        const oc = getOC();
+        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+        const curve = adaptor.Curve();
+        const handle = curve.Curve();
+        curve.delete();
+        adaptor.delete();
+        return handle;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { Edge } from "../../../common/edge.js";
+import { Shape } from "../../../common/shape.js";
+import { ConstraintQualifier } from "../../../features/2d/constraints/qualified-geometry.js";
+import { Plane } from "../../../math/plane.js";
+import { TangentLineSolver } from "../constraint-solver.js";
+export declare class CurveTangentLineSolver implements TangentLineSolver {
+    getTangentLines(plane: Plane, shape1: {
+        shape: Shape;
+        qualifier: ConstraintQualifier;
+    }, shape2: {
+        shape: Shape;
+        qualifier: ConstraintQualifier;
+    }, mustTouch: boolean): Edge[];
+    private getPointCurveTangent;
+    private getCurveCurveTangent;
+    private getSolutions;
+    private solutionsToEdges;
+    private getCurve;
+}