简介：面向计算机图形学、CAD建模及数值计算领域学习者的三次B样条曲线算法VC++实现资源，基于控制点、Knot向量与De Boor算法构造平滑连续曲线，适合需要掌握曲线插值、局部控制与可视化原理的开发者参考。压缩包共38个文件，包含完整C++源文件（.h/.cpp）、可执行程序（.exe）、MFC工程文件（.dsp/.dsw/.rc）、调试文件（.pdb/.obj）及说明文档（.txt/ReadMe）等，整体仅2.29MB，目录结构清晰，便于按需查阅与二次开发。已有528人学习下载。资源提供可运行的工程代码与演示程序，可直观理解三次B样条基函数递归构造、Knot向量重复值对端点特性的影响，以及调整控制点改变曲线形状的过程；代码用C++数组或STL容器存储数据，实现De Boor算法逐级计算曲线点，并用OpenGL或GDI完成图形绘制，帮助从数学原理到实际编程形成完整闭环，亦可基于MFC扩展交互式输入界面。

1. 三次B样条曲线算法在VC++里的真实分量：从鼠标点集到光滑曲线的第一步

做CAD插件或逆向建模工具时，三次B样条曲线算法几乎是绕不开的基础件：用户用鼠标点出七八个散点，软件要生成一条能局部修改的光滑曲线，Bezier曲线不够格，直线拟合又太糙。这个场景下，VC++里的B样条实现不是背公式，而是要把基函数递推、节点向量构造和求值代码串成一套能调试的东西。这套实现适合正在写CAD/CAM、逆向或路径规划模块的C++开发者，目标是让你半天内拥有一套能跑通、能封装、能排错的B样条工具类，而不是一份纸上算法。我会按实际写这类代码的顺序来讲：先把理论和三个参数的关系说清楚，再给求值类的完整代码，然后处理开曲线和闭曲线，最后把最容易翻车的几个坑逐个排查一遍。

2. 先立住原理：de Boor-Cox递推与三次B样条的三个关键参数

动手写代码之前，先把这个算法里的三个角色分清楚：控制点、节点向量、次数。很多翻车现场不是代码写错，而是这三个参数的关系没搞对。B样条曲线的定义式是C(u) = Σ_{i=0}^{n} N_{i,p}(u)·P_i，其中N_{i,p}(u)是p次基函数，P_i是控制点，节点向量U = {u_0, u_1, …, u_m}决定了基函数的分段位置。三者之间有一条硬约束：节点向量长度减一m，必须等于控制点最大下标n加次数p再加1，写作m = n + p + 1。这个等式在p=3时就是m = n + 4，不满足它，求值代码几乎必越界。

2.1 为什么是三次而不是二次或四次：从Bezier到B样条的工程选型

B样条是Bezier的推广，Bezier是B样条在只有一个节点区间时的特例。Bezier曲线修改任何一个控制点，整条曲线都会被拖着走，局部修改无从谈起；B样条用节点向量把参数域切成若干小区间，每个控制点的基函数只在p+1个节点区间上有非零值，这就是局部支撑性。选三次的原因很工程化：三次基函数保证C2连续，也就是二阶导连续，CAD里大多数曲面拼接和刀具路径规划都以二阶连续作为底线。二次曲线只有C1连续，在曲率突变的造型上能看出折角，很多时候过不了工艺审查；四五六次理论上连续性更高，但每个控制点的影响范围变大，数值计算量和抖动风险同步上升，收益很小。三次是连续性与局部可控性之间的平衡点，这个结论在工业软件里被反复验证过。

2.2 节点向量、控制点、次数p=3：三个参数各自的职责

节点向量里的一组数值可以理解成分段开关：它决定每个控制点在哪一段参数区间里起作用，以及起作用的权重。节点重复会让基函数在该处降阶，曲线被“吸”到对应控制点附近；控制点的疏密分布则直接决定局部表达能力。这里有一个新手极易绕进去的认知误区：B样条曲线默认不经过控制点，控制点只是对曲线的“牵引”，如果你期待曲线像插值一样穿过每个点，就必须做插值型B样条或者反算控制点。后面给的方案是让曲线经过首尾两个点的clamped构造，中间的控制点仍然只是逼近，理解这一点，调试时会少很多困惑。

还有一个必须记住的数量关系：控制点下标从0到n，共n+1个；节点向量下标从0到m，共m+1个；当p=3时m = n + 4，节点数比控制点数多4。这是三次单参数B样条的标准结构。很多人写循环时用控制点长度去遍历节点向量，几乎必越界，我习惯把这个关系直接写进代码注释里，提醒自己别踩。

2.3 de Boor-Cox递推公式的代码骨架

基函数递归实现是理解整个算法的捷径，p=3时递归深度只有3层，逻辑非常清晰。

// 计算第i个p次B样条基函数在参数u处的值 // knot: 节点向量; i: 基函数序号; p: 次数; u: 参数值 double BasisFunc(const std::vector<double>& knot, int i, int p, double u) { if (p == 0) { // 0次基函数在 [knot[i], knot[i+1]) 内为1，取半开区间避免端点重复计数 if (u >= knot[i] && u < knot[i + 1]) return 1.0; return 0.0; } double left = 0.0, right = 0.0; // 第一项权重：u 在 [knot[i], knot[i+p]] 中的比例 double d1 = knot[i + p] - knot[i]; if (std::fabs(d1) > 1e-12) left = (u - knot[i]) / d1 * BasisFunc(knot, i, p - 1, u); // 第二项权重：u 在 [knot[i+1], knot[i+p+1]] 中的比例 double d2 = knot[i + p + 1] - knot[i + 1]; if (std::fabs(d2) > 1e-12) right = (knot[i + p + 1] - u) / d2 * BasisFunc(knot, i + 1, p - 1, u); return left + right; }

代码逻辑说明：每个p次基函数由两个p-1次基函数加权合成，权重就是u在当前节点区间内的相对位置。两个分母在节点重复时会变成0，此时该权重对基函数没有贡献，按0处理，这是所有B样条实现里的关键保护。参数说明：knot是节点向量；i的合法范围是0到n；u必须在[knot[p], knot[m-p]]内取值，超出这个范围曲线未定义。递归实现适合p=3的教学和调试场景，因为调用次数可控，生产代码不建议这样跑，原因下面说。

实际项目里我不会用递归实现。p=3时虽然递归深度只有3层，但每个求值点要多次重复调用，控制点几十个时还能忍，做成软件每帧实时拖动控制点时明显变慢。生产代码用下一章的迭代de Boor算法，它的计算量是固定次数的线性组合，不随层数爆炸。递归版本的价值是让你验证基函数形状是否正确：单独把第i个基函数输出成一条曲线，看它是不是只在4个节点区间内非零。我当初排查一个曲线“多余抖动”的问题，就是这样定位到某个基函数数值异常的。

提示：调试阶段把u细分1000份，逐点打印基函数值，能直观看到局部支撑性是否正常。

3. 用C++实现三次B样条求值：de Boor迭代算法与类的完整封装

写代码之前，先定数据结构。控制点我建议单独定义Point3结构体，包含x、y、z三个double，而不是用三个平行的std::vector 。原因是de Boor算法每一层加权都是对整个点做线性组合，用结构体能一次写完，代码更接近数学表达式，调试时也容易在监视窗口里看一个点的完整坐标。节点向量用std::vector 足够，它是严格非减的数组，不需要额外容器特性。B样条曲线类固定p=3，不把次数做成模板参数，只在类里留一个int成员，原因很现实：VC++工程里调用方几乎不会换次数，写死参数能省掉模板展开的编译时间，代码也更直白。

3.1 区间定位：二分查找u所在的节点区间

de Boor算法第一步是找u落在哪个节点区间，这一步写不好，后面的下标全部跟着错。标准做法是二分查找。

// 返回参数u所在的节点区间下标k，满足 knot[k] <= u < knot[k+1] // n: 控制点最大下标; p: 次数; u: 参数值 int FindSpan(const std::vector<double>& knot, int n, int p, double u) { if (u >= knot[n + 1]) return n; // 右端点强制落在最后一个有效区间 if (u <= knot[p]) return p; // 左端点落在第一个有效区间 int low = p, high = n + 1; int mid = (low + high) / 2; while (u < knot[mid] || u >= knot[mid + 1]) { if (u < knot[mid]) high = mid; else low = mid; mid = (low + high) / 2; } return mid; }

边界处理为什么必须特判：clamped节点向量右端有p+1个重复的1，u=1时如果直接二分可能落到最后一个重复区间，返回n+1会让后续控制点下标越界。所以先判断u >= knot[n+1]返回n，这是图形学里B样条类实现的标准做法，原样保留别乱改。n是控制点最大下标，在这类中是ctrlPoints.size() - 1。查找复杂度是O(log n)，配合固定p=3的求值，整体性能足够应对交互拖动场景。

3.2 de Boor迭代求值：三角形加权与下标映射

拿到区间下标k后，真正参与计算的只有p+1个控制点，从P_{k-p}到P_k。de Boor算法把这些点放进一个临时数组，逐层做线性加权，每层只更新一半节点。

// de Boor迭代求值：返回曲线在u处的三维坐标 // ctrl: 控制点数组; knot: 节点向量; p: 次数; u: 参数值 Point3 DeBoor(const std::vector<Point3>& ctrl, const std::vector<double>& knot, int p, double u) { int n = (int)ctrl.size() - 1; int k = FindSpan(knot, n, p, u); // d 保存参与计算的 p+1 个控制点，按 de Boor 算法逐层加权 std::vector<Point3> d(p + 1); for (int i = 0; i <= p; ++i) d[i] = ctrl[k - p + i]; // r 是层号，从1到p for (int r = 1; r <= p; ++r) { // 每层从左侧第一个节点开始向右，只更新 k-p+r 到 k 之间的点 for (int i = k - p + r; i <= k; ++i) { int idx = i - (k - p); // 映射到d数组下标 // 权重alpha：当前层左右两个节点决定的比例 double denom = knot[i + p - r + 1] - knot[i]; double alpha = (std::fabs(denom) < 1e-12) ? 0.0 : (u - knot[i]) / denom; d[idx] = Point3( (1 - alpha) * d[idx - 1].x + alpha * d[idx].x, (1 - alpha) * d[idx - 1].y + alpha * d[idx].y, (1 - alpha) * d[idx - 1].z + alpha * d[idx].z); } } return d[p]; }

参数含义：k是从FindSpan拿到的区间下标；d是长度为4的临时数组；alpha是层次化权重，分母是同一层两个节点的距离。节点重复导致分母为零时alpha取0，这是上一章说的除零保护在迭代版本里的体现。特别注意不要在第一层循环里直接用原始控制点数组覆盖，因为每一层加权必须基于上一层的中间结果。内层循环从左到右扫描时，d[idx-1]是本层刚算出的新值，d[idx]还是上一层旧值，数学上恰好构成标准交叉加权，这说明下标映射是对的核心循环闭式。

3.3 封装BSplineCurve类：构造、求值、一致性校验

把上面的函数收进一个类，对外暴露SetControlPoints和Evaluate两个接口。类内部完成节点向量构造和参数校验，调用方不需要知道B样条的数学细节。

class BSplineCurve { public: BSplineCurve() : p(3), knotMin(0.0), knotMax(1.0) {} // 设置控制点并自动构造clamped节点向量 void SetControlPoints(const std::vector<Point3>& pts) { if (pts.size() < 4) throw std::invalid_argument("三次B样条至少需要4个控制点"); ctrl = pts; knot = BuildClampedKnot((int)ctrl.size() - 1, p); knotMin = knot[p]; knotMax = knot[ctrl.size() - 1]; // 即 knot[n+1] } // 在参数u处求值，u越界时自动裁剪到有效范围 Point3 Evaluate(double u) const { if (u < knotMin) u = knotMin; if (u > knotMax) u = knotMax; return DeBoor(ctrl, knot, p, u); } double KnotMin() const { return knotMin; } double KnotMax() const { return knotMax; } private: std::vector<Point3> ctrl; std::vector<double> knot; int p; double knotMin, knotMax; };

一致性校验放在SetControlPoints里，控制点少于4个直接抛异常，这样UI层可以捕获错误并弹出诊断对话框，而不是在后续求值里静默出NaN。这里BuildClampedKnot会在下一章给出完整实现。Evaluate里的裁剪逻辑是工程习惯：交互程序里经常有鼠标拖到边界外的情况，与其让调用方处理异常参数，不如让求值函数自动收敛到端点。代价是曲线在端点处重复取同一个点，对显示没影响。

注意：类里固定p=3，所有内部数组长度都按4设计。如果以后要改成任意次数，d数组和BuildClampedKnot函数都要改成参数化版本。

4. 把代码变成可用工具：节点向量构造与开闭曲线的工程封装

上一章的BSplineCurve类还差一个关键输入：节点向量。节点向量怎么构造，直接决定曲线是经过端点还是悬空、是开曲线还是闭曲线。这一章把三种常用构造方式讲透，并给出开曲线和闭曲线的完整工程做法。

4.1 均匀、准均匀、非均匀节点向量：三种选型与适用场景

节点向量构造方式直接决定B样条曲线的边界行为。工程上主要有三种，我列一个对比表，方便你在动手前先选中目标。

解释一下为什么均匀节点向量不适合交互式应用：它构造简单，每个节点间隔相同，但曲线端点会悬空，第一个控制点和最后一个控制点只是“牵引”曲线而不是“钉住”曲线。用户用鼠标点下的起点和终点看到曲线不经过，第一反应就是算法有bug。准均匀也叫clamped，工程上默认选它，首尾各重复p+1次节点后，基函数在端点处被拉成1，曲线精准穿过首尾控制点。非均匀节点向量按弦长比例分配参数，拟合精度最高，但需要先计算控制点间的累计距离。

4.2 准均匀节点向量的构造：clamped边界与内部节点数量

clamped节点向量的构造有固定套路。这里给出完整代码，同时把内部节点数量算清楚，避免再犯越界错误。

// 构造三次B样条的clamped节点向量 // n: 控制点最大下标; p: 次数(固定3) std::vector<double> BuildClampedKnot(int n, int p) { // 节点向量长度为 n + p + 2，对应 m+1 std::vector<double> knot(n + p + 2, 0.0); int inner = n - p; // 中间不同节点值的个数 for (int i = 1; i <= inner; ++i) { // 均匀分布在 (0, 1) 内，步长 1/(inner+1) knot[p + i] = (double)i / (inner + 1); } // 尾部 p+1 个节点全部取1 for (int i = n + 1; i <= n + p + 1; ++i) knot[i] = 1.0; return knot; }

参数说明：n是控制点最大下标，p=3，所以节点向量长度是n+5。inner = n - 3是中间不同节点值的个数。举例：5个控制点即n=4时，knot长度为9，前4个是0，中间1个值0.5，后4个是1，序列为0,0,0,0,0.5,1,1,1,1。首尾各4个重复值是clamped的根源：三次基函数在端点需要p+1重节点才能把基函数压缩成只有一段非零，曲线才能被端点“钉住”。中间节点均匀分布即可，如果你有更高的贴合要求，可以把循环里的均匀步长换成弦长比例。

代码里的边界为什么是knot[p + i]：前p个位置被0占据，所以第i个内部节点从下标p+1开始写。尾部从n+1开始覆盖为1，因为前面循环最多写到p+inner = p+n-p = n，下标n+1到n+p+1正好是最后的p+1个位置。这个推导不需要每次重算，但建议你调试一次打印全部节点值，确认序列严格非减。

4.3 闭曲线处理：绕回控制点与均匀节点向量

闭曲线是B样条绕不开的话题。常见需求是让一条样条首尾相接、形成封闭轮廓。工程上最省事的做法是绕回控制点：把前p个控制点复制到数组尾部，让首尾在几何上重合。

// 闭曲线处理：追加前p个控制点到尾部，实现首尾重合 // ctrl: 原控制点数组，会被扩容; p: 次数(固定3) void MakeClosed(std::vector<Point3>& ctrl, int p) { int n = (int)ctrl.size(); // 原有控制点数量 ctrl.resize(n + p); // 尾部追加p个位置 for (int i = 0; i < p; ++i) ctrl[n + i] = ctrl[i]; // 前p个控制点复制到尾部 }

调用示例：原控制点5个，MakeClosed后变成8个，其中第6、7、8个点分别是第1、2、3个点的副本。然后节点向量要用均匀而非clamped，否则尾部重复节点会破坏闭合性：

// 构造均匀节点向量，用于闭曲线 int n = (int)ctrl.size() - 1; int m = n + p + 1; std::vector<double> knot(m + 1); for (int i = 0; i <= m; ++i) knot[i] = (double)i / m;

这里有个值得注意的工程边界：绕回控制点加均匀节点向量得到的闭曲线，在首尾接缝处只是几何重合，不保证C1连续。如果曲线用于视觉展示，肉眼验收通常能过；如果用于高精度加工路径，闭合处的切向量必须连续，那就需要查周期节点向量的标准构造（让节点向量满足周期性条件），再配合绕回控制点一起用。我一般先看项目需求，展示类用绕回法，加工路径类直接上周期样条，不在这上面省事。

5. 三次B样条编程避坑指南：5个典型异常现象与排查记录

这一章写我实际遇到过的异常现象和排查过程，全部按“现象→原因→解决”记录。每一项都是真实工程里反复出现的，不是理论推导出来的问题。

5.1 现象：某个参数值上直接输出NaN或程序崩溃

现象：曲线大部分区域正常，但拖到某个控制点附近时，求值结果变成NaN，随后曲线整个消失或者程序报内存错误。原因：分母为零。典型场景是节点向量里有大量重复值——clamped首尾各有4个0和4个1，递归或迭代代码里没做除零保护，浮点除零产出NaN，NaN参与加权后传染给整个点。另外FindSpan在u正好等于节点值时也可能返回错误区间，导致数组访问越界。解决：所有分母先取绝对值与1e-12比较再计算alpha；FindSpan的二分循环前先特判两端。我习惯在DeBoor入口加一个断言，检查u的范围和节点向量的单调性，把问题掐在源头。

5.2 现象：曲线画出来根本不经过用户点的起点和终点

现象：用户依次点了6个点，曲线画出来后起点和终点都悬在半空，跟用户预期完全不符。原因：用了均匀节点向量而不是clamped。均匀节点向量下，基函数在端点处的值不是1，曲线端点落在第一个控制点和第二个控制点之间，数学上没写错，但交互上无法接受。我第一次做这个功能时也被这个“bug”困住，后来打印出节点向量才发现是构造方式的问题。解决：交互式应用一律用BuildClampedKnot，让前4个节点都等于0、后4个节点都等于1。验收标准就是Evaluate(0)必须等于第一个控制点坐标，Evaluate(1)必须等于最后一个控制点坐标。

5.3 现象：修改一个控制点，整条曲线都在抖动

现象：在UI里拖动其中一个控制点，本应只有附近的一段曲线变化，结果整条曲线都在动，跟Bezier没有区别。原因：把这些代码误用在了别的封装里。最常见的是用了某框架自带的Bezier曲线类，或者自己实现的B样条基函数里节点向量传错了对象，导致局部支撑性失效。另一个隐蔽原因是控制点数组被外部代码重新排序或插值过，破坏了原始拓扑。解决：确认求值路径用的是自己写的DeBoor函数；再打印相邻控制点之间的节点区间长度，看是否出现非单调跳变。B样条修改一个点最多影响4段曲线，如果影响全局，优先怀疑代码路径而不是数学原理。

5.4 现象：曲线在某个区间突然出现尖角或反折

现象：曲线整体光滑，但某个局部突然折出一个尖角，像控制点被外力拽过去了一样。原因：节点向量里出现了内部重复节点，且重复度等于p。当内部节点重复次数达到p时，曲线在该处的一阶导数降阶，允许形成角点，这是B样条的合法行为，却不是你想要的效果。另一种常见原因是控制点顺序写反，或者某个控制点的某个坐标值在数据录入时被写成0，导致局部扭曲。解决：先把控制点坐标和节点向量全部打印出来检查一遍：

for (int i = 0; i < (int)knot.size(); ++i) printf("knot[%d] = %.6f\n", i, knot[i]); for (int i = 0; i < (int)ctrl.size(); ++i) printf("ctrl[%d] = (%.3f, %.3f, %.3f)\n", i, ctrl[i].x, ctrl[i].y, ctrl[i].z);

同时检查内部节点是否出现重复且非首尾的相同数值。如果确认节点向量单调、控制点无误，再把重点转向数据源。

5.5 现象：两条曲线拼接处一阶不连续，轮廓有折痕

现象：两条独立构造的B样条曲线首尾相接，拼出来的轮廓在接缝处有明显折痕，检查单段曲线本身都正常，基函数和节点向量也没报错。原因：三次B样条单段内部是C2连续，但两段拼接处的连续性取决于端点控制点和相邻控制点的几何关系。最常见错误是两个曲线类各自构造了clamped节点向量，拼接时没有共享端点控制点，导致该点两侧的切向量方向不一致。解决：拼接时让两条曲线的端点控制点设为同一个点，并且该点两侧的相邻控制点三点共线、距离比例符合要求。这不是B样条算法的问题，是建模阶段的连续性约束，但出错时最容易被错怪成求值代码有bug。

6. 最后一道工序：光顺性验证与控制点密度的实战权衡

写完能画的B样条曲线类只是第一步，真正放进产品里之前必须做验证。我习惯的验证套路是先做密采样再检查形状：把u从0到1按每个节点区间100个点的密度细分，把坐标输出到文本文件，用图表工具快速地画出折线观察。B样条理论上是C2连续的，但如果控制点数据本身噪声大、或者节点向量配得不合理，曲线依然会在视觉上出现波浪和抖动。对运动控制类应用，还要检查一阶导数的变化是否平缓。

验证相邻采样点距离是否连续变化是一个简单好用的方法：

void ValidateCurve(const BSplineCurve& curve, int samples) { double uMin = curve.KnotMin(), uMax = curve.KnotMax(); Point3 prev = curve.Evaluate(uMin); for (int i = 1; i <= samples; ++i) { double u = uMin + (uMax - uMin) * i / samples; Point3 cur = curve.Evaluate(u); double dx = cur.x - prev.x, dy = cur.y - prev.y, dz = cur.z - prev.z; double dist = std::sqrt(dx * dx + dy * dy + dz * dz); printf("%d\t%.10f\n", i, dist); prev = cur; } }

这段代码用来探测采样密度不均匀：正常曲线相邻采样点距离应当连续变化，如果某段突然出现数量级的波动，多半是控制点里有坏点或者节点向量不平滑。注意一个常见误区：B样条不保证控制点密集的地方曲线就“更贴”，控制点过密反而会产生高频波浪，这在逆向扫描数据里经常出现。

关于控制点密度的取舍，我的一般策略是先用弦长参数化构造节点向量，再看曲率变化区段。曲率大的地方（比如半圆弧转直角的过渡）必须加密控制点；平直段放两三个控制点足够。给曲线做光顺靠增加控制点密度是最差的做法，先检查原始数据有没有离群点更有效。参数化方面，弦长参数化比均匀参数化抗噪；交互式造型用准均匀clamped即可，等形状稳定后再换成弦长参数提高贴合度。

把整个类收尾时，我会让FindSpan、DeBoor和BuildClampedKnot三个函数先通过一个半圆基准测试：用一个半径已知的半圆弧控制点数组求值，对比输出点半径误差控制在1e-3以内，再做集成。这个习惯让我每次改完都能快速验证而不是靠肉眼猜，已经成了固定流程，希望帮到你。

本文还有配套的精品资源，点击获取