1. 项目概述：当期末作业遇上DEV C++

又到期末了，是不是感觉计算机图形学这门课既迷人又让人头疼？看着那些复杂的算法和炫酷的渲染效果，自己动手写代码时却常常卡在第一步。如果你正在使用DEV C++作为开发环境，并且面对“实现1-6个简单图形学示例”这样的期末作业要求感到无从下手，那么这篇分享就是为你准备的。

我经历过无数次这样的场景：学生时代为了完成图形学作业，在DEV C++这个轻量但“古老”的IDE里折腾各种图形库和配置。DEV C++因其小巧、免安装、对C/C++标准支持直接（尤其是对学校教学常用的旧标准）而备受国内高校C语言和C++入门课程的青睐。但用它来做图形学编程，尤其是涉及到窗口创建、图形绘制时，往往会遇到一些特有的“坑”。本文旨在为你提供一个清晰的路线图，从环境配置到核心算法实现，手把手带你完成六个典型的计算机图形学期末作业示例。这些示例覆盖了从基本图元绘制到简单二维变换的核心内容，确保你能在DEV C++环境下顺利跑通，并理解背后的原理。

2. 环境准备与配置：搭建你的图形学“画板”

在DEV C++里做图形学编程，第一步不是写代码，而是搭建一个能“画画”的环境。和现代IDE（如Visual Studio）不同，DEV C++默认不包含图形库，我们需要手动配置。

2.1 选择与配置图形库

对于DEV C++，最常用且兼容性最好的图形库是graphics.h（通常指BGI图形库的移植版，如WinBGIm）。这是一个非常古老的库，源自Turbo C的Borland Graphics Interface。虽然古老，但它函数简单，非常适合教学和实现基础的图形学算法，如画线、画圆、填充等。

配置步骤：

1. 下载库文件：你需要获取graphics.h头文件和对应的库文件（如libbgi.a）。可以在网上搜索“WinBGIm for Dev C++”找到打包好的资源。
2. 放置文件：
   • 将graphics.h复制到DEV C++的include目录下（例如：C:\Program Files (x86)\Dev-Cpp\MinGW64\include）。
   • 将libbgi.a复制到DEV C++的lib目录下（例如：C:\Program Files (x86)\Dev-Cpp\MinGW64\lib）。
3. 项目链接设置：在DEV C++中，打开你的项目，点击菜单栏的“项目” -> “项目属性”。
   • 在“参数”选项卡的“链接器”框中，你需要添加链接库。通常需要添加-lbgi -lgdi32 -lcomdlg32 -luuid -loleaut32 -lole32。这一步至关重要，它告诉编译器在生成可执行文件时需要链接哪些额外的库来实现图形功能。

注意：不同版本的DEV C++或MinGW路径可能略有不同。如果编译时提示找不到graphics.h或链接错误，首先检查文件路径是否正确。

2.2 创建第一个图形窗口

配置好后，我们来写一个“Hello Graphics”程序测试环境。

#include <graphics.h> #include <conio.h> // 用于_getch()函数 int main() { // 初始化图形模式，创建一个640x480的窗口 int gd = DETECT, gm; initgraph(&gd, &gm, ""); // 设置文本样式和颜色，在窗口中央输出文字 settextstyle(DEFAULT_FONT, HORIZ_DIR, 2); setcolor(YELLOW); outtextxy(200, 220, "Hello, Computer Graphics!"); // 画一条红色的线 setcolor(RED); line(100, 100, 500, 100); // 画一个绿色的圆 setcolor(GREEN); circle(320, 240, 50); // 等待用户按键 _getch(); // 关闭图形模式 closegraph(); return 0; }

代码解析与避坑：

• initgraph(&gd, &gm, “”)：这是初始化图形驱动和模式的函数。DETECT是一个宏，表示让系统自动检测最佳的图形模式。第三个参数是驱动程序的路径，为空表示在当前目录查找。
• closegraph()：程序结束前必须调用此函数来关闭图形模式，释放资源，否则可能导致程序异常退出或资源未释放。
• 常见问题：如果你的程序一闪而过，看不到图形窗口，通常是因为没有_getch()或类似的阻塞函数（如delay(5000)）来等待。图形窗口是一个独立的消息循环，主函数执行完毕会立即关闭。

实操心得：建议将上述链接器参数（-lbgi -lgdi32...）保存为一个“图形项目”的模板。每次新建图形学作业项目时，直接应用这个模板，可以省去重复配置的麻烦。

3. 六个核心示例的逐步实现

下面，我们将围绕六个经典的图形学入门作业，在DEV C++环境中逐一实现。每个示例都包含核心代码、原理解析和注意事项。

3.1 示例一：DDA直线绘制算法

作业要求：不使用line()函数，自己实现DDA（Digital Differential Analyzer）算法在屏幕上绘制一条直线。

核心思想：DDA算法是一种基于微分方程的直线生成算法。对于斜率m（|m| <= 1）的直线，我们让x每次递增1，y则递增m。对于|m|>1的直线，则让y每次递增1，x递增1/m，以保证点的连续性。

#include <graphics.h> #include <math.h> #include <conio.h> void drawLine_DDA(int x1, int y1, int x2, int y2, int color) { int dx = x2 - x1; int dy = y2 - y1; int steps; float xIncrement, yIncrement, x = x1, y = y1; // 判断哪个方向的变化量更大，以其作为步数 if (abs(dx) > abs(dy)) { steps = abs(dx); } else { steps = abs(dy); } // 计算每一步的增量 xIncrement = (float)dx / steps; yIncrement = (float)dy / steps; // 开始绘制 putpixel(round(x), round(y), color); // 绘制第一个点 for (int i = 0; i < steps; i++) { x += xIncrement; y += yIncrement; putpixel(round(x), round(y), color); // 四舍五入取整后画点 } } int main() { int gd = DETECT, gm; initgraph(&gd, &gm, ""); // 使用自定义的DDA算法画线 drawLine_DDA(100, 100, 500, 300, RED); // 对比使用库函数画的线 setcolor(BLUE); line(100, 150, 500, 350); _getch(); closegraph(); return 0; }

注意事项：

1. 浮点数与取整：x和y是浮点数，但屏幕坐标是整数。round()函数（或简单的(int)(x+0.5)）进行四舍五入是关键，否则直线会出现明显的“阶梯”不均匀现象。
2. 效率问题：DDA算法每步都需要浮点数加法和取整运算，效率不是最高。但它原理简单，是理解光栅化直线生成的基础。
3. 特殊直线：注意处理水平线（dy=0）和垂直线（dx=0）的情况，虽然上述代码能处理，但理解其步数steps的选择逻辑很重要。

3.2 示例二：Bresenham直线绘制算法

作业要求：实现更高效的Bresenham直线算法，仅使用整数运算。

核心思想：Bresenham算法通过一个误差项e的符号来决定下一个像素点的位置，完全避免了浮点数运算，效率极高。

void drawLine_Bresenham(int x1, int y1, int x2, int y2, int color) { int dx = abs(x2 - x1); int dy = abs(y2 - y1); int sx = (x1 < x2) ? 1 : -1; // x方向步进符号 int sy = (y1 < y2) ? 1 : -1; // y方向步进符号 int err = dx - dy; int e2; while (1) { putpixel(x1, y1, color); if (x1 == x2 && y1 == y2) break; e2 = 2 * err; if (e2 > -dy) { // 误差项与-dy比较，决定是否在x方向移动 err -= dy; x1 += sx; } if (e2 < dx) { // 误差项与dx比较，决定是否在y方向移动 err += dx; y1 += sy; } } } int main() { int gd = DETECT, gm; initgraph(&gd, &gm, ""); // 绘制多条不同方向的Bresenham直线 drawLine_Bresenham(50, 50, 400, 150, GREEN); drawLine_Bresenham(50, 200, 400, 50, YELLOW); drawLine_Bresenham(200, 400, 200, 100, CYAN); // 垂直线 _getch(); closegraph(); return 0; }

原理解析：算法的核心是误差项err。它代表了从理想直线到当前候选像素点的垂直距离（的某种度量）。通过判断err的符号，我们可以决定下一个像素是选右边的点（误差小）还是右上角的点（误差大）。代码中通过2*err与dx、dy的比较来做出决策，巧妙地用整数运算完成了判断。

实操心得：Bresenham算法是图形学硬件实现的基石。务必亲手推导一遍err的更新公式，理解其几何意义。在作业报告中，画出决策过程的示意图是加分项。

3.3 示例三：中点圆绘制算法

作业要求：实现中点圆算法，绘制一个圆。

核心思想：利用圆的八分对称性，只需计算八分之一圆弧上的点，然后通过对称得到整个圆。算法在候选像素的中点处计算判别式的值，根据其符号决定下一个像素点。

void drawCircle_Midpoint(int xc, int yc, int r, int color) { int x = 0, y = r; int d = 1 - r; // 初始决策参数 // 绘制八分圆上的初始点（及对称点） putpixel(xc + x, yc + y, color); putpixel(xc - x, yc + y, color); putpixel(xc + x, yc - y, color); putpixel(xc - x, yc - y, color); putpixel(xc + y, yc + x, color); putpixel(xc - y, yc + x, color); putpixel(xc + y, yc - x, color); putpixel(xc - y, yc - x, color); while (x < y) { x++; if (d < 0) { d += 2 * x + 1; // 选择E点 } else { y--; d += 2 * (x - y) + 1; // 选择SE点 } // 绘制当前八分点及其七个对称点 putpixel(xc + x, yc + y, color); putpixel(xc - x, yc + y, color); putpixel(xc + x, yc - y, color); putpixel(xc - x, yc - y, color); putpixel(xc + y, yc + x, color); putpixel(xc - y, yc + x, color); putpixel(xc + y, yc - x, color); putpixel(xc - y, yc - x, color); } } int main() { int gd = DETECT, gm; initgraph(&gd, &gm, ""); drawCircle_Midpoint(320, 240, 100, LIGHTRED); // 再画一个同心圆 drawCircle_Midpoint(320, 240, 60, LIGHTBLUE); _getch(); closegraph(); return 0; }

算法细节：决策参数d的推导是基于圆方程F(x,y) = x^2 + y^2 - R^2。在候选像素中点M处计算F(M)，若F(M)<0，则中点在圆内，选择E像素；否则选择SE像素。递推公式d的更新就是为了高效计算F(M)的变化量。

常见问题：绘制的圆边缘有时会出现“缺口”或不对称。这通常是因为while (x < y)这个条件。对于从(0,R)开始绘制第一象限的八分圆，当x == y时，对应45度角的位置，此时循环应该停止，因为八分圆已经画完。确保你的对称点计算涵盖了所有八种情况。

3.4 示例四：多边形扫描线填充算法

作业要求：实现扫描线填充算法，对一个给定的多边形进行颜色填充。

核心思想：用一系列水平扫描线从上到下切割多边形。求出扫描线与多边形各边的交点，将这些交点按x坐标排序，然后两两配对，在配对区间内绘制像素。

#include <vector> #include <algorithm> // 用于sort // 边表项（Edge Table Entry） struct Edge { int y_max; // 边的最大y坐标 float x_curr; // 当前扫描线与边交点的x坐标（用于活化边表） float dx; // 边的斜率的倒数 (1/m) Edge* next; Edge(int ymax, float x, float slope_inv) : y_max(ymax), x_curr(x), dx(slope_inv), next(nullptr) {} }; // 简单的多边形顶点（假设多边形是凸的或自相交已处理） int polyPoints[][2] = {{200,100}, {400,150}, {350,300}, {250,350}, {100,250}}; int nVertices = 5; void scanlineFill(int vertices[][2], int n, int color) { // 1. 初始化边表（ET） std::vector<Edge*> ET[1024]; // 假设屏幕高度不超过1024 int ymin = 1024, ymax = 0; // 构建ET for (int i = 0; i < n; i++) { int x1 = vertices[i][0]; int y1 = vertices[i][1]; int x2 = vertices[(i+1)%n][0]; int y2 = vertices[(i+1)%n][1]; if (y1 == y2) continue; // 忽略水平边 // 确保从y值小的端点开始 if (y1 > y2) { std::swap(x1, x2); std::swap(y1, y2); } float dx_inv = (float)(x2 - x1) / (y2 - y1); // 1/m Edge* edge = new Edge(y2, x1, dx_inv); // 将边插入到ET中y1对应的桶里 ET[y1].push_back(edge); // 更新扫描线范围 if (y1 < ymin) ymin = y1; if (y2 > ymax) ymax = y2; } // 2. 初始化活化边表（AET）为空 std::vector<Edge*> AET; // 3. 从ymin到ymax遍历每条扫描线 for (int y = ymin; y <= ymax; y++) { // 3.1 将ET中对应y桶的边加入AET for (Edge* e : ET[y]) { AET.push_back(e); } // 删除ET[y]的指针，避免内存泄漏（实际中需更严谨管理） ET[y].clear(); // 3.2 从AET中删除y_max == y的边（该边已处理完） AET.erase(std::remove_if(AET.begin(), AET.end(), [y](Edge* e) { return e->y_max == y; }), AET.end()); // 3.3 按x_curr对AET中的边排序 std::sort(AET.begin(), AET.end(), [](Edge* a, Edge* b) { return a->x_curr < b->x_curr; }); // 3.4 填充配对区间 for (size_t i = 0; i < AET.size(); i += 2) { if (i + 1 < AET.size()) { int x_start = (int)(AET[i]->x_curr + 0.5); int x_end = (int)(AET[i+1]->x_curr + 0.5); for (int x = x_start; x <= x_end; x++) { putpixel(x, y, color); } } } // 3.5 更新AET中所有边的x_curr (x = x + dx) for (Edge* e : AET) { e->x_curr += e->dx; } } // 清理动态分配的内存（简化示例，生产代码需用智能指针等） for (auto& bucket : ET) { for (Edge* e : bucket) delete e; } for (Edge* e : AET) delete e; } int main() { int gd = DETECT, gm; initgraph(&gd, &gm, ""); // 先画出多边形边框 setcolor(WHITE); for (int i = 0; i < nVertices; i++) { int next = (i + 1) % nVertices; line(polyPoints[i][0], polyPoints[i][1], polyPoints[next][0], polyPoints[next][1]); } // 填充多边形 scanlineFill(polyPoints, nVertices, MAGENTA); _getch(); closegraph(); return 0; }

实现要点与避坑：

1. 数据结构：边表（ET）和活化边表（AET）是算法的核心。这里用vector<Edge*>数组模拟ET，用vector<Edge*>作为AET。实际作业中，你可能需要自己实现链表来管理边，以练习数据结构。
2. 水平边处理：水平边不与任何扫描线相交，应直接忽略（if (y1 == y2) continue;）。
3. 交点配对：排序后，交点总是成对出现（第0个和第1个，第2个和第3个...），在两两之间填充。
4. 顶点处理：对于非水平边的顶点，需要小心处理，避免一个顶点被计算两次（奇点问题）。一个常见的解决方法是，在构建ET时，如果一条边从某个顶点开始，且该顶点是局部极小点，则将该边的y_max减1。上述简化代码未处理此问题，对于凸多边形尚可，复杂多边形可能出现填充错误。这是作业中的一个难点和考察点。
5. 内存管理：示例中使用了new，但未完全妥善释放。在DEV C++这种教学环境中问题不大，但良好的习惯是使用std::unique_ptr或确保在函数末尾释放所有分配的Edge对象。

3.5 示例五：二维几何变换（平移、旋转、缩放）

作业要求：实现一个三角形的平移、绕某点旋转、缩放，并显示变换过程。

核心思想：使用齐次坐标和变换矩阵。一个点(x, y)可以表示为[x, y, 1]。变换通过矩阵乘法实现。

• 平移矩阵 T(tx, ty)：[[1, 0, tx], [0, 1, ty], [0, 0, 1]]
• 旋转矩阵 R(θ)（绕原点逆时针）：[[cosθ, -sinθ, 0], [sinθ, cosθ, 0], [0, 0, 1]]
• 缩放矩阵 S(sx, sy)：[[sx, 0, 0], [0, sy, 0], [0, 0, 1]]

绕任意点(cx, cy)旋转的步骤：1. 平移物体使旋转中心到原点；2. 绕原点旋转；3. 平移回原位置。即：T(cx,cy) * R(θ) * T(-cx, -cy)。

#include <math.h> #define PI 3.1415926535 // 二维点结构体 struct Point2D { float x, y; }; // 矩阵乘法：3x3 矩阵 * 3x1 齐次坐标向量 void transformPoint(float mat[3][3], Point2D& p) { float x_new = mat[0][0]*p.x + mat[0][1]*p.y + mat[0][2]*1; float y_new = mat[1][0]*p.x + mat[1][1]*p.y + mat[1][2]*1; // 齐次坐标的w分量（mat[2][2]）为1，忽略第三行计算 p.x = x_new; p.y = y_new; } // 绘制三角形 void drawTriangle(Point2D p1, Point2D p2, Point2D p3, int color) { setcolor(color); line((int)p1.x, (int)p1.y, (int)p2.x, (int)p2.y); line((int)p2.x, (int)p2.y, (int)p3.x, (int)p3.y); line((int)p3.x, (int)p3.y, (int)p1.x, (int)p1.y); } int main() { int gd = DETECT, gm; initgraph(&gd, &gm, ""); Point2D tri[3] = {{100,100}, {150,50}, {200,100}}; // 初始三角形 // 1. 绘制原始三角形 drawTriangle(tri[0], tri[1], tri[2], WHITE); _getch(); cleardevice(); // 2. 平移 (tx=50, ty=30) float translate[3][3] = {{1,0,50}, {0,1,30}, {0,0,1}}; for (int i=0; i<3; i++) transformPoint(translate, tri[i]); drawTriangle(tri[0], tri[1], tri[2], GREEN); _getch(); // 3. 绕三角形第一个顶点旋转45度 Point2D center = tri[0]; // 旋转中心 float angle = 45.0 * PI / 180.0; // 构建绕任意点旋转的复合矩阵: T * R * T^-1 float rotate[3][3]; // 初始化为单位矩阵 for(int i=0;i<3;i++) for(int j=0;j<3;j++) rotate[i][j]=(i==j)?1:0; // 这里为了清晰，分步计算。实际可以合并矩阵。 // 步骤1: 平移到原点 float t1[3][3] = {{1,0,-center.x}, {0,1,-center.y}, {0,0,1}}; // 步骤2: 旋转 float r[3][3] = {{cos(angle), -sin(angle),0}, {sin(angle),cos(angle),0},{0,0,1}}; // 步骤3: 平移回去 float t2[3][3] = {{1,0,center.x}, {0,1,center.y}, {0,0,1}}; // 合并矩阵 (这里简单起见，我们直接对点应用三次变换) for (int i=0; i<3; i++) { transformPoint(t1, tri[i]); // 移到原点 transformPoint(r, tri[i]); // 旋转 transformPoint(t2, tri[i]); // 移回 } drawTriangle(tri[0], tri[1], tri[2], RED); _getch(); // 4. 缩放 (sx=1.5, sy=0.8)，以旋转后的第一个顶点为中心 center = tri[0]; float scale[3][3] = {{1.5,0,0}, {0,0.8,0}, {0,0,1}}; // 同样需要复合变换：先平移到中心点，缩放，再平移回去 float t1_s[3][3] = {{1,0,-center.x}, {0,1,-center.y}, {0,0,1}}; float t2_s[3][3] = {{1,0,center.x}, {0,1,center.y}, {0,0,1}}; for (int i=0; i<3; i++) { transformPoint(t1_s, tri[i]); transformPoint(scale, tri[i]); transformPoint(t2_s, tri[i]); } drawTriangle(tri[0], tri[1], tri[2], YELLOW); _getch(); closegraph(); return 0; }

关键点解析：

• 矩阵运算：虽然上述代码分步应用了变换，但更好的做法是预先计算好复合矩阵M = T2 * R * T1，然后一次性应用到所有点上，效率更高。这是作业优化的重要方向。
• 齐次坐标：引入第三维w=1，使得平移操作也能用矩阵乘法表示，统一了所有变换。
• 变换顺序：矩阵乘法不满足交换律，因此变换顺序非常重要。先旋转再平移，与先平移再旋转，结果截然不同。
• 浮点精度：三角函数和浮点运算会引入误差。在将最终坐标转换为整数像素位置时，使用四舍五入(int)(x+0.5)。

3.6 示例六：Cohen-Sutherland直线段裁剪算法

作业要求：实现Cohen-Sutherland算法，裁剪一个矩形窗口外的线段部分。

核心思想：用区域码（4位二进制）表示端点相对于裁剪窗口的位置（上、下、右、左）。通过区域码的位运算快速判断线段完全可见、完全不可见或需要求交。

// 定义区域码 const int INSIDE = 0; // 0000 const int LEFT = 1; // 0001 const int RIGHT = 2; // 0010 const int BOTTOM = 4; // 0100 const int TOP = 8; // 1000 // 矩形裁剪窗口 int xmin = 200, xmax = 500; int ymin = 150, ymax = 350; // 计算点的区域码 int computeCode(float x, float y) { int code = INSIDE; if (x < xmin) code |= LEFT; else if (x > xmax) code |= RIGHT; if (y < ymin) code |= BOTTOM; else if (y > ymax) code |= TOP; return code; } // Cohen-Sutherland 裁剪算法 bool cohenSutherlandClip(float &x1, float &y1, float &x2, float &y2) { int code1 = computeCode(x1, y1); int code2 = computeCode(x2, y2); bool accept = false; while (true) { if ((code1 == 0) && (code2 == 0)) { // 完全在窗口内 accept = true; break; } else if (code1 & code2) { // 两个端点都在窗口的同一外侧，完全不可见 break; } else { // 部分可见，需要裁剪。选择至少一个在窗口外的点 int code_out; float x, y; if (code1 != 0) code_out = code1; else code_out = code2; // 求交点的坐标 if (code_out & TOP) { x = x1 + (x2 - x1) * (ymax - y1) / (y2 - y1); y = ymax; } else if (code_out & BOTTOM) { x = x1 + (x2 - x1) * (ymin - y1) / (y2 - y1); y = ymin; } else if (code_out & RIGHT) { y = y1 + (y2 - y1) * (xmax - x1) / (x2 - x1); x = xmax; } else if (code_out & LEFT) { y = y1 + (y2 - y1) * (xmin - x1) / (x2 - x1); x = xmin; } // 用交点替换窗口外的点 if (code_out == code1) { x1 = x; y1 = y; code1 = computeCode(x1, y1); } else { x2 = x; y2 = y; code2 = computeCode(x2, y2); } } } return accept; } int main() { int gd = DETECT, gm; initgraph(&gd, &gm, ""); // 绘制裁剪窗口 rectangle(xmin, ymin, xmax, ymax); // 定义几条测试线段 float lines[][4] = { {100, 100, 450, 300}, // 部分在内部 {150, 400, 350, 100}, // 穿过窗口 {50, 50, 150, 180}, // 完全在外部 {250, 200, 400, 250} // 完全在内部 }; for (int i = 0; i < 4; i++) { float x1 = lines[i][0], y1 = lines[i][1]; float x2 = lines[i][2], y2 = lines[i][3]; // 绘制原始线段（灰色） setcolor(LIGHTGRAY); line((int)x1, (int)y1, (int)x2, (int)y2); // 进行裁剪 if (cohenSutherlandClip(x1, y1, x2, y2)) { // 绘制裁剪后的线段（亮绿色） setcolor(LIGHTGREEN); line((int)(x1+0.5), (int)(y1+0.5), (int)(x2+0.5), (int)(y2+0.5)); } // 如果被拒绝，则不绘制 delay(500); // 延迟观察过程 } _getch(); closegraph(); return 0; }

算法详解：

1. 编码：computeCode函数根据点与窗口四条边的位置关系，生成一个4位区域码。例如，一个点在窗口左上角，其编码就是TOP | LEFT。
2. 快速接受/拒绝：
   • 完全可见：两个端点的编码都为INSIDE(0)。
   • 完全不可见：两个端点的编码进行按位与操作结果不为0，意味着它们位于窗口某条边的同一侧（例如，都在左边）。
3. 裁剪求交：对于既不完全可见也不完全不可见的线段，算法选择一个位于窗口外的端点（code_out），根据其编码判断它与窗口的哪条边相交，然后利用直线的参数方程求出交点坐标。用该交点替换原来的外部端点，并更新其区域码。
4. 循环：这个过程需要循环进行，因为一次裁剪后，新的线段可能仍然有一部分在窗口外（例如，线段从左上角穿到右下角，需要裁剪两次）。

注意事项：

• 浮点除法：求交计算涉及除法(y2-y1)和(x2-x1)，当线段垂直或水平时，分母可能为0。在实际实现中，需要处理这种特殊情况。上述代码假设线段不垂直/水平，或已做处理。
• 效率：Cohen-Sutherland算法在大多数情况下能快速拒绝或接受线段，适合硬件实现。但在最坏情况下（线段斜穿窗口角落），可能需要多次求交。

4. 常见问题与调试技巧实录

在DEV C++中完成这些图形学作业，除了算法本身，环境与调试是更大的挑战。以下是我踩过的一些坑和总结的技巧。

4.1 编译与链接错误

• undefined reference to ‘initgraph’等链接错误：

  • 原因：这是最常见的问题，意味着链接器没有找到graphics.h对应的库实现。
  • 解决：确保你已正确将libbgi.a放入lib文件夹，并且项目链接参数设置正确。务必完整添加-lbgi -lgdi32 -lcomdlg32 -luuid -loleaut32 -lole32。注意，参数前的-l是“减号L”，不是数字1。
  • 检查方法：在DEV C++中，点击“工具”->“编译选项”->“编译器”选项卡，查看“在连接器命令行加入以下命令”框中是否有上述参数。更可靠的是在“项目”->“项目属性”->“参数”->“链接器”中设置。

• graphics.h: No such file or directory：

  • 原因：编译器找不到头文件。
  • 解决：确认graphics.h已复制到正确的include目录。可以在代码中尝试使用绝对路径包含，如#include “C:/Dev-Cpp/include/graphics.h”来测试，但这不推荐作为最终方案。

4.2 运行时问题

• 程序窗口一闪而过：

  • 原因：控制台程序执行完毕立即退出。initgraph会创建一个独立的图形窗口，但主函数结束后，这个窗口也会被关闭。
  • 解决：在closegraph()之前，使用getch()、_getch()（需#include <conio.h>）或delay(毫秒数)（需#include <dos.h>或graphics.h已包含）来阻塞程序，等待用户输入或一段时间。

• 图形窗口无响应或黑屏：

  • 原因1：坐标超出屏幕范围。DEV C++的图形窗口大小取决于initgraph调用时设置的图形模式。默认模式通常是全屏或一个较大分辨率。使用getmaxx()和getmaxy()函数获取当前图形模式下的最大坐标。
  • 解决：在绘图前，先获取边界，确保你的坐标(0 <= x <= getmaxx()) && (0 <= y <= getmaxy())。
  • 原因2：颜色值不正确。graphics.h中预定义的颜色常量如RED、GREEN等是有限的。使用setcolor(COLOR)设置颜色，COLOR应在有效范围内（如0-15）。使用setfillstyle和floodfill进行填充时也需注意。
  • 调试技巧：在关键位置（如循环开始、函数调用后）使用printf向控制台输出变量值。虽然DEV C++图形模式下控制台可能被隐藏，但输出信息有助于逻辑调试。或者，可以先用简单图形（如画一个点、一条线）测试环境是否正常。

4.3 算法实现中的逻辑错误

• 直线/圆画不出来或形状怪异：

  • 检查边界和步长：对于DDA/Bresenham算法，检查循环条件是否正确，是否漏画了起点或终点。对于Bresenham算法，确保误差项err的初始化 (dx - dy) 和更新逻辑 (err +/- dx, dy) 正确。
  • 检查对称性：对于圆算法，确保八个对称点的计算正确，特别是正负号。
  • 使用调试器：DEV C++内置了GDB调试器。在关键变量（如x,y,d,err）上设置断点，单步执行，观察其变化是否符合预期。这是理解算法和定位错误最有效的方法。

• 扫描线填充出现漏填或错填：

  • 重点检查ET/AET的构建和更新：特别是新边插入AET时，是否按x_curr正确排序了？更新x_curr(x += dx) 是否在填充之后进行？
  • 验证交点配对：在循环内，打印出AET中每条边的x_curr和y_max，检查排序后的交点是否真的成对。
  • 处理顶点奇点：这是最容易出错的地方。实现一个更健壮的ET构建函数，对于局部极值点（即共享该顶点的两条边在顶点两侧），需要进行特殊处理（如将其中一条边的y_max减1），避免一个顶点产生两个交点。

• 变换后图形位置不对：

  • 检查变换矩阵和顺序：确认平移值tx, ty、旋转角度θ（弧度制）、缩放系数sx, sy是否正确。牢记矩阵乘法顺序从右向左执行。绕任意点变换时，三个矩阵（T-1 * R * T）的顺序不能错。
  • 检查参考点：旋转和缩放的中心点坐标是否正确。是绕原点还是绕物体中心或某个顶点？
  • 分步调试：不要一次性写完所有变换。先实现并测试平移，再实现旋转，最后组合。每步都绘制出来看看。

4.4 提升作业质量的建议

1. 模块化设计：将每个算法（如drawLine_DDA,drawCircle_Midpoint,scanlineFill）封装成独立的函数，放在单独的头文件（.h）和源文件（.cpp）中。主程序只负责调用和显示。这使代码清晰，易于调试和复用。
2. 交互功能：尝试超越作业基础要求。例如，让用户通过键盘（kbhit,getch）或鼠标（graphics.h中有getmouseclick等函数，但需查具体实现）来动态输入点、选择算法、改变参数。这能极大提升作业的完整度和观感。
3. 可视化算法过程：对于DDA/Bresenham算法，可以延迟绘制每个点（delay(10)），让绘制过程“动画”起来。对于扫描线算法，可以高亮显示当前扫描线、AET中的边和正在填充的区间。这不仅能帮助你自己理解，也是向老师展示你深刻理解算法的好方法。
4. 撰写清晰的报告：代码重要，报告同样重要。在报告中：
   • 简述原理：用你自己的话描述算法思想。
   • 展示关键代码片段：并加以注释。
   • 附上运行结果截图。
   • 分析遇到的问题及解决方案：这是体现你思考和调试能力的关键部分。
   • 总结与心得：谈谈通过实现这个算法，你对图形学有了哪些新的认识。

DEV C++虽然简陋，但它轻量、直接，能让你更专注于图形学算法本身，而不是复杂的IDE和框架。通过亲手实现这六个基础示例，你不仅能顺利完成期末作业，更能扎实地理解光栅图形学的基本原理和实现方法。记住，图形编程的核心乐趣在于“创造”和“控制”，看到自己写的代码生成预期的图案时，那种成就感是无与伦比的。从这些简单的图元开始，你已经踏入了计算机图形学奇妙世界的大门。