@mlightcad/geometry-engine 3.13.0 → 3.14.0

package/lib/geometry/AcGeCurveIntersect.js

@@ -0,0 +1,941 @@
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { AcGeBox3d, AcGePlane, AcGePoint3d, AcGeVector3d } from '../math';
+import { AcGeMathUtil, AcGeTol, DEFAULT_TOL, FLOAT_TOL, TAU } from '../util';
+import { AcGeCircArc3d } from './AcGeCircArc3d';
+import { AcGeEllipseArc3d } from './AcGeEllipseArc3d';
+var SPLINE_SAMPLE_COUNT = 128;
+var PLANAR_SAMPLE_COUNT = 96;
+var POINT_TOL = DEFAULT_TOL.equalPointTol;
+var REFINE_TOL = POINT_TOL * 8;
+/**
+ * Finds intersection points between two sets of curve primitives.
+ *
+ * `extendA` / `extendB` correspond to ObjectARX `AcDb::Intersect` flags for
+ * the two operands. A primitive is only extended when `extendable` is not
+ * `false`. Overlapping coincident curves do not produce a continuum of points.
+ *
+ * When `projPlane` is provided, both operands are projected onto that plane
+ * first (apparent intersection). Result points lie on the plane.
+ *
+ * @param a - Primitives from the first operand
+ * @param b - Primitives from the second operand
+ * @param extendA - Extend the first operand when its primitives allow it
+ * @param extendB - Extend the second operand when its primitives allow it
+ * @param projPlane - Optional projection plane for apparent intersection
+ * @returns Intersection points in WCS, de-duplicated by the equal-point tolerance
+ */
+export function acgeIntersectCurves(a, b, extendA, extendB, projPlane) {
+    var e_1, _a, e_2, _b;
+    if (extendA === void 0) { extendA = false; }
+    if (extendB === void 0) { extendB = false; }
+    var left = flattenPrimitives(a, extendA, projPlane);
+    var right = flattenPrimitives(b, extendB, projPlane);
+    var points = [];
+    try {
+        for (var left_1 = __values(left), left_1_1 = left_1.next(); !left_1_1.done; left_1_1 = left_1.next()) {
+            var pa = left_1_1.value;
+            try {
+                for (var right_1 = (e_2 = void 0, __values(right)), right_1_1 = right_1.next(); !right_1_1.done; right_1_1 = right_1.next()) {
+                    var pb = right_1_1.value;
+                    if (!boxesMayIntersect(pa, pb))
+                        continue;
+                    appendPoints(points, intersectPrepared(pa, pb));
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (right_1_1 && !right_1_1.done && (_b = right_1.return)) _b.call(right_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (left_1_1 && !left_1_1.done && (_a = left_1.return)) _a.call(left_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return dedupePoints(points);
+}
+/**
+ * Returns a transformed copy of a curve primitive.
+ */
+export function acgeTransformIntersectPrimitive(primitive, matrix) {
+    var cloned = acgeCloneIntersectPrimitive(primitive);
+    switch (cloned.kind) {
+        case 'line':
+            cloned.line.transform(matrix);
+            return cloned;
+        case 'circArc':
+            cloned.arc.transform(matrix);
+            return cloned;
+        case 'ellipseArc':
+            cloned.arc.transform(matrix);
+            return cloned;
+        case 'spline':
+            cloned.spline.transform(matrix);
+            return cloned;
+    }
+}
+/**
+ * Returns a deep-cloned curve primitive.
+ */
+export function acgeCloneIntersectPrimitive(primitive) {
+    switch (primitive.kind) {
+        case 'line':
+            return {
+                kind: 'line',
+                line: primitive.line.clone(),
+                extent: primitive.extent,
+                extendable: primitive.extendable
+            };
+        case 'circArc':
+            return {
+                kind: 'circArc',
+                arc: primitive.arc.clone(),
+                extendable: primitive.extendable
+            };
+        case 'ellipseArc':
+            return {
+                kind: 'ellipseArc',
+                arc: primitive.arc.clone(),
+                extendable: primitive.extendable
+            };
+        case 'spline':
+            return {
+                kind: 'spline',
+                spline: primitive.spline.clone(),
+                extendable: primitive.extendable
+            };
+    }
+}
+function flattenPrimitives(primitives, extend, projPlane) {
+    var e_3, _a;
+    var result = [];
+    try {
+        for (var primitives_1 = __values(primitives), primitives_1_1 = primitives_1.next(); !primitives_1_1.done; primitives_1_1 = primitives_1.next()) {
+            var primitive = primitives_1_1.value;
+            var shouldExtend = extend && primitive.extendable !== false;
+            switch (primitive.kind) {
+                case 'line': {
+                    var line = projectLine(primitive.line, projPlane);
+                    if (!line)
+                        break;
+                    var extent = shouldExtend ? 'unbounded' : primitive.extent;
+                    result.push(prepareLine(line.start, line.end, extent));
+                    break;
+                }
+                case 'circArc': {
+                    var expanded = expandCircArc(primitive.arc, shouldExtend);
+                    if (projPlane && !planesParallel(expanded.normal, projPlane.normal)) {
+                        var projected = projectCircleOntoPlane(expanded, projPlane);
+                        if ((projected === null || projected === void 0 ? void 0 : projected.kind) === 'circArc') {
+                            result.push(prepareCircArc(projected.arc, isFullCircArc(projected.arc)));
+                        }
+                        else if ((projected === null || projected === void 0 ? void 0 : projected.kind) === 'ellipseArc') {
+                            result.push(prepareEllipseArc(projected.arc, isFullEllipseArc(projected.arc)));
+                        }
+                        else {
+                            appendSampledCurve(result, sampleCircArc(expanded, isFullCircArc(expanded)), isFullCircArc(expanded), projPlane);
+                        }
+                    }
+                    else {
+                        var projected = projectCircArc(expanded, projPlane);
+                        if (projected) {
+                            result.push(prepareCircArc(projected, isFullCircArc(projected)));
+                        }
+                    }
+                    break;
+                }
+                case 'ellipseArc': {
+                    var expanded = expandEllipseArc(primitive.arc, shouldExtend);
+                    if (projPlane && !planesParallel(expanded.normal, projPlane.normal)) {
+                        appendSampledCurve(result, sampleEllipseArc(expanded, isFullEllipseArc(expanded)), isFullEllipseArc(expanded), projPlane);
+                    }
+                    else {
+                        var projected = projectEllipseArc(expanded, projPlane);
+                        if (projected) {
+                            result.push(prepareEllipseArc(projected, isFullEllipseArc(projected)));
+                        }
+                    }
+                    break;
+                }
+                case 'spline': {
+                    if (projPlane) {
+                        appendSampledCurve(result, primitive.spline.getPoints(SPLINE_SAMPLE_COUNT), primitive.spline.closed, projPlane);
+                    }
+                    else {
+                        result.push(prepareSpline(primitive.spline));
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (primitives_1_1 && !primitives_1_1.done && (_a = primitives_1.return)) _a.call(primitives_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return result;
+}
+function prepareLine(start, end, extent) {
+    var dir = new AcGeVector3d().subVectors(end, start);
+    return {
+        kind: 'line',
+        start: start,
+        dir: dir,
+        extent: extent,
+        box: extent === 'bounded'
+            ? new AcGeBox3d().setFromPoints([start, end])
+            : undefined
+    };
+}
+function prepareCircArc(arc, full) {
+    return {
+        kind: 'circArc',
+        arc: arc,
+        full: full || isFullCircArc(arc),
+        box: arc.box
+    };
+}
+function prepareEllipseArc(arc, full) {
+    return {
+        kind: 'ellipseArc',
+        arc: arc,
+        full: full || isFullEllipseArc(arc),
+        box: arc.box
+    };
+}
+function prepareSpline(spline) {
+    var e_4, _a;
+    var samples = [];
+    var points = spline.getPoints(SPLINE_SAMPLE_COUNT);
+    if (points.length >= 2) {
+        var count = spline.closed ? points.length : points.length - 1;
+        for (var i = 0; i < count; i++) {
+            var start = points[i];
+            var end = points[(i + 1) % points.length];
+            if (start.distanceToSquared(end) < POINT_TOL * POINT_TOL)
+                continue;
+            samples.push(prepareLine(start.clone(), end.clone(), 'bounded'));
+        }
+    }
+    var box = new AcGeBox3d();
+    try {
+        for (var samples_1 = __values(samples), samples_1_1 = samples_1.next(); !samples_1_1.done; samples_1_1 = samples_1.next()) {
+            var sample = samples_1_1.value;
+            if (sample.box)
+                box.union(sample.box);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (samples_1_1 && !samples_1_1.done && (_a = samples_1.return)) _a.call(samples_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return {
+        kind: 'spline',
+        spline: spline,
+        samples: samples,
+        box: samples.length > 0 ? box : undefined
+    };
+}
+function expandCircArc(arc, extend) {
+    if (!extend || isFullCircArc(arc))
+        return arc;
+    return new AcGeCircArc3d(arc.center, arc.radius, 0, TAU, arc.normal, arc.refVec);
+}
+function expandEllipseArc(arc, extend) {
+    if (!extend || isFullEllipseArc(arc))
+        return arc;
+    return new AcGeEllipseArc3d(arc.center, arc.normal, arc.majorAxis, arc.majorAxisRadius, arc.minorAxisRadius, 0, TAU);
+}
+function projectLine(line, plane) {
+    if (!plane) {
+        return { start: line.startPoint.clone(), end: line.endPoint.clone() };
+    }
+    var start = projectPointToPlane(line.startPoint, plane);
+    var end = projectPointToPlane(line.endPoint, plane);
+    if (start.distanceToSquared(end) < POINT_TOL * POINT_TOL)
+        return null;
+    return { start: start, end: end };
+}
+function projectCircArc(arc, plane) {
+    if (!plane)
+        return arc;
+    var center = projectPointToPlane(arc.center, plane);
+    return new AcGeCircArc3d(center, arc.radius, arc.startAngle, arc.endAngle, plane.normal.clone(), projectDirectionToPlane(arc.refVec, plane.normal));
+}
+/**
+ * Orthogonal projection of a circular arc onto `plane`. Parallel planes keep a
+ * circle; a tilted circle becomes an ellipse. A circle whose plane is
+ * perpendicular to `plane` degenerates to a segment and returns null so the
+ * caller can sample.
+ */
+function projectCircleOntoPlane(arc, plane) {
+    var center = projectPointToPlane(arc.center, plane);
+    var n = arc.normal.clone();
+    if (n.lengthSq() < POINT_TOL * POINT_TOL)
+        return null;
+    n.normalize();
+    var p = plane.normal.clone();
+    if (p.lengthSq() < POINT_TOL * POINT_TOL)
+        return null;
+    p.normalize();
+    var cos = n.dot(p);
+    var absCos = Math.abs(cos);
+    if (absCos > 1 - 1e-8) {
+        return {
+            kind: 'circArc',
+            arc: new AcGeCircArc3d(center, arc.radius, arc.startAngle, arc.endAngle, p, projectDirectionToPlane(arc.refVec, p))
+        };
+    }
+    if (absCos < 1e-8)
+        return null;
+    var hinge = new AcGeVector3d().crossVectors(n, p);
+    if (hinge.lengthSq() < POINT_TOL * POINT_TOL)
+        return null;
+    hinge.normalize();
+    var ellipse = new AcGeEllipseArc3d(center, p, hinge, arc.radius, arc.radius * absCos, 0, TAU);
+    if (isFullCircArc(arc)) {
+        return { kind: 'ellipseArc', arc: ellipse };
+    }
+    var start = projectPointToPlane(arc.startPoint, plane);
+    var end = projectPointToPlane(arc.endPoint, plane);
+    var mid = projectPointToPlane(arc.midPoint, plane);
+    var startAngle = ellipseArcAngle(ellipse, start);
+    var endAngle = ellipseArcAngle(ellipse, end);
+    var midAngle = ellipseArcAngle(ellipse, mid);
+    var tMid = AcGeMathUtil.normalizeAngle(midAngle - startAngle);
+    var tEnd = AcGeMathUtil.normalizeAngle(endAngle - startAngle);
+    var sweepEnd = tMid <= tEnd || tEnd < 1e-8 ? startAngle + tEnd : startAngle + tEnd + TAU;
+    return {
+        kind: 'ellipseArc',
+        arc: new AcGeEllipseArc3d(center, p, hinge, arc.radius, arc.radius * absCos, startAngle, sweepEnd)
+    };
+}
+function projectEllipseArc(arc, plane) {
+    if (!plane)
+        return arc;
+    var center = projectPointToPlane(arc.center, plane);
+    var major = projectDirectionToPlane(arc.majorAxis, plane.normal);
+    if (major.lengthSq() < POINT_TOL * POINT_TOL)
+        return null;
+    return new AcGeEllipseArc3d(center, plane.normal.clone(), major, arc.majorAxisRadius, arc.minorAxisRadius, arc.startAngle, arc.endAngle);
+}
+function appendSampledCurve(result, samples, closed, projPlane) {
+    if (samples.length < 2)
+        return;
+    var points = projPlane
+        ? samples.map(function (point) { return projectPointToPlane(point, projPlane); })
+        : samples;
+    var count = closed ? points.length : points.length - 1;
+    for (var i = 0; i < count; i++) {
+        var start = points[i];
+        var end = points[(i + 1) % points.length];
+        if (start.distanceToSquared(end) < POINT_TOL * POINT_TOL)
+            continue;
+        result.push(prepareLine(start.clone(), end.clone(), 'bounded'));
+    }
+}
+function sampleCircArc(arc, full) {
+    if (full || isFullCircArc(arc)) {
+        return new AcGeCircArc3d(arc.center, arc.radius, 0, TAU, arc.normal, arc.refVec).getPoints(PLANAR_SAMPLE_COUNT);
+    }
+    return arc.getPoints(PLANAR_SAMPLE_COUNT);
+}
+function sampleEllipseArc(arc, full) {
+    if (full || isFullEllipseArc(arc)) {
+        return new AcGeEllipseArc3d(arc.center, arc.normal, arc.majorAxis, arc.majorAxisRadius, arc.minorAxisRadius, 0, TAU).getPoints(PLANAR_SAMPLE_COUNT);
+    }
+    return arc.getPoints(PLANAR_SAMPLE_COUNT);
+}
+function boxesMayIntersect(a, b) {
+    if (!a.box || !b.box)
+        return true;
+    return a.box.intersectsBox(b.box);
+}
+function intersectPrepared(a, b) {
+    if (a.kind === 'spline' && b.kind === 'spline') {
+        return intersectSplineSpline(a, b);
+    }
+    if (a.kind === 'spline')
+        return intersectSplineOther(a, b);
+    if (b.kind === 'spline')
+        return intersectSplineOther(b, a);
+    if (a.kind === 'line' && b.kind === 'line')
+        return intersectLineLine(a, b);
+    if (a.kind === 'line' && b.kind === 'circArc') {
+        return intersectLineCircArc(a, b.arc, b.full);
+    }
+    if (b.kind === 'line' && a.kind === 'circArc') {
+        return intersectLineCircArc(b, a.arc, a.full);
+    }
+    if (a.kind === 'line' && b.kind === 'ellipseArc') {
+        return intersectLineEllipseArc(a, b.arc, b.full);
+    }
+    if (b.kind === 'line' && a.kind === 'ellipseArc') {
+        return intersectLineEllipseArc(b, a.arc, a.full);
+    }
+    if (a.kind === 'circArc' && b.kind === 'circArc') {
+        return intersectCircCirc(a.arc, a.full, b.arc, b.full);
+    }
+    if (a.kind === 'circArc' && b.kind === 'ellipseArc') {
+        return intersectCircEllipse(a.arc, a.full, b.arc, b.full);
+    }
+    if (a.kind === 'ellipseArc' && b.kind === 'circArc') {
+        return intersectCircEllipse(b.arc, b.full, a.arc, a.full);
+    }
+    if (a.kind === 'ellipseArc' && b.kind === 'ellipseArc') {
+        return intersectEllipseEllipse(a.arc, a.full, b.arc, b.full);
+    }
+    return [];
+}
+function intersectSplineOther(spline, other) {
+    var e_5, _a;
+    var hits = [];
+    try {
+        for (var _b = __values(spline.samples), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var sample = _c.value;
+            if (!boxesMayIntersect(sample, other))
+                continue;
+            appendPoints(hits, intersectPrepared(sample, other));
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return refineSplineHits(spline.spline, hits, other);
+}
+function intersectSplineSpline(a, b) {
+    var e_6, _a, e_7, _b, e_8, _c;
+    var hits = [];
+    try {
+        for (var _d = __values(a.samples), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var sa = _e.value;
+            try {
+                for (var _f = (e_7 = void 0, __values(b.samples)), _g = _f.next(); !_g.done; _g = _f.next()) {
+                    var sb = _g.value;
+                    if (!boxesMayIntersect(sa, sb))
+                        continue;
+                    appendPoints(hits, intersectLineLine(sa, sb));
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    var points = [];
+    try {
+        for (var hits_1 = __values(hits), hits_1_1 = hits_1.next(); !hits_1_1.done; hits_1_1 = hits_1.next()) {
+            var hit = hits_1_1.value;
+            var pa = a.spline.nearestPoint(hit, SPLINE_SAMPLE_COUNT);
+            var pb = b.spline.nearestPoint(hit, SPLINE_SAMPLE_COUNT);
+            if (pa.distanceTo(pb) <= REFINE_TOL)
+                points.push(pa);
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (hits_1_1 && !hits_1_1.done && (_c = hits_1.return)) _c.call(hits_1);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    return points;
+}
+function refineSplineHits(spline, hits, other) {
+    var e_9, _a;
+    var points = [];
+    try {
+        for (var hits_2 = __values(hits), hits_2_1 = hits_2.next(); !hits_2_1.done; hits_2_1 = hits_2.next()) {
+            var hit = hits_2_1.value;
+            var refined = spline.nearestPoint(hit, SPLINE_SAMPLE_COUNT);
+            if (distanceToPrepared(other, refined) <= REFINE_TOL) {
+                points.push(refined);
+            }
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (hits_2_1 && !hits_2_1.done && (_a = hits_2.return)) _a.call(hits_2);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+    return points;
+}
+function distanceToPrepared(primitive, point) {
+    if (primitive.kind === 'line') {
+        var dirLenSq = primitive.dir.lengthSq();
+        if (dirLenSq < POINT_TOL * POINT_TOL)
+            return Number.POSITIVE_INFINITY;
+        var t = new AcGeVector3d().subVectors(point, primitive.start).dot(primitive.dir) /
+            dirLenSq;
+        if (!isParamOnExtent(t, primitive.extent))
+            return Number.POSITIVE_INFINITY;
+        return pointOnLine(primitive.start, primitive.dir, t).distanceTo(point);
+    }
+    if (primitive.kind === 'circArc') {
+        if (!isPointOnCircle(point, primitive.arc)) {
+            var plane = planeFromNormalAndPoint(primitive.arc.normal, primitive.arc.center);
+            var planar = Math.abs(plane.distanceToPoint(point));
+            var radial = Math.abs(point.distanceTo(primitive.arc.center) - primitive.arc.radius);
+            var off = Math.hypot(planar, radial);
+            if (off > REFINE_TOL)
+                return off;
+        }
+        return isAngleOnCircArc(primitive.arc, circArcAngle(primitive.arc, point), primitive.full)
+            ? 0
+            : Number.POSITIVE_INFINITY;
+    }
+    if (primitive.kind === 'ellipseArc') {
+        return isPointOnEllipse(point, primitive.arc, primitive.full)
+            ? 0
+            : Math.abs(ellipseImplicit(primitive.arc, point));
+    }
+    return Number.POSITIVE_INFINITY;
+}
+function intersectLineLine(a, b) {
+    var d1 = a.dir;
+    var d2 = b.dir;
+    var len1Sq = d1.lengthSq();
+    var len2Sq = d2.lengthSq();
+    if (len1Sq < POINT_TOL * POINT_TOL || len2Sq < POINT_TOL * POINT_TOL) {
+        return [];
+    }
+    var w0 = new AcGeVector3d().subVectors(a.start, b.start);
+    var aa = d1.dot(d1);
+    var bb = d1.dot(d2);
+    var cc = d2.dot(d2);
+    var dd = d1.dot(w0);
+    var ee = d2.dot(w0);
+    var denom = aa * cc - bb * bb;
+    if (Math.abs(denom) < FLOAT_TOL * FLOAT_TOL * aa * cc) {
+        return [];
+    }
+    var t = (bb * ee - cc * dd) / denom;
+    var s = (aa * ee - bb * dd) / denom;
+    if (!isParamOnExtent(t, a.extent) || !isParamOnExtent(s, b.extent)) {
+        return [];
+    }
+    var p = pointOnLine(a.start, d1, t);
+    var q = pointOnLine(b.start, d2, s);
+    if (p.distanceTo(q) > POINT_TOL)
+        return [];
+    return [p];
+}
+function intersectLineCircArc(line, arc, full) {
+    var plane = planeFromNormalAndPoint(arc.normal, arc.center);
+    var hit = intersectLineWithPlane(line, plane);
+    if (hit === 'coplanar') {
+        return intersectCoplanarLineCircle(line, arc, full);
+    }
+    if (!hit)
+        return [];
+    if (!isPointOnCircle(hit, arc))
+        return [];
+    if (!isAngleOnCircArc(arc, circArcAngle(arc, hit), full))
+        return [];
+    return [hit];
+}
+function intersectCoplanarLineCircle(line, arc, full) {
+    var e_10, _a;
+    var f = new AcGeVector3d().subVectors(line.start, arc.center);
+    var a = line.dir.dot(line.dir);
+    if (a < POINT_TOL * POINT_TOL)
+        return [];
+    var b = 2 * line.dir.dot(f);
+    var c = f.dot(f) - arc.radius * arc.radius;
+    var points = [];
+    try {
+        for (var _b = __values(solveQuadratic(a, b, c)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var t = _c.value;
+            if (!isParamOnExtent(t, line.extent))
+                continue;
+            var point = pointOnLine(line.start, line.dir, t);
+            if (!isAngleOnCircArc(arc, circArcAngle(arc, point), full))
+                continue;
+            points.push(point);
+        }
+    }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_10) throw e_10.error; }
+    }
+    return points;
+}
+function intersectLineEllipseArc(line, arc, full) {
+    var plane = planeFromNormalAndPoint(arc.normal, arc.center);
+    var hit = intersectLineWithPlane(line, plane);
+    if (hit === 'coplanar') {
+        return intersectCoplanarLineEllipse(line, arc, full);
+    }
+    if (!hit)
+        return [];
+    if (!isPointOnEllipse(hit, arc, full))
+        return [];
+    return [hit];
+}
+function intersectCoplanarLineEllipse(line, arc, full) {
+    var e_11, _a;
+    var u = arc.majorAxis;
+    var v = arc.minorAxis;
+    var a = arc.majorAxisRadius;
+    var b = arc.minorAxisRadius;
+    if (a < POINT_TOL || b < POINT_TOL)
+        return [];
+    var startOffset = new AcGeVector3d().subVectors(line.start, arc.center);
+    var x0 = startOffset.dot(u);
+    var y0 = startOffset.dot(v);
+    var dx = line.dir.dot(u);
+    var dy = line.dir.dot(v);
+    var A = (dx * dx) / (a * a) + (dy * dy) / (b * b);
+    var B = (2 * x0 * dx) / (a * a) + (2 * y0 * dy) / (b * b);
+    var C = (x0 * x0) / (a * a) + (y0 * y0) / (b * b) - 1;
+    var points = [];
+    try {
+        for (var _b = __values(solveQuadratic(A, B, C)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var t = _c.value;
+            if (!isParamOnExtent(t, line.extent))
+                continue;
+            var point = pointOnLine(line.start, line.dir, t);
+            if (!isAngleOnEllipseArc(arc, ellipseArcAngle(arc, point), full))
+                continue;
+            points.push(point);
+        }
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_11) throw e_11.error; }
+    }
+    return points;
+}
+function intersectCircCirc(a, fullA, b, fullB) {
+    if (planesParallel(a.normal, b.normal)) {
+        var planeA = planeFromNormalAndPoint(a.normal, a.center);
+        if (Math.abs(planeA.distanceToPoint(b.center)) > POINT_TOL)
+            return [];
+        return filterCircPoints(intersectCoplanarCircles(a, b), a, fullA, b, fullB);
+    }
+    var line = planePlaneIntersectionLine(planeFromNormalAndPoint(a.normal, a.center), planeFromNormalAndPoint(b.normal, b.center));
+    if (!line)
+        return [];
+    var prepared = prepareLine(line.point.clone(), new AcGePoint3d().addVectors(line.point, line.dir), 'unbounded');
+    var onA = intersectLineCircArc(prepared, a, fullA);
+    return onA.filter(function (point) {
+        if (!isPointOnCircle(point, b))
+            return false;
+        return isAngleOnCircArc(b, circArcAngle(b, point), fullB);
+    });
+}
+function intersectCoplanarCircles(a, b) {
+    var offset = new AcGeVector3d().subVectors(b.center, a.center);
+    var dist = offset.length();
+    var r1 = a.radius;
+    var r2 = b.radius;
+    if (dist < POINT_TOL && AcGeTol.equal(r1, r2, POINT_TOL))
+        return [];
+    if (dist > r1 + r2 + POINT_TOL)
+        return [];
+    if (dist + Math.min(r1, r2) + POINT_TOL < Math.max(r1, r2))
+        return [];
+    var dir = dist < POINT_TOL ? perpInPlane(a.normal) : offset.clone().normalize();
+    var x = (r1 * r1 - r2 * r2 + dist * dist) / (2 * Math.max(dist, POINT_TOL));
+    var hSq = r1 * r1 - x * x;
+    var p = new AcGePoint3d().copy(a.center).addScaledVector(dir, x);
+    if (hSq < -POINT_TOL * POINT_TOL)
+        return [];
+    if (hSq < POINT_TOL * POINT_TOL)
+        return [p];
+    var h = Math.sqrt(Math.max(0, hSq));
+    var perp = new AcGeVector3d().crossVectors(a.normal, dir).normalize();
+    return [
+        new AcGePoint3d().copy(p).addScaledVector(perp, h),
+        new AcGePoint3d().copy(p).addScaledVector(perp, -h)
+    ];
+}
+function intersectCircEllipse(circle, fullCircle, ellipse, fullEllipse) {
+    if (!planesParallel(circle.normal, ellipse.normal)) {
+        var line = planePlaneIntersectionLine(planeFromNormalAndPoint(circle.normal, circle.center), planeFromNormalAndPoint(ellipse.normal, ellipse.center));
+        if (!line)
+            return [];
+        var prepared = prepareLine(line.point.clone(), new AcGePoint3d().addVectors(line.point, line.dir), 'unbounded');
+        return intersectLineCircArc(prepared, circle, fullCircle).filter(function (point) {
+            return isPointOnEllipse(point, ellipse, fullEllipse);
+        });
+    }
+    return intersectPlanarImplicit(sampleCircArc(circle, fullCircle), isFullCircArc(circle) || fullCircle, function (point) { return ellipseImplicit(ellipse, point); }, function (point) {
+        return isAngleOnCircArc(circle, circArcAngle(circle, point), fullCircle) &&
+            isPointOnEllipse(point, ellipse, fullEllipse);
+    });
+}
+function intersectEllipseEllipse(a, fullA, b, fullB) {
+    if (!planesParallel(a.normal, b.normal)) {
+        var line = planePlaneIntersectionLine(planeFromNormalAndPoint(a.normal, a.center), planeFromNormalAndPoint(b.normal, b.center));
+        if (!line)
+            return [];
+        var prepared = prepareLine(line.point.clone(), new AcGePoint3d().addVectors(line.point, line.dir), 'unbounded');
+        return intersectLineEllipseArc(prepared, a, fullA).filter(function (point) {
+            return isPointOnEllipse(point, b, fullB);
+        });
+    }
+    return intersectPlanarImplicit(sampleEllipseArc(a, fullA), isFullEllipseArc(a) || fullA, function (point) { return ellipseImplicit(b, point); }, function (point) {
+        return isAngleOnEllipseArc(a, ellipseArcAngle(a, point), fullA) &&
+            isPointOnEllipse(point, b, fullB);
+    });
+}
+function intersectPlanarImplicit(samples, closed, implicit, accept) {
+    var points = [];
+    var count = closed ? samples.length : samples.length - 1;
+    for (var i = 0; i < count; i++) {
+        var p0 = samples[i];
+        var p1 = samples[(i + 1) % samples.length];
+        var e0 = implicit(p0);
+        var e1 = implicit(p1);
+        if (Math.abs(e0) <= POINT_TOL) {
+            if (accept(p0))
+                points.push(p0.clone());
+            continue;
+        }
+        if (e0 * e1 > 0)
+            continue;
+        var lo = 0;
+        var hi = 1;
+        var loVal = e0;
+        for (var step = 0; step < 40; step++) {
+            var mid = (lo + hi) / 2;
+            var midPoint = new AcGePoint3d().lerpVectors(p0, p1, mid);
+            var midVal = implicit(midPoint);
+            if (loVal * midVal <= 0) {
+                hi = mid;
+            }
+            else {
+                lo = mid;
+                loVal = midVal;
+            }
+        }
+        var hit = new AcGePoint3d().lerpVectors(p0, p1, (lo + hi) / 2);
+        if (accept(hit))
+            points.push(hit);
+    }
+    return points;
+}
+function intersectLineWithPlane(line, plane) {
+    var denom = plane.normal.dot(line.dir);
+    var dist = plane.distanceToPoint(line.start);
+    if (AcGeTol.equalToZero(denom, POINT_TOL * Math.max(1, line.dir.length()))) {
+        return AcGeTol.equalToZero(dist, POINT_TOL) ? 'coplanar' : null;
+    }
+    var t = -dist / denom;
+    if (!isParamOnExtent(t, line.extent))
+        return null;
+    return pointOnLine(line.start, line.dir, t);
+}
+function planePlaneIntersectionLine(a, b) {
+    var dir = new AcGeVector3d().crossVectors(a.normal, b.normal);
+    if (dir.lengthSq() < POINT_TOL * POINT_TOL)
+        return null;
+    dir.normalize();
+    var n1 = a.normal;
+    var n2 = b.normal;
+    var det = n1.dot(n1) * n2.dot(n2) - Math.pow(n1.dot(n2), 2);
+    if (Math.abs(det) < FLOAT_TOL)
+        return null;
+    var c1 = -a.constant;
+    var c2 = -b.constant;
+    var x = (n2.dot(n2) * c1 - n1.dot(n2) * c2) / det;
+    var y = (n1.dot(n1) * c2 - n1.dot(n2) * c1) / det;
+    var point = new AcGePoint3d().addScaledVector(n1, x).addScaledVector(n2, y);
+    return { point: point, dir: dir };
+}
+function isParamOnExtent(t, extent) {
+    if (extent === 'unbounded')
+        return true;
+    if (extent === 'ray')
+        return t >= -POINT_TOL;
+    return t >= -POINT_TOL && t <= 1 + POINT_TOL;
+}
+function pointOnLine(start, dir, t) {
+    return new AcGePoint3d().copy(start).addScaledVector(dir, t);
+}
+function projectPointToPlane(point, plane) {
+    var target = new AcGePoint3d();
+    plane.projectPoint(point, target);
+    return target;
+}
+function projectDirectionToPlane(dir, planeNormal) {
+    var projected = dir
+        .clone()
+        .addScaledVector(planeNormal, -dir.dot(planeNormal));
+    if (projected.lengthSq() < POINT_TOL * POINT_TOL) {
+        return perpInPlane(planeNormal);
+    }
+    return projected.normalize();
+}
+function planeFromNormalAndPoint(normal, point) {
+    return new AcGePlane().setFromNormalAndCoplanarPoint(normal, point);
+}
+function planesParallel(a, b) {
+    return (new AcGeVector3d().crossVectors(a, b).lengthSq() < POINT_TOL * POINT_TOL);
+}
+function circArcAngle(arc, point) {
+    var vec = new AcGeVector3d().subVectors(point, arc.center);
+    var ortho = new AcGeVector3d().crossVectors(arc.normal, arc.refVec);
+    return Math.atan2(vec.dot(ortho), vec.dot(arc.refVec));
+}
+function ellipseArcAngle(arc, point) {
+    var offset = new AcGeVector3d().subVectors(point, arc.center);
+    var x = offset.dot(arc.majorAxis) / arc.majorAxisRadius;
+    var y = offset.dot(arc.minorAxis) / arc.minorAxisRadius;
+    return Math.atan2(y, x);
+}
+function isFullCircArc(arc) {
+    return arc.closed || Math.abs(arc.deltaAngle - TAU) < 1e-10;
+}
+function isFullEllipseArc(arc) {
+    return (arc.closed ||
+        Math.abs(arc.endAngle - arc.startAngle) < 1e-10 ||
+        Math.abs(arc.deltaAngle - TAU) < 1e-10);
+}
+function isAngleOnCircArc(arc, angle, full) {
+    if (full || isFullCircArc(arc))
+        return true;
+    var t = AcGeMathUtil.normalizeAngle(angle - arc.startAngle);
+    return t <= arc.deltaAngle + 1e-8;
+}
+function isAngleOnEllipseArc(arc, angle, full) {
+    if (full || isFullEllipseArc(arc))
+        return true;
+    var t = AcGeMathUtil.normalizeAngle(angle - arc.startAngle);
+    return t <= arc.deltaAngle + 1e-8;
+}
+function isPointOnCircle(point, arc) {
+    var plane = planeFromNormalAndPoint(arc.normal, arc.center);
+    if (Math.abs(plane.distanceToPoint(point)) > POINT_TOL)
+        return false;
+    return Math.abs(point.distanceTo(arc.center) - arc.radius) <= POINT_TOL;
+}
+function ellipseImplicit(arc, point) {
+    var offset = new AcGeVector3d().subVectors(point, arc.center);
+    var x = offset.dot(arc.majorAxis) / arc.majorAxisRadius;
+    var y = offset.dot(arc.minorAxis) / arc.minorAxisRadius;
+    return x * x + y * y - 1;
+}
+function isPointOnEllipse(point, arc, full) {
+    var plane = planeFromNormalAndPoint(arc.normal, arc.center);
+    if (Math.abs(plane.distanceToPoint(point)) > POINT_TOL)
+        return false;
+    if (Math.abs(ellipseImplicit(arc, point)) > 1e-4)
+        return false;
+    return isAngleOnEllipseArc(arc, ellipseArcAngle(arc, point), full);
+}
+function filterCircPoints(points, a, fullA, b, fullB) {
+    return points.filter(function (point) {
+        return isAngleOnCircArc(a, circArcAngle(a, point), fullA) &&
+            isAngleOnCircArc(b, circArcAngle(b, point), fullB);
+    });
+}
+function perpInPlane(normal) {
+    var axis = Math.abs(normal.x) < 0.9 ? AcGeVector3d.X_AXIS : AcGeVector3d.Y_AXIS;
+    var perp = new AcGeVector3d().crossVectors(normal, axis);
+    if (perp.lengthSq() < POINT_TOL * POINT_TOL) {
+        perp.crossVectors(normal, AcGeVector3d.Z_AXIS);
+    }
+    return perp.normalize();
+}
+function solveQuadratic(a, b, c) {
+    if (Math.abs(a) < FLOAT_TOL) {
+        if (Math.abs(b) < FLOAT_TOL)
+            return [];
+        return [-c / b];
+    }
+    var disc = b * b - 4 * a * c;
+    if (disc < -POINT_TOL)
+        return [];
+    if (disc < POINT_TOL)
+        return [-b / (2 * a)];
+    var sqrtDisc = Math.sqrt(Math.max(0, disc));
+    return [(-b - sqrtDisc) / (2 * a), (-b + sqrtDisc) / (2 * a)];
+}
+function appendPoints(target, points) {
+    var e_12, _a;
+    try {
+        for (var points_1 = __values(points), points_1_1 = points_1.next(); !points_1_1.done; points_1_1 = points_1.next()) {
+            var point = points_1_1.value;
+            target.push(point);
+        }
+    }
+    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+    finally {
+        try {
+            if (points_1_1 && !points_1_1.done && (_a = points_1.return)) _a.call(points_1);
+        }
+        finally { if (e_12) throw e_12.error; }
+    }
+}
+function dedupePoints(points) {
+    var e_13, _a;
+    var unique = [];
+    var _loop_1 = function (point) {
+        if (unique.some(function (existing) { return existing.distanceTo(point) <= POINT_TOL; })) {
+            return "continue";
+        }
+        unique.push(point);
+    };
+    try {
+        for (var points_2 = __values(points), points_2_1 = points_2.next(); !points_2_1.done; points_2_1 = points_2.next()) {
+            var point = points_2_1.value;
+            _loop_1(point);
+        }
+    }
+    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    finally {
+        try {
+            if (points_2_1 && !points_2_1.done && (_a = points_2.return)) _a.call(points_2);
+        }
+        finally { if (e_13) throw e_13.error; }
+    }
+    return unique;
+}
+//# sourceMappingURL=AcGeCurveIntersect.js.map