从零实现B样条曲线：C++核心算法与德布尔算法详解

1. 项目概述：为什么从B样条曲线开始？

如果你正在学习计算机图形学、CAD系统开发，或者对机器人路径规划、动画设计感兴趣，那么“B样条曲线”这个名字你一定不陌生。它几乎是现代曲线曲面造型的基石。但很多教程和论文一上来就是复杂的数学推导，让人望而却步。这个项目，就是一次“返璞归真”的实践：用最纯粹的C++，不依赖任何大型图形库，从零开始实现一个基础的B样条曲线生成器。

B样条曲线之所以强大，在于它完美地平衡了控制能力与平滑性。相比贝塞尔曲线，它通过引入节点向量和控制点，实现了局部修改性——你移动一个控制点，只会影响曲线的一小段，而不是整条曲线都“牵一发而动全身”。这对于精细调整造型至关重要。在工业设计软件里，汽车外壳的曲面、手机圆润的边角，背后很可能就是B样条在支撑。

这个“简单的C++实现”项目，目标非常明确：剥离复杂的理论外壳，聚焦于核心算法的代码落地。我们将亲手实现B样条基函数的计算、控制点的加权求和，并最终在控制台上或一个简单的图形窗口里看到生成的曲线。这对于理解B样条的工作原理，远比读十篇论文更有效。无论你是刚学完C++语法想找个有挑战的练手项目，还是需要在项目中集成曲线功能但不想引入庞大依赖的开发者，这个实现都能提供一个清晰、可靠的起点。

2. 核心原理拆解：B样条曲线的数学“骨架”

在动手写代码之前，我们必须先理解B样条曲线的数学定义，这是所有实现的根基。不用担心，我们会用最直白的语言和类比来解释。

2.1 B样条曲线的定义与核心思想

一条p次的B样条曲线，其数学表达式如下：

C(u) = Σ(i=0 to n) N(i,p)(u) * P(i)

这个公式是理解一切的关键，我们把它拆开看：

• C(u)：这是我们最终要的曲线。u是一个参数，通常在某个区间（比如[0,1]）内变化。你可以把u想象成时间，C(u)就是随时间变化的一个点，所有这些点连起来就成了曲线。
• P(i)：这是第i个控制点。它就是一个坐标，比如(x, y)。一系列控制点构成了一个多边形，我们称之为“控制多边形”。曲线的大致形状会跟随这个多边形，但通常不会穿过所有控制点（除非是端点特殊的样条）。
• N(i,p)(u)：这是第i个p次B样条基函数。它是整个公式的灵魂，是一个关于参数u的函数。它的值是一个权重，决定了第i个控制点P(i)对参数u处曲线点C(u)的影响有多大。

核心思想类比：你可以把生成曲线点的过程，想象成一场“投票”。参数u是议题，每个控制点P(i)是一个投票者。基函数N(i,p)(u)就是投票者i在议题u上的投票权重。最终曲线点C(u)的位置，就是所有控制点根据各自的权重“投票”出来的加权平均位置。B样条的巧妙之处在于，每个投票者（控制点）的权重（基函数）只在u的某一段区间内不为零，这就实现了局部性。

2.2 节点向量：定义“影响力”范围的关键

是什么决定了基函数N(i,p)(u)的形状和“非零区间”呢？答案是节点向量U。

节点向量是一个非递减的实数序列：U = [u0, u1, u2, ..., u(m)]。其中，m = n + p + 1（n是控制点索引最大值，p是次数）。

节点向量有两个核心作用：

1. 定义参数域：曲线实际有定义的范围是u ∈ [u(p), u(n+1)]。通常我们会把节点向量规范化为从0开始，到1结束，这样参数域就是[0,1]，便于处理。
2. 划分影响区间：第i个基函数N(i,p)(u)只在区间[u(i), u(i+p+1))内非零。这意味着控制点P(i)只对这一段的曲线有影响。

节点向量的类型：

• 均匀节点向量：节点等间距分布，如[0, 1, 2, 3, 4, 5, 6]。生成的曲线在参数域内均匀变化，实现最简单。
• 准均匀节点向量：首尾节点具有重复度p+1，内部节点均匀。这是最常用的类型，它保证了曲线穿过第一个和最后一个控制点，非常符合直觉。例如，对于2次样条(p=2)，准均匀节点向量可能是[0,0,0,1,2,3,3,3]。
• 非均匀节点向量：节点任意非递减排列。这提供了最大的灵活性，可以通过调整节点间距来改变曲线局部的“张力”和形状。

在我们的简单实现中，为了降低入门门槛，会优先选择准均匀节点向量。

2.3 德布尔-考克斯递推公式：计算基函数的“引擎”

直接根据定义计算基函数非常复杂。幸运的是，我们有德布尔-考克斯递推公式，它用一种优雅的递归方式解决了这个问题。

公式定义如下：

1. 当次数p = 0时：N(i,0)(u) = 1, 如果 u(i) <= u < u(i+1)，否则为 0。这很好理解：0次基函数就是一个“开关”，只在对应的节点区间内“开启”（值为1）。
2. 当次数p > 0时：N(i,p)(u) = [(u - u(i)) / (u(i+p) - u(i))] * N(i, p-1)(u) + [(u(i+p+1) - u) / (u(i+p+1) - u(i+1))] * N(i+1, p-1)(u)

这个递推公式是代码实现的核心。它告诉我们，高次的基函数可以由两个低一次的基函数线性组合而成。在编程时，我们会用一个函数来实现这个递归计算。

注意：公式中存在分母(u(i+p) - u(i))和(u(i+p+1) - u(i+1))。当分母为零时，我们规定整个分式为零。这是算法实现中必须处理的边界条件。

3. 项目设计与代码架构

理解了原理，我们就可以开始设计程序了。一个清晰、模块化的设计能让编码和调试事半功倍。

3.1 整体架构与模块划分

我们的程序可以划分为以下几个核心模块：

1. 数据结构模块 (Point, KnotVector)：定义控制点、节点向量等基础数据结构。
2. 核心算法模块 (BSpline)：实现德布尔-考克斯递推公式和曲线点计算。
3. 输入/输出模块 (IOHandler)：负责从文件或命令行读取控制点数据，以及将生成的曲线点输出。
4. 可视化模块 (SimpleVisualizer) [可选但强烈推荐]：一个简单的图形界面，用于绘制控制多边形和生成的B样条曲线。对于C++新手，可以先用std::cout输出坐标，再用Python的matplotlib或任何其他工具绘图。对于想挑战的，可以使用轻量级的图形库如SFML或raylib。

3.2 类与数据结构设计

我们采用面向对象的思想来设计。以下是用C++伪代码展示的核心类结构：

// 1. 二维点（或三维，根据需求） struct Point { double x, y; Point(double x_ = 0, double y_ = 0) : x(x_), y(y_) {} // 可以重载一些运算符，如加法、数乘，方便后续计算 Point operator+(const Point& other) const { return Point(x + other.x, y + other.y); } Point operator*(double scalar) const { return Point(x * scalar, y * scalar); } }; // 2. 节点向量类 class KnotVector { private: std::vector<double> knots; int degree; // 曲线次数p public: KnotVector() = default; // 生成准均匀节点向量 void generateUniform(int numControlPoints, int degree); // 获取节点值 double operator[](int index) const; // 查找参数u所在的节点区间下标（Find Span算法，关键！） int findSpan(double u) const; }; // 3. B样条曲线核心类 class BSpline { private: int degree; // 次数 p std::vector<Point> controlPoints; KnotVector knotVector; public: BSpline(int deg, const std::vector<Point>& ctrlPts); // 计算p次第i个基函数在u处的值（递归实现） double basisFunction(int i, int p, double u) const; // 计算曲线在参数u处的点坐标 Point evaluate(double u) const; // 批量生成曲线上的点（用于绘制） std::vector<Point> generateCurvePoints(int numSamples = 100) const; };

3.3 开发环境与工具选型

• 编译器：推荐使用MinGW-w64 GCC或Microsoft Visual C++ (MSVC)。两者在Windows上都有很好的支持。对于这个项目，GCC足够且轻量。
• 集成开发环境(IDE)：
  • Visual Studio 2022：功能强大，调试方便，社区版免费。对于Windows开发者是首选。
  • VS Code：轻量灵活，配合C/C++扩展和CMake Tools扩展，可以构建非常专业的C++开发环境。你需要自己配置编译任务（tasks.json）和调试配置（launch.json）。
• 构建工具：对于小型项目，直接使用IDE的构建系统或写一个简单的Makefile即可。如果考虑扩展性，可以使用CMake，它能生成跨平台的构建文件。
• 图形库（可选）：
  • SFML：简单快速的多媒体库，2D图形、窗口管理、事件处理一应俱全，文档友好，非常适合此类图形学demo。
  • raylib：另一个极简的游戏/图形库，API设计非常直观。
  • 如果只想快速验证：将曲线点坐标输出到文件（如curve_points.txt），然后用Python脚本（matplotlib）读取并绘图，这是最快捷的跨平台可视化方案。

实操心得：对于初学者，我强烈建议从VS Code + GCC + 控制台输出开始。先确保核心算法（evaluate函数）计算正确，能输出合理的坐标。这能让你专注于算法逻辑，避免早期陷入图形库的环境配置难题。等曲线坐标生成无误后，再单独解决可视化问题。

4. 核心算法实现详解

这是整个项目最硬核的部分。我们将深入每一行关键代码，解释其背后的数学含义和编程技巧。

4.1 节点向量的生成与规范化

我们以实现最常用的准均匀节点向量为例。

void KnotVector::generateUniform(int numCtrlPts, int deg) { int n = numCtrlPts - 1; // 控制点最大索引 int m = n + deg + 1; // 节点向量长度-1 knots.clear(); knots.reserve(m + 1); // 1. 前 p+1 个节点为0 for (int i = 0; i <= deg; ++i) { knots.push_back(0.0); } // 2. 中间均匀分布的节点 int internalKnotCount = m - 2 * deg - 1; if (internalKnotCount > 0) { double step = 1.0 / (internalKnotCount + 1); for (int i = 1; i <= internalKnotCount; ++i) { knots.push_back(i * step); } } // 3. 后 p+1 个节点为1 for (int i = 0; i <= deg; ++i) { knots.push_back(1.0); } // 最终节点向量形如：[0,0,0, 0.25,0.5,0.75, 1,1,1] (对于p=2, n=3) degree = deg; }

关键点：internalKnotCount的计算确保了节点总数是m+1个。中间节点的均匀分布保证了曲线在参数域内变化均匀。

4.2 Find Span算法：高效定位参数区间

在计算N(i,p)(u)或C(u)时，我们需要知道参数u位于哪个节点区间[u(k), u(k+1))。线性搜索（从0到m-1遍历）是低效的。对于均匀或准均匀节点向量，我们可以利用其有序性进行二分查找，这就是经典的Find Span算法。

int KnotVector::findSpan(double u) const { // 边界处理：如果u等于最后一个节点值，特殊处理 if (u >= knots[knots.size() - 1 - degree]) { return knots.size() - 1 - degree - 1; } // 二分查找 int low = degree; int high = knots.size() - 1 - degree; // 有效查找范围 int mid = (low + high) / 2; while (u < knots[mid] || u >= knots[mid + 1]) { if (u < knots[mid]) { high = mid; } else { low = mid; } mid = (low + high) / 2; } return mid; }

这个函数返回的k值满足knots[k] <= u < knots[k+1]，且degree <= k < numCtrlPts。它是后续所有计算的基础。

4.3 德布尔-考克斯递推的代码实现

递归实现最直观，但可能存在重复计算。对于性能要求高的场景，可以使用基于三角计算表的迭代方法。这里我们先展示清晰的递归版本。

double BSpline::basisFunction(int i, int p, double u) const { const std::vector<double>& U = knotVector.getKnots(); // 递归基况：0次基函数 if (p == 0) { if (U[i] <= u && u < U[i + 1]) { return 1.0; } else { return 0.0; } } // 处理分母可能为0的情况 double leftCoeff = 0.0, rightCoeff = 0.0; double denomLeft = U[i + p] - U[i]; if (denomLeft != 0.0) { leftCoeff = (u - U[i]) / denomLeft; } double denomRight = U[i + p + 1] - U[i + 1]; if (denomRight != 0.0) { rightCoeff = (U[i + p + 1] - u) / denomRight; } // 递归计算 return leftCoeff * basisFunction(i, p - 1, u) + rightCoeff * basisFunction(i + 1, p - 1, u); }

注意事项：递归实现虽然简洁，但计算单个u处的所有基函数时效率不高，因为会产生大量重复的递归调用。在实际应用中，更常用的是德布尔算法，它是一种迭代算法，能一次性计算出参数u处所有非零的基函数值，效率更高。我们会在后续优化部分介绍。

4.4 曲线点计算：从公式到代码

有了基函数，计算曲线点就水到渠成了。我们实现evaluate函数。

Point BSpline::evaluate(double u) const { // 1. 找到u所在的节点区间k int k = knotVector.findSpan(u); // 2. 计算所有非零的基函数值 // 对于p次样条，在区间k内，只有 N(k-p, p), N(k-p+1, p), ..., N(k, p) 可能非零 int startIdx = k - degree; if (startIdx < 0) startIdx = 0; // 边界安全处理 Point result(0, 0); for (int i = startIdx; i <= k; ++i) { double weight = basisFunction(i, degree, u); // 控制点下标i必须有效 if (i < controlPoints.size()) { result = result + controlPoints[i] * weight; } } return result; }

为了绘制整条曲线，我们需要在参数域[u(p), u(n+1)]（通常就是[0,1]）内采样一系列u值，调用evaluate得到对应的点。

std::vector<Point> BSpline::generateCurvePoints(int numSamples) const { std::vector<Point> curvePts; curvePts.reserve(numSamples); const std::vector<double>& U = knotVector.getKnots(); double uStart = U[degree]; double uEnd = U[U.size() - 1 - degree]; double step = (uEnd - uStart) / (numSamples - 1); for (int i = 0; i < numSamples; ++i) { double u = uStart + i * step; // 对最后一个点，确保u精确等于uEnd，避免浮点误差导致漏点 if (i == numSamples - 1) u = uEnd; curvePts.push_back(evaluate(u)); } return curvePts; }

5. 性能优化与高级话题：德布尔算法

前面递归计算基函数的方法在需要生成大量曲线点时效率低下。工业级实现几乎都采用德布尔算法。它不仅快，而且数值稳定性更好。

5.1 德布尔算法原理

德布尔算法的核心思想是：不单独计算每个基函数，而是利用递推公式的规律，通过迭代直接计算出曲线点C(u)。它需要一个长度为p+1的临时数组N来存储中间计算的基函数值（实际上是经过规约的权重）。

算法步骤简述：

1. 找到u所在的节点区间k。
2. 初始化一个数组N[0..p]，其中N[0] = 1.0，其余为0。这个数组将在迭代中演化。
3. 进行p轮迭代。在第r轮(r从1到p)，从后向前更新数组N，利用节点向量计算线性插值系数。
4. 经过p轮后，数组N中存储的值就是N(k-p, p)(u), N(k-p+1, p)(u), ..., N(k, p)(u)这些非零基函数的值。
5. 用这些权重与控制点P(k-p)到P(k)做加权和，得到C(u)。

5.2 德布尔算法的C++实现

Point BSpline::evaluateDeBoor(double u) const { const std::vector<double>& U = knotVector.getKnots(); int k = knotVector.findSpan(u); // 德布尔算法步骤 std::vector<Point> d(degree + 1); // 初始化：将相关的控制点拷贝到临时数组d中 for (int i = 0; i <= degree; ++i) { int ctrlIdx = k - degree + i; // 确保索引在有效范围内 ctrlIdx = std::max(0, std::min(ctrlIdx, (int)controlPoints.size() - 1)); d[i] = controlPoints[ctrlIdx]; } // 迭代计算 for (int r = 1; r <= degree; ++r) { for (int j = degree; j >= r; --j) { int idx = k - degree + j; double alpha = (u - U[idx]) / (U[idx + degree + 1 - r] - U[idx]); // 线性插值 d[j] = d[j-1] * (1.0 - alpha) + d[j] * alpha; } } // 最终结果在d[degree]中 return d[degree]; }

为什么德布尔算法更好？

1. 效率：它将计算一个曲线点的时间复杂度从递归的指数级降低到了O(p^2)，并且避免了大量重复计算。
2. 数值稳定：直接操作控制点坐标进行线性插值，比计算可能非常小的基函数值再进行加权求和更稳定。
3. 与递推公式等价：数学上可以证明，德布尔算法计算出的结果与使用基函数加权求和的结果完全相同。

实操心得：在第一次实现时，为了理解原理，我建议先实现递归版本的basisFunction和evaluate。当你确认算法正确，并能生成预期曲线后，务必将其替换为德布尔算法。这是从“学习实现”到“工业级实现”的关键一步。你可以同时保留两个函数，并生成相同的曲线点进行对比验证，确保结果一致（在浮点误差允许范围内）。

6. 从控制台到图形：可视化与调试

算法正确性需要验证。将数据可视化是最直观的方式。

6.1 数据输出与外部绘图

最简单的可视化方法是输出坐标，用其他工具绘图。

// 在main函数中 std::vector<Point> ctrlPts = {{0,0}, {50, 150}, {150, -50}, {200, 100}}; BSpline spline(3, ctrlPts); // 3次B样条 auto curve = spline.generateCurvePoints(200); // 输出到文件 std::ofstream outFile("curve_data.txt"); outFile << "Control Points:\n"; for (auto& pt : ctrlPts) outFile << pt.x << " " << pt.y << "\n"; outFile << "\nCurve Points:\n"; for (auto& pt : curve) outFile << pt.x << " " << pt.y << "\n"; outFile.close();

然后，用一个简单的Python脚本（需要安装matplotlib）绘图：

import matplotlib.pyplot as plt import numpy as np # 读取数据 ctrl_pts = [] curve_pts = [] with open('curve_data.txt', 'r') as f: lines = f.readlines() section = None for line in lines: line = line.strip() if line == 'Control Points:': section = 'ctrl' continue elif line == 'Curve Points:': section = 'curve' continue if line and section: x, y = map(float, line.split()) if section == 'ctrl': ctrl_pts.append([x, y]) else: curve_pts.append([x, y]) ctrl_pts = np.array(ctrl_pts) curve_pts = np.array(curve_pts) plt.figure(figsize=(10,6)) # 绘制控制多边形 plt.plot(ctrl_pts[:,0], ctrl_pts[:,1], 'ro--', label='Control Polygon', linewidth=1, markersize=8) # 绘制B样条曲线 plt.plot(curve_pts[:,0], curve_pts[:,1], 'b-', label='B-Spline Curve (p=3)', linewidth=2) plt.legend() plt.grid(True, linestyle='--', alpha=0.7) plt.title('B-Spline Curve Generation') plt.xlabel('X') plt.ylabel('Y') plt.axis('equal') # 保证x,y轴比例相同，图形不变形 plt.show()

6.2 集成轻量级图形库（以SFML为例）

如果你希望程序自带显示功能，集成一个图形库是更好的选择。SFML的配置相对简单。

1. 安装SFML：从官网下载编译好的库，或者使用vcpkg/CMake管理。
2. 修改项目：在main.cpp中创建窗口、处理事件，并在循环中绘制。
3. 绘制逻辑：
   • 将控制点坐标映射到窗口像素坐标（可能需要一个缩放和平移变换）。
   • 用sf::VertexArray以sf::LineStrip模式绘制曲线点。
   • 用sf::CircleShape绘制控制点。

#include <SFML/Graphics.hpp> // ... 其他头文件 // 坐标变换函数：将世界坐标(如0~200)映射到屏幕中心区域 sf::Vector2f worldToScreen(const Point& worldPt, const sf::Vector2u& windowSize) { float scale = 2.0f; // 缩放因子 float offsetX = windowSize.x / 2.0f; float offsetY = windowSize.y / 2.0f; return sf::Vector2f(worldPt.x * scale + offsetX, -worldPt.y * scale + offsetY); } int main() { // 初始化B样条数据... BSpline spline(3, controlPoints); auto curvePoints = spline.generateCurvePoints(500); // 创建SFML窗口 sf::RenderWindow window(sf::VideoMode(800, 600), "B-Spline Demo"); window.setFramerateLimit(60); // 准备绘制控制多边形 sf::VertexArray controlPolygon(sf::LineStrip, controlPoints.size()); for (size_t i = 0; i < controlPoints.size(); ++i) { controlPolygon[i].position = worldToScreen(controlPoints[i], window.getSize()); controlPolygon[i].color = sf::Color::Red; } // 准备绘制B样条曲线 sf::VertexArray curve(sf::LineStrip, curvePoints.size()); for (size_t i = 0; i < curvePoints.size(); ++i) { curve[i].position = worldToScreen(curvePoints[i], window.getSize()); curve[i].color = sf::Color::Blue; } // 主循环 while (window.isOpen()) { sf::Event event; while (window.pollEvent(event)) { if (event.type == sf::Event::Closed) window.close(); } window.clear(sf::Color::White); window.draw(controlPolygon); window.draw(curve); window.display(); } return 0; }

7. 常见问题、调试技巧与扩展方向

即使理解了原理，实现过程中也一定会遇到各种问题。这里记录了一些典型的坑和解决方法。

7.1 常见问题与排查表

问题现象	可能原因	排查与解决方法
曲线点全部为(0,0)或NaN	1. 基函数计算全为0。 2. 节点向量定义错误，导致findSpan返回错误区间。 3. 控制点索引越界。	1.打印调试：在evaluate函数中，打印出u、k（span值）、计算出的每个weight。检查weight是否在[0,1]区间内。 2.检查节点向量：打印出生成的节点向量，确认其符合准均匀格式（首尾重复p+1次）。 3.边界检查：在basisFunction或evaluate中，确保访问controlPoints和knots向量时索引有效。
曲线形状异常，不光滑或有尖刺	1. 控制点顺序错误或坐标值不合理。 2. 曲线次数p设置过高，接近或超过控制点数量-1。 3.浮点数精度问题：在findSpan中，u非常接近节点值时判断出错。	1.可视化控制多边形：先单独绘制控制点并用直线连接，确认多边形是你期望的形状。 2.检查次数：确保0 <= degree < controlPoints.size()。通常degree取2（二次）或3（三次）。 3.处理浮点容差：在findSpan的二分查找和basisFunction的区间判断中，使用一个很小的容差值epsilon（如1e-10）来代替严格的<=和<比较。
曲线起点/终点不经过第一个/最后一个控制点	使用的不是准均匀节点向量。均匀节点向量没有这个性质。	确认你的generateUniform函数生成的是准均匀节点向量（首尾节点重复p+1次）。这是实现“端点插值”的关键。
程序崩溃（段错误）	1. 访问空向量或越界。 2. 递归版本的basisFunction递归深度过大导致栈溢出（对于高次p）。	1. 在所有向量访问前添加断言或边界检查。 2.改用德布尔算法。递归实现只适用于低次（p<=3）的教学演示，实际应用必须用德布尔算法。
生成的曲线点不连续或有缺口	generateCurvePoints中采样参数u的终点处理有误，可能因为浮点误差没能取到uEnd。	在采样循环中，显式地将最后一个采样点的u设置为uEnd，如前面代码示例所示。

7.2 调试技巧实录

• 从小开始，逐步验证：不要一开始就用多个控制点和复杂参数。从3个控制点，1次（p=1）B样条开始测试。1次B样条就是控制多边形本身，非常容易验证。确认无误后，再测试2次、3次。
• 使用固定测试用例：找一些经典教材或论文中的B样条示例，输入完全相同的控制点和节点向量，对比输出的曲线点坐标。这是验证算法正确性的金标准。
• 分离算法与可视化：先确保evaluate函数能输出看似合理的坐标（比如，坐标值在控制点坐标范围内变化）。用std::cout输出几个关键u值（如0, 0.5, 1）对应的曲线点，进行人工粗略校验。可视化是为了更直观，但初期调试，控制台输出更直接。
• 图形调试：如果集成了图形库，可以实时绘制。一个有用的技巧是：在鼠标位置实时计算并显示对应的u值和曲线点C(u)，同时高亮显示此时有哪些控制点被激活（即权重>0）。这能让你直观地理解B样条的局部性。

7.3 项目扩展方向

这个简单的实现是一个完美的起点，你可以沿着多个方向深化它：

1. 支持非均匀节点向量：修改KnotVector类，允许从外部传入或生成非均匀节点向量。这能让你体验如何通过调整节点间距来改变曲线形状。
2. 实现节点插入/细化：这是B样条一个非常重要的操作，可以在不改变曲线形状的前提下增加控制点，提供更灵活的编辑能力。算法核心是奥斯陆算法。
3. 升阶与降阶：改变曲线的次数p而尽量保持形状不变。
4. 从曲线到曲面：将算法从一维参数u扩展到二维参数(u, v)，实现B样条曲面。数据结构从控制点数组变为控制点网格，计算从单重循环变为双重循环。
5. 集成到实际应用：尝试用生成的B样条曲线作为机器人运动路径、动画关键帧插值、或者字体轮廓描述。思考如何计算曲线的切线、法线（一阶导数）和曲率（二阶导数）。
6. 性能优化：将德布尔算法进一步优化，预计算一些不变值。对于需要实时生成大量曲线的应用，考虑使用SIMD指令或GPU加速。

实现一个基础的B样条曲线生成器，就像搭积木。你首先需要几块形状正确的积木（正确的基函数计算、节点向量），然后按照图纸（德布尔算法）把它们组装起来。这个过程里最深的体会是，理论上的优雅公式和代码中的边界情况处理，完全是两回事。比如那个不起眼的findSpan函数，如果二分查找的边界条件没处理好，或者浮点数比较没加容差，整个曲线就可能在某处“断裂”。还有，从递归基函数切换到德布尔算法，不仅仅是性能的提升，更是一种思维方式的转变——从“计算权重”到“直接构造点”。我建议每个做图形学编程的朋友，都不要只停留在调用OpenGL或DirectX的某个曲线绘制函数，亲手实现一次这个算法，你对计算机图形学的理解会扎实很多。最后一个小技巧，在开发初期，别急着搞图形界面，用一个你熟悉的脚本语言（比如Python）快速写一个数据验证和绘图脚本，能帮你节省大量的调试时间。