我的Bezier曲线计算代码运行过慢，如何进行性能优化？

优化建议与高效计算方案 #

你的代码性能瓶颈主要来自两点：一是每次计算单个t值时都要重复执行完整的de Casteljau迭代，且每次迭代都新建数组，带来巨大的内存分配和GC开销；二是100个控制点的高次Bezier曲线，单次计算就需要98轮迭代，10000次计算的总运算量呈指数级增长。以下是针对性的优化方案：

1. 改用伯恩斯坦多项式公式直接计算（推荐）

伯恩斯坦公式通过预计算二项式系数和增量幂次项，直接求和得到Bezier点，避免了迭代过程中的冗余计算。

public static class BezierOptimized
{
    // 预计算99次Bezier曲线的二项式系数，仅初始化一次
    private static readonly double[] _binomialCoefficients = PrecomputeBinomialCoefficients(99);

    private static double[] PrecomputeBinomialCoefficients(int n)
    {
        double[] coeffs = new double[n + 1];
        coeffs[0] = 1;
        for (int i = 1; i <= n; i++)
        {
            coeffs[i] = coeffs[i - 1] * (n - i + 1) / i;
        }
        return coeffs;
    }

    public static Vector2 GetPoint(IList<Vector2> points, float t)
    {
        int n = points.Count - 1;
        double tDouble = t;
        double oneMinusT = 1.0 - tDouble;
        double currentPower = Math.Pow(oneMinusT, n);
        Vector2 result = Vector2.Zero;

        for (int i = 0; i <= n; i++)
        {
            double coeff = _binomialCoefficients[i] * currentPower;
            result.X += (float)(coeff * points[i].X);
            result.Y += (float)(coeff * points[i].Y);

            if (i < n)
            {
                currentPower *= tDouble / oneMinusT;
            }
        }

        return result;
    }
}

优化亮点：

• 预计算二项式系数，避免每次计算重复计算组合数
• 增量计算幂次项，将O(n)的指数运算转为O(1)乘法
• 无额外数组分配，彻底消除GC压力

2. 优化de Casteljau算法，消除内存分配

如果坚持使用de Casteljau算法，可通过复用数组减少内存开销：

public static class BezierOptimized
{
    public static Vector2 GetPoint(IList<Vector2> points, float t)
    {
        int count = points.Count;
        Vector2[] temp = new Vector2[count];
        points.CopyTo(temp, 0);

        for (int k = 1; k < count; k++)
        {
            for (int i = 0; i < count - k; i++)
            {
                // 内联插值计算，消除函数调用开销
                temp[i].X = temp[i].X * (1f - t) + temp[i + 1].X * t;
                temp[i].Y = temp[i].Y * (1f - t) + temp[i + 1].Y * t;
            }
        }

        return temp[0];
    }
}

优化亮点：

• 仅分配一次临时数组，避免迭代过程中频繁新建数组
• 内联插值逻辑，消除函数调用的微小开销
• 原地修改数组，减少内存占用

3. 批量计算与并行优化（针对固定步长场景）

由于你使用固定步长0.0001计算10000个点，可进一步优化：

• 并行计算：利用Parallel.For将10000个t值的计算分配到多个CPU核心，大幅缩短总耗时（注意每个线程独立计算，无共享状态）
• 精度权衡：如果项目允许，可适当降低t的精度或减少采样点数量，直接减少计算量

额外优化细节

• 使用float代替double进行计算（精度允许的情况下），减少类型转换开销
• 将控制点列表转为数组，避免IList的索引访问开销
• 开启Release模式编译，编译器会自动进行循环展开、函数内联等优化

内容的提问来源于stack exchange，提问作者Oko Lenmi