计算机图形学核心考点精讲：光栅化、曲线拟合与工程应用

简介：《计算机图形学》课后习题参考答案面向正在学习计算机图形学课程的在校学生与备考者，系统整理了教材各章节的典型习题解答。内容紧扣计算机图形学核心知识点，涵盖计算机图形学与图形处理、模式识别的本质区别，矢量法与描点法两类图形生成方法，三维图形生成输出流水线，图形系统组成与分类，以及阴极射线管、光栅扫描显示器工作原理和显存容量计算等重点题目，适合课后自查、期末复习与考研基础巩固。资源为1个PDF文档，整体约6.19MB，按章节组织，可直接检索定位答案，省去分散查找的麻烦。目前已有1350人学习下载，是一份实用且针对性较强的计算机图形学配套参考材料，能帮助读者快速检验对基础概念和典型计算的掌握情况。

1. 图形学课后题背后的核心考点与工程映射

手头这份《计算机图形学》课后习题参考答案，覆盖了从图形生成原理、显示系统架构到光栅算法与曲线拟合的完整知识链。表面看是应试资料，实际上每一道题都对应着真实图形管线里的一个具体模块：矢量法与描点法的区别对应着 Swing 与 Canvas 的渲染差异，CRT 的电子枪与偏转系统对应着现代显示器的刷新机制，DDA 与 Bresenham 直线算法对应着底层栅格化的性能取舍，而三次样条与 Bezier 曲线的计算则是字体渲染和路径绘制的数学基础。阅读这份资料时，不必逐题背诵，更值得做的是把题目还原成技术决策场景去理解。

对于正在学习图形学基础、准备面试或需要快速温习渲染管线的开发者，这份答案能够帮助厘清许多容易混淆的概念边界。比如向量图形与点阵图形的本质区别、GKS 三种坐标系的换算关系、显存容量与颜色深度的计算逻辑，这些内容在 OpenGL 和 Vulkan 的学习中同样会反复出现。下面按主题拆解这些习题，并补充一些工程实践中会用到的对应实现。

2. 显示系统与图形生成方式：从 CRT 到现代光栅化

2.1 矢量法与描点法的本质差异

习题第一章第 6 题给出了计算机生成图形的两种基本方法：矢量法和描点法。矢量法通过控制电子束按顺序扫描坐标点间的短矢量来逼近曲线，描点法则是在光栅上点亮曲线经过的像素点。这个区别在今天的图形 API 中仍然成立——Graphics2D.drawLine()走的是矢量路径，经过光栅化阶段变成像素；而直接操作BufferedImage.setRGB()则是典型的描点法。

从实现角度看，矢量法生成的是几何描述，可以无限缩放而不损失质量，但它只适合表达规则图形。描点法以像素为单位记录颜色信息，能表达照片级的复杂画面，但放大后会看到锯齿。实际工程中两者往往结合使用：UI 层用矢量描述按钮和图标，底层渲染到纹理时再光栅化为像素数据。

2.2 显存容量与颜色深度的计算逻辑

第二章第 5 题给出了一个经典计算题：分辨率为 1024×1024 的光栅系统，每像素用 8 位和 12 位二进制表示时，各需多大显存，能显示多少颜色。计算过程如下：

width = 1024 height = 1024 bits_per_pixel = 8 # 或 12 memory_bytes = width * height * bits_per_pixel // 8 print(f"{bits_per_pixel}位/像素，显存 = {memory_bytes / 1024 / 1024:.2f} MB") print(f"颜色数 = {2 ** bits_per_pixel}")

8 位每像素时显存为 1MB，颜色 256 种；12 位时显存 1.5MB（实际显存按 2 的幂次取 2MB），颜色 4096 种。这里的核心是理解显存大小由分辨率和像素深度共同决定，而颜色数由像素深度直接决定。现代显卡动辄 8GB 显存，但若分辨率是 4K（3840×2160）且每像素 32 位，一帧所需显存约为 3840×2160×4≈33MB，一个 3D 场景的多重缓冲和纹理贴图很快就会吃满显存。这也是为什么游戏画质设置中纹理质量和显存占用直接挂钩。

2.3 光栅扫描显示器的组成与刷新机制

第二章第 4 题要求说明光栅扫描显示器的组成。除了 CRT 构造，这道题的核心在于理解光栅化的流程：电子束从左到右、从上到下逐行扫描，每一行的像素点按亮度值点亮。对应的现代实现是 LCD 面板的逐行刷新和 GPU 的扫描输出。在帧率（FPS）与刷新率（Hz）不匹配时会出现的画面撕裂，正是因为 GPU 输出的帧与显示器扫描正在进行的画面不同步。

工程上解决撕裂的垂直同步（VSync）机制，本质上是让 GPU 的帧缓冲切换与显示器的垂直消隐期对齐。理解了这个背景，再去读图形 API 里的glfwSwapInterval(1)就有更直观的感受。

2.4 GKS 坐标系与变换管线

第二章第 8 题涉及 GKS 的三种坐标系：世界坐标系（WC）、规范设备坐标系（NDC）和设备坐标系（DC）。这道题的要点是理解图形从应用程序到物理设备逐级变换的过程。现代图形管线中的坐标变换与此类似：

模型坐标 → 世界坐标 → 视图坐标 → 裁剪坐标 → NDC → 屏幕坐标

在 OpenGL 中，这个变换通过顶点着色器中的矩阵乘法完成。初学者往往困惑于 NDC 的取值范围为 [-1,1]，而屏幕坐标以像素为单位。中间的视口变换（viewport transform）负责将 NDC 映射到实际的窗口像素位置，对应 GKS 中从 NDC 到 DC 的阶段。

2.5 各章节考点速查表

3. 直线与圆弧生成算法：从 DDA 到 Bresenham 的代码落地

3.1 DDA 直线算法的实现与分析

第四章第 2 题要求用 DDA 算法从 (0,0) 到 (4,12) 和 (12,4) 画线。DDA 的核心思路是取步长方向上的较大者为迭代步数，每一步递增一个单位步长，另一个方向按斜率递增。代码实现如下：

void DDA_Line(int x1, int y1, int x2, int y2) { float increx, increy, x, y; float length; int i; // 取 Δx 和 Δy 中的较大者作为步进方向的总步数 if (abs(x2 - x1) > abs(y2 - y1)) length = abs(x2 - x1); else length = abs(y2 - y1); increx = (x2 - x1) / length; increy = (y2 - y1) / length; x = x1; y = y1; for (i = 1; i <= length; i++) { putpixel((int)(x + 0.5), (int)(y + 0.5), 1); // 四舍五入取整 x = x + increx; y = y + increy; } }

参数说明：length取 Δx 和 Δy 的绝对值较大者，保证迭代步数为较长轴的长度，使直线连续无断裂。increx和increy是每步的增量，其中较大者为 1，较小者为斜率。注意这里用浮点累加，每一步都做四舍五入取整，会产生累积误差。

DDA 的缺点是浮点运算和取整操作带来的性能开销与精度问题。在软件渲染等对性能敏感的场合，工程上更常使用纯整数运算的 Bresenham 算法。但 DDA 的直观性使它适合作为理解光栅化原理的入门算法。

3.2 Bresenham 直线算法与整数化优化

习题中第 5 题讨论了 DDA 与 Bresenham 的差异：DDA 存在取整误差，而 Bresenham 通过每一步根据判别式决定像素选择，结果更贴近真实直线。Bresenham 的整数化思路可以总结为利用误差项的符号来决定下一步的 y 是否递增：

void Bresenham_Line(int x1, int y1, int x2, int y2) { int dx = abs(x2 - x1); int dy = abs(y2 - y1); int sx = (x1 < x2) ? 1 : -1; int sy = (y1 < y2) ? 1 : -1; int err = dx - dy; while (1) { putpixel(x1, y1, 1); if (x1 == x2 && y1 == y2) break; int e2 = 2 * err; if (e2 > -dy) { err -= dy; x1 += sx; } if (e2 < dx) { err += dx; y1 += sy; } } }

这里的核心是用err代替浮点斜率，通过e2 = 2 * err与-dy、dx的比较来确定下一步的方向。Bresenham 只涉及整数加减法，适合在没有浮点单元的嵌入式设备或 GPU 硬件光栅化单元中实现。现代 GPU 的像素填充单元原理上仍是 Bresenham 的并行化扩展。

3.3 逐点比较法与角度 DDA 画圆弧

第四章第 3 题要求用逐点比较法画圆心在原点的 1/4 圆弧，给出了顺四象限、逆四象限和顺一象限三种实现。逐点比较法的核心是利用偏差判别式 F = x² + y² - R² 的符号决定下一步往哪个方向走：

// 从 A(5,0) 到 B(0,5) 的方向绘图 float f = 0.0; int x = 5, y = 0; while (abs(x - 0) > 1 || abs(y - 5) > 1) { if (f >= 0) { // 偏向圆外，向 -x 方向逼近 x = x - 1; f = f - 2 * x + 1; // 新的判别式 } else { // 偏向圆内，向 +y 方向逼近 y = y + 1; f = f + 2 * y + 1; } putpixel(x, y, 1); }

判别式更新的推导：F(x-1,y) = (x-1)² + y² - R² = F(x,y) - 2x + 1，F(x,y+1) = x² + (y+1)² - R² = F(x,y) + 2y + 1。这就是代码中每次更新f的依据。角度 DDA 法则通过参数方程 x = R·cos(i·α)，y = R·sin(i·α) 来生成圆上点序列，N = R·8 保证相邻点间隔不超过一个像素：

int N = R * 8; float a = 2 * 3.14159 / N; for (int i = 1; i <= N; i++) { int xi = x0 + R * cos(i * a); int yi = y0 + R * sin(i * a); line(x1, y1, xi, yi); x1 = xi; y1 = yi; }

逐点比较法适合无浮点、无三角函数的硬件环境，而角度 DDA 直观但引入了三角函数开销。实际工程中的圆弧绘制常使用中点画圆法（Bresenham 画圆），这一点习题第 6 题给出了完整的判别式推导过程。中点算法的核心是利用圆心对称性只计算 1/8 圆弧，再通过八分对称映射到整个圆。

4. 曲线曲面理论：三次样条、Bézier 与 B 样条的参数化实现

4.1 三次样条插值的边界条件与系数求解

第四章第 7 题给出了四个型值点，要求用抛物线端边界条件求解各段三次样条曲线。三次样条的核心是保证各段曲线在连接处值、一阶导、二阶导连续。工程中常见的应用场景包括关键帧动画的路径插值、字体轮廓的平滑处理。

求解过程分为三步：

第一步，计算相邻型值点的步长（即 x 的差）：

m1 = 2.5 - 1.0 = 1.5 m2 = 4.0 - 2.5 = 1.5 m3 = 5.0 - 4.0 = 1.0

第二步，按抛物线端边界条件列出方程组。抛物线端要求首尾处的二阶导为零（或等效约束），据此构造三弯矩方程组。题中给出的系数 λ 和 μ 由相邻步长比确定，最终联立方程求解出每个型值点处的一阶导数值 b1 到 b4：

b1 = 39/38, b2 = 37/38, b3 = 3/38, b4 = -41/38

第三步，由一阶导数推算各段的三次多项式系数，最终得到：

S1(x) = 2 + (39/38)(x-1) - (1/57)(x-1)²，x ∈ [1.0, 2.5] S2(x) = 3.5 + (37/38)(x-2.5) - (1/57)(x-2.5)² - (64/513)(x-2.5)³，x ∈ [2.5, 4.0] S3(x) = 4.5 + (3/38)(x-4) - (11/19)(x-4)²，x ∈ [4.0, 5.0]

可以看到 S1 和 S3 没有三次项，这是因为抛物线端边界条件使得首尾两段的二阶导为零，三次项系数自然消失。实际实现中一般写成矩阵形式求解，工程上更常见的做法是直接用库函数，比如 Python 的scipy.interpolate.CubicSpline，但理解背后的三弯矩方程有助于排查插值结果异常（如过冲、抖动）时的原因。

4.2 Bezier 曲线的矩阵表示与分段拼接

第四章第 8、9 题要求绘制三次 Bezier 曲线并实现多段拼接。三次 Bezier 的矩阵形式为：

P(t) = [t³ t² t 1] · M · [P0 P1 P2 P3]ᵀ 其中 M = [[-1, 3, -3, 1], [3, -6, 3, 0], [-3, 3, 0, 0], [1, 0, 0, 0]]

题中给出的计算结果，P(0) = [5,5]，P(0.5) = [11.25, 10.625]，P(1) = [10,5]，这些点描述了曲线从起点到终点的走向。代码实现中采用逐点采样 t 从 0 到 1，以 0.001 为步长计算曲线上的像素位置：

void drawCurve(int p0, int p1, int p2, int p3) { for (double t = 0; t <= 1.0; t += 0.001) { double tmpx = (-bP[p0].x + 3*bP[p1].x - 3*bP[p2].x + bP[p3].x) * t*t*t + (3*bP[p0].x - 6*bP[p1].x + 3*bP[p2].x) * t*t + (-3*bP[p0].x + 3*bP[p1].x) * t + bP[p0].x; double tmpy = (-bP[p0].y + 3*bP[p1].y - 3*bP[p2].y + bP[p3].y) * t*t*t + (3*bP[p0].y - 6*bP[p1].y + 3*bP[p2].y) * t*t + (-3*bP[p0].y + 3*bP[p1].y) * t + bP[p0].y; putpixel(tmpx, tmpy, 3); } }

这里将 Bernstein 基函数展开成了幂基形式，减少了每次迭代的乘法次数，是实践中的常见优化。多段 Bezier 拼接时，若要求曲线整体 C¹ 连续，需要保证前一段的 P3、后一段的 P0 共线且方向相同、长度成比例。题中第 9 题的数据点 [50,100] 到 [80,230] 再到 [100,270] 等点，按每 4 个点一组分段，实现了三段首尾相接的曲线。需要说明的是，Bezier 曲线不经过中间的型值点（控制点不落在曲线上），因此做插值拟合时需要反算控制点，这一点与样条曲线不同。

4.3 B 样条曲线的局部支撑性与连续拼接

第 10 题给出了二次 B 样条的矩阵形式并实现了两段曲线的绘制。均匀二次 B 样条的矩阵为：

P(t) = (1/2) · [t² t 1] · [[1, -2, 1], [-2, 2, 0], [1, 1, 0]] · [Pi Pi+1 Pi+2]ᵀ

代码实现将四个型值点分组成 [P0,P1,P2] 和 [P1,P2,P3] 两段，分别计算 t 从 0 到 1 采样，最终连接成完整曲线。B 样条与 Bezier 的关键区别在于局部支撑性：修改一个控制点只影响相邻的几段曲线，而 Bezier 修改任意控制点都会影响整条曲线。这一特性使 B 样条在交互式曲线设计中更实用。

习题中特别提到 NURBS 曲线产生的背景——它引入权因子后可以精确表示圆弧、椭圆等圆锥曲线。这是 Bezier 和均匀 B 样条做不到的，因为有理参数多项式才能在分母中引入形状调节能力。理解这一点，再去用 Cairo 或 Skia 的路径 API 时，心里就清楚底层是哪种数学表示。

4.4 最小二乘拟合的工程应用

第 12 题给出了 6 个数据点，分别用一次和二次多项式做最小二乘拟合。一次多项式的结果为：

y = 1.4608 + 0.9706x

二次多项式的结果为：

y = 1.0793 + 1.0921x - 0.006796x²

从系数可见二次项绝对值很小，说明数据接近线性。最小二乘的矩阵解法为构造正规方程：

AᵀAx = Aᵀb

其中 A 的行是 [1, x_i]（一次）或 [1, x_i, x_i²]（二次）。这个解法在曲线拟合、传感器校准、数据分析中普遍使用。工程上通常直接用numpy.polyfit(x, y, deg)，底层就是通过 SVD 求解正规方程以避免病态矩阵，结果比手工构造法更稳定。

5. 多边形的区域填充：ET 表与 AET 表的维护

第 13 题要求用多边形区域填充算法生成实心五边形。题中给了五个顶点坐标 (10,10)、(15,5)、(12,5)、(8,2)、(4,5)，并给出了 ET（边表）与 AET（活化边表）的建立思路。

扫描线填充算法的步骤可以拆解为建表、维护、填充三个阶段：

第一阶段，建立全局边表 ET。对每条非水平边计算 ymax（该边较上端的 y 值）、x（该边在下端点处的 x 坐标）和 m 的倒数 1/m（x 随 y 变化的步长）。扫描线从 y=2 开始向上推进，对应每一条扫描线，将与当前扫描线相交的边加入 ET。

第二阶段，维护活化边表 AET。扫描线每向上移动一格，需要更新 x 的值：

x = x + 1/m

同时，当扫描线到达某条边的 ymax 时，将该边从 AET 中删除。

第三阶段，对 AET 中的边按 x 值排序，两两配对填充扫描线区间。例如某扫描线上 AET 有两条边，左边界 x=5，右边界 x=12，则从 x=5 到 x=12 逐像素填充。

经典实现如下：

// 伪代码结构 struct Edge { int ymax; float x; float dx; // 1/m struct Edge* next; }; // 扫描线主循环 for (int y = ymin; y <= ymax; y++) { // 1. 将 ET[y] 中的边加入 AET // 2. 按 x 排序 // 3. 两两配对并填充区间 // 4. 删除 ymax == y 的边 // 5. 更新每条边的 x += dx }

工程上需要注意的两个细节：一是水平边需要跳过，因为它的上下两条扫描线会各自处理与它相邻的边；二是当多边形的顶点恰好落在扫描线上时，需要做奇偶校验以避免重复计数。

6. 图形学课后题到工程实践的落地技巧

把这份答案里的知识迁移到实际项目时，有几个判断可以直接借鉴：

第一个技巧是区分 DDA 与 Bresenham 的适用边界。如果目标是软件渲染且性能敏感，Bresenham 是必然选择；如果只是原型验证算法正确性，DDA 的代码可读性更好。

第二个技巧是验证曲线拟合结果。比如题目中三次样条的系数求出来后，可以代入中间点验证连续性：

def S1(x): return 2 + (39/38)*(x-1) - (1/57)*(x-1)**2 def S2(x): return 3.5 + (37/38)*(x-2.5) - (1/57)*(x-2.5)**2 - (64/513)*(x-2.5)**3 # 在 x=2.5 处验证 print(S1(2.5), S2(2.5)) # 应均为 3.5

类似的道理，B 样条拼接处也应验证一阶导数的连续性。这类验证手段在调试动画路径或字体轮廓时非常实用。

第三个技巧是处理浮点坐标时的取整策略。DDA 算法中的putpixel((int)(x+0.5), ...)采用四舍五入，而 Bresenham 通过误差累积自然完成了类似效果。在图形 API 中也有类似选择，比如抗锯齿渲染中常见的子像素偏移就是更精细的取整策略。

第四个技巧是显存预算的快速估算。拿到分辨率 × 像素深度的题目时，可以直接心算，但工程上还需要额外考虑多重采样（MSAA）的倍数、深度缓冲（24 或 32 位）以及纹理显存占用，这些加在一起常常是理论帧缓冲的 3 到 5 倍。

这份资料作为复习索引的价值在于：它把图形学的知识点按章节组织，适合建立知识框架后逐项对照复习。遇到具体算法记不清细节时，翻到对应题目的推导过程和参考代码，能较快找回上下文。真正上手时，还是建议在 Python 的 Pillow 或 C++ 的 SDL 中自己实现一遍，在 B 站或 GitHub 上也能找到不少参考实现来对比验证。

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