二次贝塞尔曲线与直线相交算法特定值下失效的解决求助

基于StackOverflow方案实现的二次贝塞尔曲线与直线相交检测方法，多数场景运行正常，但在特定坐标组合下无法识别预期交点：

• 直线参数：[{"x":350,"y":350},{"x":608,"y":608}]
• 二次贝塞尔曲线参数：[{"x":1024,"y":-40},{"x":569,"y":569},{"x":-40,"y":1024}]
• 预期交点：[{"x":530.5,"y":530.5}]
• 实际返回：空数组

经排查，问题源于计算时变量a的值为0（直线与曲线的二次项方向垂直），此时原代码的二次方程求解逻辑失效，需要单独处理该边界情况。

解决方案：添加a=0的分支处理 #

当a=0时，原二次方程退化为一次方程（甚至常数方程），需要针对性求解：

1. 若a=0且b=0：检查常数项是否为0，若为0则曲线与直线重合（可根据需求返回范围内的点）；若不为0则无交点。
2. 若a=0且b≠0：解一次方程b*t + c = 0得到t值，再进行后续的t∈[0,1]和边界范围检查。

修改后的完整代码如下：

export type PointXY = {x: number, y: number};
const lerp = (a: number, b: number, t: number) => (a + t * (b - a));
export const quadraticIntersectsLine = (p1: PointXY, p2: PointXY, p3: PointXY, a1: PointXY, a2: PointXY) => {
    let intersections: PointXY[] = [];
    // inverse line normal
    let normal = {x: a1.y - a2.y, y: a2.x - a1.x};

    // Q-coefficients
    let c2 = {x: p1.x + p2.x * -2 + p3.x, y: p1.y + p2.y * -2 + p3.y};
    let c1 = {x: p1.x * -2 + p2.x * 2, y: p1.y * -2 + p2.y * 2};
    let c0 = {x: p1.x, y: p1.y};

    // Transform to line
    let coefficient = a1.x * a2.y - a2.x * a1.y;
    let a = normal.x * c2.x + normal.y * c2.y;
    let bVal = normal.x * c1.x + normal.y * c1.y;
    let cVal = normal.x * c0.x + normal.y * c0.y + coefficient;

    let roots: number[] = [];

    // 处理a=0的边界情况（用极小值判断浮点数为0，避免精度问题）
    if (Math.abs(a) < 1e-9) {
        if (Math.abs(bVal) < 1e-9) {
            // a和b都为0，检查曲线是否在直线上
            if (Math.abs(cVal) < 1e-9) {
                // 简化处理：返回曲线端点/控制点中在直线范围内的点
                [p1, p2, p3].forEach(point => {
                    let okY = point.y >= Math.min(a1.y, a2.y) && point.y <= Math.max(a1.y, a2.y);
                    let okX = point.x >= Math.min(a1.x, a2.x) && point.x <= Math.max(a1.x, a2.x);
                    if ((a1.x === a2.x && okY) || (a1.y === a2.y && okX) || (okX && okY)) {
                        intersections.push(point);
                    }
                });
            }
        } else {
            // 解一次方程：b*t + c = 0
            let t = -cVal / bVal;
            roots.push(t);
        }
    } else {
        // 原二次方程求解逻辑
        let b = bVal / a;
        let c = cVal / a;
        let d = b * b - 4 * c;
        if (d > 1e-9) {
            roots.push((-b + Math.sqrt(d)) / 2);
            roots.push((-b - Math.sqrt(d)) / 2);
        } else if (Math.abs(d) <= 1e-9) {
            roots.push(-b / 2);
        }
    }

    let minX = Math.min(a1.x, a2.x);
    let minY = Math.min(a1.y, a2.y);
    let maxX = Math.max(a1.x, a2.x);
    let maxY = Math.max(a1.y, a2.y);

    // 计算交点并做边界检查（加入微小误差容忍）
    roots.forEach(t => {
        if (t >= -1e-9 && t <= 1 + 1e-9) {
            t = Math.max(0, Math.min(1, t)); // 限制t在[0,1]范围内
            let point = {
                x: lerp(lerp(p1.x, p2.x, t), lerp(p2.x, p3.x, t), t),
                y: lerp(lerp(p1.y, p2.y, t), lerp(p2.y, p3.y, t), t)
            };
            let okY = point.y >= minY - 1e-9 && point.y <= maxY + 1e-9;
            let okX = point.x >= minX - 1e-9 && point.x <= maxX + 1e-9;
            // 边界检查
            if (a1.x === a2.x && okY) {
                intersections.push(point);
            } else if (a1.y === a2.y && okX) {
                intersections.push(point);
            } else if (okX && okY) {
                intersections.push(point);
            }
        }
    });

    // 去重，避免重复添加重合的交点
    return intersections.filter((point, index, self) => 
        index === self.findIndex(p => 
            Math.abs(p.x - point.x) < 1e-9 && Math.abs(p.y - point.y) < 1e-9
        )
    );
}

关键修改说明 #

1. 浮点数精度处理：用1e-9作为极小值判断条件，避免因浮点数精度问题导致的错误判断。
2. a=0分支：单独处理二次项系数为0的情况，区分一次方程和常数方程的场景。
3. 边界点容错：在t的范围判断和坐标边界检查中加入微小误差容忍，避免因精度问题遗漏交点。
4. 交点去重：对结果数组进行去重，避免重复添加重合的交点。

内容的提问来源于stack exchange，提问作者Gaius Coffey