中点直线画圆算法

‘壹’ 计算机图形学复习

第一章
1. 计算机图形：用数学方法描述，通过计算机生成、处理、存储和显示的对象。
2. 图形和图像的主要区别是表示方法不同：图形是用矢量表示；图像是用点阵表示的。图形和图像也可以通过光栅显示器（或经过识别处理）可相互转化。
3. 于计算机图形学紧密相关的学科主要包括 图像处理、计算几何和计算机视觉模式识别。它们的共同点是 以图形/图像在计算机中的表示方法为基础。
4. 交互式计算机图形系统的发展可概括为以下4个阶段：字符、矢量、二维光栅图形、三维图形。
5. 图形学研究的主要内容有：①几何造型技术 ②图形生成技术 ③图形处理技术 ④图形信息的存储、检索与交换技术 ⑤人机交互技术 ⑥动画技术 ⑦图形输入输出技术 ⑧图形标准与图形软件包的研发。
6. 计算机辅助设计和计算机辅助制造 是计算机图形学最广泛最活跃的应用领域。
7. 计算机图形学的基本任务：一是如何利用计算机硬件来实现图形处理功能；二是如何利用好的图形软件；三是如何利用数学方法及算法解决实际应用中的图行处理问题。
8. 计算机图形系统是由硬件系统和软件系统组成的。
9. 计算机图形系统包括处理、存储、交互、输入和输出五种基本功能。
10. 键盘和鼠标是最常用的图形输入设备。鼠标根据测量位移部件的不同，分为光电式、光机式和机械式3种。
11. 数字化仪分为电子式、超声波式、磁伸缩式、电磁感应式等。小型的数字化仪也称为图形输入板。
12. 触摸屏是一种 定位设备，它是一种对于触摸能产生反应的屏幕。
13. 扫描仪由3部分组成：扫描头、控制电路和移动扫描机构。扫描头由光源发射和光鲜接收组成。按移动机构的不同，扫描仪可分为平板式和滚筒式2种。
14. 显示器是计算机的标准输出设备。彩色CRT的显示技术有2种：电子穿透法和荫罩法。
15. 随机扫描是指电子束的定位及偏转具有随意性，电子束根据需要可以在荧光屏任意方向上连续扫描，没有固定扫描线和扫描顺序限制。它具有局部修改性和动态性能。
16. 光栅扫描显示器是画点设备。
17. 点距是指相邻像素点间的距离，与分辨指标相关。
18. 等离子显示器一般有三层玻璃板组成，通常称为等离子显示器的三层结构。
19. 用以输出图形的计算机外部设备称为硬拷贝设备。
20. 打印机是廉价的硬拷贝设备，从机械动作上常为撞击式和非撞击式2种。
21. 常用的喷墨头有：压电式、气泡式、静电式、固体式。
22. 绘图仪分为静电绘图仪和笔式绘图仪。
23. 图形软件的分层。由下到上分别是：①图形设备指令、命令集、计算机操作系统 ②零级图形软件 ③一级图形软件 ④二级图形软件 ⑤三级图形软件。
24. 零级图形软件是面向系统的、最底层的软件，主要解决图形设备与主机的通信与接口问题，又称设备驱动程序。
25. 一级图形软件即面向系统又面向用户，又称基本子系统。
26. 图形应用软件是系统的核心部分。
27. 从物理学角度，颜色以主波长、色纯度和辉度来描述；从视觉角度来看，颜色以色彩、饱和度和亮度来描述。
28. 用适当比列的3种颜色混合，可以获得白色，而且这3种颜色中的任意2种的组合都不能生成第三种颜色，称为三原色理论。
29. RGB模型的匹配表达式是：c=rR+gG+bB。
30. 常用颜色模型
颜色模型名称 使用范围
RGB 图形显示设备（彩色CRT和光栅显示器）
CMY 图形打印、绘制设备
HSV 对应画家本色原理、直观的颜色描述
HSL 基于颜色参数的模型
用基色青、品红、黄定义的CMY颜色模型用来描述硬拷贝设备的输出颜色。它从白光中滤去某种颜色，故称为减色性原色系统。

第二章
31. 直线生成的3个常用算法：数值微分法（DDA）、中点划线法和Bresenham算法。
32. DDA算法的C语言实现：
DDA算法生成直线，起点（x0,y0）,终点（x1,y1）.
Void CMy View ::OnDdaline()
{
CDC *pDC=GetDC(); //获得设备指针
int x0=100,y0=100,x1=300,y1=200,c=RGB(250,0,0);//定义直线两端点和直线颜色
int x,y,i;
float dx,dy,k;
dx=(float)(x1-x0);
dy=(float)(y1-y0);
k=dy/dx;
x=x0;
y=y0;
if(abs(k)<1)
{ for(;x<=x1;x++)
{pDC—>SetPixel(x,int(y+0.5),c);
y=y+k;}
}
if(abs(k)>=1)
{ for(;y<=y1;y++)
{pDC—>SetPixel(int(x+0.5),y,c);
x=x+1/k;}
}
ReleaseDC(pDC); //释放设备指针
}
33. 任何影响图元显示方法的参数称为属性参数。图元的基本表现是线段，其基本属性包括线型、线宽和色彩。
34. 最常见的线型包括实线、虚线、细线和点划线等，通常默认的线型是实线。
35. 线宽控制的实线方法：垂直线刷子、水平线刷子、方形线刷子。生成具有宽度的线条还可以采用区域填充算法。
36. 用离散量表示连续量时引起的失真现象称为走样。为了提高图形显示质量，减少或消除走样现象的技术称为反走样。
37. 反走样技术有：提高分辨率（硬件方法和软件方法）、简单区域取样、加权区域取样。
38. 区域连通情况分为四连通区域和八连通区域。四连通区域是指从区域上某一点出发，可通过上下左右4个方向移动，在不越出区域的前提下到达区域内的任意像素；八连通区域是指从区域内某一像素出发，可通过上下左右、左上左下、右上右下8个方向的移动，在不越出区域的前提下到达区域内的任意像素。
39. 字符的图形表示可以分为点阵式和矢量式两种形式。
40. 在图形软件中，除了要求能生成直线、圆等基本图形元素外，还要求能生成其他曲线图元、多边形及符号等多种图元。
41. 在扫描线填充算法中，对水平边忽略而不予处理的原因是实际处理时不计其交点。
42. 关于直线生成算法的叙述中，正确的是：Bresenham算法是对中点画线算法的改进。
43. 在中点画圆算法中叙述错误的是：为了减轻画圆的工作量，中点画圆利用了圆的四对称性性质。
44. 多边形填充时，下列论述错误的是：在判断点是否在多边形内时，一般通过在多变形外找一点，然后根据该线段与多边形的交点数目为偶数即可认为在多边形内部，若为奇数则在多边形外部，且不考虑任何特殊情况。
第三章
1. Cohen-Sutherland算法，也称编码裁剪法。其基本思想是：对于每条待裁剪的线段P1P2分三种情况处理：①若P1P2完全在窗口内，则显示该线段，简称“取”之；②若P1P2完全在窗口外，则丢弃该线段，简称“舍”之；③若线段既不满足“取”的条件也不满足“舍”的条件，则求线段与窗口边界的交点，在交点处把线段分为两段，其中一段 完全在窗口外，可舍弃之，然后对另一段重复上述处理。
2. Sutherland-Hodgman算法，又称逐边裁剪算法。其基本思想是用窗口的四条边所在的直线依次来裁剪多边形。多边形的每条边与裁剪线的位置关系有4种情况（假设当前处理的多边形的边为SP）：a>端点S在外侧，P在内侧，则从外到内输出P和I；b>端点S和P都在内侧，则从内到内输出P；c>端点S在内侧，而P在外侧，则从内到外输出I；d>端点S和P都在外侧，无输出。
3. 按裁剪精度的不同，字符裁剪可分为三种情况：字符串裁剪、字符裁剪和笔画裁剪。
4. 在线段AB的编码裁剪算法中，如A、B两点的码逻辑或运算全为0，则该线段位于窗口内；如AB两点的码逻辑与运算结果不为0，则该线段在窗口外。
5. n边多边形关于矩形窗口进行裁剪，结果多边形最多有2n个顶点，最少有n个顶点。
6. 对一条等长的直线段裁剪，编码裁剪算法的速度和中点分割算法的裁剪速度哪一个快，无法确定。（√）
7. 多边形裁剪可以看做是线段裁剪的组合。（X）
8. 对于线段来说，中点分割算法要比其他线段裁剪算法的裁剪速度快。（X）
9. 多边形的Weiler-Atherton裁剪算法可以实现对任意多边形的裁剪。（√）
第四章
1. 几何变换是指改变几何形状和位置，非几何变换是指改变图形的颜色、线型等属性。变换方法有对象变换（坐标系不动）和坐标变换（坐标系变化）两种。
2. 坐标系可以分为以下几种：世界坐标系（是对计算机图形场景中所有图形对象的空间定位和定义，是其他坐标系的参照）、模型坐标系（用于设计物体的局部坐标系）、用户坐标系(为了方便交互绘图操作，可以变换角度、方向)、设备坐标系（是绘制或输出图形的设备所用的坐标系，采用左手系统）。
3. 将用户坐标系中需要进行观察和处理的一个坐标区域称为窗口，将窗口映射到显示设备上的坐标区域称为视区。从窗口到视区的变换，称为规格化变换。（eg.4-1）
4. 所谓体素，是指可以用有限个尺寸参数定位和定形的体，如长方体、圆锥体。
5. 所谓齐次坐标表示，就是用n+1维向量表示n维的向量。
6. 二维点（x,y）的齐次坐标可以表示为：（hx hy h）,其中h≠0。当h=1时称为规范化的齐次坐标，它能保证点集表示的唯一性。
7. 旋转变换公式的推导、对称变换

第五章
1. 交互绘图技术是一种处理用户输入图形数据的技术，是设计交互绘图系统的基础。常见的交互绘图技术有：定位技术、橡皮筋技术、拖曳技术、定值技术、拾取技术、网格与吸附技术。
2. 常用的橡皮筋技术有：橡皮筋直线、橡皮筋矩形、橡皮筋圆。
3. 拖曳技术是将形体在空间移动的过程动态地、连续地表示出来，直到用户满意。
4. 定值技术有2种：一种是键入数值，另一种是改变电位计阻值产生要求的数量，可以用模拟的方式实现电位计功能。
5. 拾取一个基本的对象可以通过：指定名称法、特征点发、外界矩阵法、分类法、直接法。

第六章
1. 点、线、面是形成三维图形的基础，三维变换是从点开始。
2. 三维图形变换分类：三维图形变换包括三维几何变换和平面几何变换，三维几何变换包括基本几何变换和复合变换；平面几何变换包括平行投影和透视投影，平行投影包括正投影和轴测投影，透视投影包括一点透视、二点透视、三点透视。
3. 投影中心与投影面之间的距离是无限的投影叫做平行投影，它包括正投影和轴测投影。
4. 正投影形成的视图包括：主视图、俯视图和左视图。轴测投影形成的视图为轴测图。
5. 透视投影也称为中心投影，其投影中心与投影面之间的距离是有限的。其特点是产生近大远小的视觉效果
6. 对于透视投影，不平行于投影面的平行线的投影会汇聚到一个点，这个点称为灭点。透视投影的灭点有无限多个，与坐标轴平行的平行线在投影面上形成的灭点称为主灭点。主灭点最多有3个，其对应的透视投影分别称为一点透视、二点透视、三点透视。

第七章
1. 型值点是曲面或曲线上的点，而控制点不一定在曲线曲面上，控制点的主要目的是用来控制曲线曲面的形状。
2. 插值和逼近是曲线曲面设计中的两种不同方法。插值—生成的曲线曲面经过每一个型值点，逼近—生成的曲线曲面靠近每一个控制点。
3. 曲线曲面的表示要求：唯一性、统一性、几何不变性、几何直观、易于界定、易于光滑连接。
4. 曲线曲面有参数和非参数表示，但参数表示较好。非参数表示又分为显式和隐式两种。
5. 对于一个平面曲线，显式表示的一般形式是：y=f(x)。一个x与一个y对应，因此显式方程不能表示封闭或多值曲线。例不能用显式方程表示一个圆。
6. 如果一个曲线方程表示为f(x,y)=0的形式，我们称之为隐式表示。其优点是易于判断函数f(x,y)是否大于、小于或等于零，即易于判断是落在所表示曲线上还是在曲线的哪一侧。
7. 参数连续与几何连续的区别：参数连续性是传统意义上的、严格的连续，而几何连续性只需限定两个曲线段在交点处的参数导数成比例，不必完全相等，是一种更直观、易于交互控制的连续性。
8. 在曲线曲面造型中，一般只用到C1（1阶参数连续）、C2（2阶参数连续）、G1（1阶几何连续）、G2（2阶几何连续）。切矢量（一阶导数）反映了曲线对参数t的变化速递，曲率（二阶导数）反映了曲线对参数t变化的加速度。
9. 通常C1连续必能保证G1的连续，但G1的连续并不能保证C1连续。
10. 对于三次Hermite曲线，用于描述曲线的可供选择的条件有：端点坐标、切矢量和曲率。
11. 三次Hermite曲线特点：①可局部调整，因为每个曲线段仅依赖于端点约束；②基于Hermite样条的变化形式有Cardinal样条和Kochanek-Bartels样条；③具有几何不变性。
12. Bezier曲线的性质：①端点性质②端点切矢量③端点的曲率④对称性⑤几何不变性⑥凸包性⑦变差缩减性。
13. 一次Bezier曲线是连接起点P0和终点P1的直线段，二次Bezier曲线对应一条起点P0终点在P2处的抛物线。
14. B样条曲线的性质：①局部性②连续性或可微性③几何不变性④严格凸包性⑤近似性⑥变差缩减性。
15. NURRS曲线具有以下性质：①局部性②可微性③仿射不变性④严格保凸性⑤一般性⑥变差缩减性⑦端点性质。

第八章
1. 要把三维物体的信息显示在二维显示设备中，必须通过投影变换。由于投影变换失去了深度信息，往往会导致二义性，要消除二义性，就必须在绘制时消除实际不可见的线和面，称作消除隐藏线和隐藏面，简称消隐。
2. 面消隐常用算法有：深度缓冲区（Z-buffer）算法和深度排序算法（画家算法）。
3. 深度缓冲区算法和深度排序算法的区别：

‘贰’ 计算机图形学 问题 中点圆算法和扫描线算法

写个文档解释一下。

‘叁’ 请问中点bresenham算法画圆与bresenham算法画圆有区别吗

Bresenham算法画圆：

Bresenham算法用来画直线非常方便，但上次也说了，Bresenham算法也可以用来显示圆和其他曲线，只需要把直线方程改成圆方程或者其他曲线的方程就行，具体的推理过程就不演示了，大体跟直线的差不多！但由推算的结果可以看出，用Bresenham算法来画圆的确是不大明智的做法，要计算的步骤太多，计算速度比专门的画圆方法慢很多！并且在斜率越大的地方像素的间距就越大，当然我们可以在画某个像素之前先判断一下这一点跟前面一点的连线的斜率，然后在适当的时候交换x、y的坐标，但这样计算量必将增加！

直接给出Bresenham画圆的代码：

#include<gl/glut.h>

#include<math.h>

#include<stdio.h>

voiddraw_pixel(intix,intiy)

{

glBegin(GL_POINTS);

glVertex2i(ix,iy);

glEnd();

}

//intinlineround(constfloata){returnint(a+0.5);}

voidBresenham(intx1,inty1,intr,doublea,doubleb,doublec)/*圆心在（x1，y1），半径为r的圆*/

{

glColor3f(a,b,c);

intdx=r;//intdy=abs(yEnd-y1);

//intp=2*dy-dx;

//inttwoDy=2*dy,twoDyMinusDx=2*dy-2*dx;

intx,y,d1,d2;

/*if(x1>xEnd)

{

x=xEnd;y=yEnd;

xEnd=x1;

}

else

{

x=x1;

y=y1;

}

*/

x=x1;

y=y1+r;

draw_pixel(x1,y1);

draw_pixel(x,y);//起始点装入帧缓存,起始点是圆的最上面一点，然后按顺时针来画

while(x<=x1+dx)

{

d1=y1+sqrt(pow(r,2)-pow(x-x1,2));/*lower*/

x++;

d2=2*(y1+sqrt(pow(r,2)-pow(x-x1,2)))-2*d1-1;/*lower-upper*/

if(1)

{

y=d1;

draw_pixel(x,y);

draw_pixel(x,2*y1-y);

draw_pixel(2*x1-x,y);

draw_pixel(2*x1-x,2*y1-y);

}

else

{

y++;

//p+=twoDyMinusDx;

draw_pixel(x,y);

}

}

}

voiddisplay()

{

glClear(GL_COLOR_BUFFER_BIT);

Bresenham(250,250,200,0.0,0.0,1.0);

Bresenham(300,250,150,1.0,0.0,0.0);

Bresenham(200,250,150,0.0,1.0,0.0);

//Bresenham(250,300,150,0.8,0.4,0.3);

//Bresenham(250,200,150);

glFlush();

}

voidmyinit()

{

glClearColor(0.8,1.0,1.0,1.0);

//glColor3f(0.0,0.0,1.0);

glPointSize(1.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(0.0,500.0,0.0,500.0);

}

voidmain(intargc,char**argv)

{

glutInit(&argc,argv);

glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);

glutInitWindowSize(500,500);

glutInitWindowPosition(200.0,200.0);

glutCreateWindow("CG_test_Bresenham_Circleexample");

glutDisplayFunc(display);

myinit();

glutMainLoop();

}

以下为程序运行效果：

中点画圆：

用光栅画圆的不足在上次已经用实例表示的很明白了，上次画的那个圆怎么都不能算满意，虽然可以通过修改算法来得到改善，但本来计算步骤就已经很多了，交换坐标重新计算将会大大增加计算机的就是负担，为此我们采用另一种更加常用的画圆算法——中点画圆算法，之所以叫做“中点”画圆算法是由于它不是像Bresenham算法那样所绘像素不是（xk+1,yk）就是（xk+1,yk+1）,而是根据这两个点的中点来判断是（xk+1,yk）还是（xk+1,yk-1）更接近于圆！

对于给定的半径r和圆心（x0,y0）,我们先计算圆心在原点（0,0）的点，然后将其平移到圆心（x0,y0）处即可，跟Bresenham算法一样，我们也可以借助圆的高度对称性来减少计算机的计算步骤，在这里我们可以先计算出八分之一圆的像素点，然后根据对称性绘出其他点。这样可以大大加快画圆的速度！

跟光栅化方法一样，我们还是采用步进的方法来逐点描绘，但这里的决策参数计算方式跟Bresenham不大一样，设决策参数为p，则：

P=x2+y2-r2

对于任一个点（x，y），可以根据p的符号来判断点是在圆内还是圆外还是在圆上，这里不多说，假设我们在（xk,yk）处绘制了一个像素，下一步需要确定的是（xk+1,yk）还是（xk+1,yk-1）更接近于圆，在此代入这两个点的中点来求出决策参数：

Pk=（xk+1）2+（yk-1/2）2-r2

如果Pk<0,则yk上的像素更接近于圆，否则就是yk-1更接近于圆

同理可以推出Pk+1=Pk+2（xk+1）+（yk+12-yk2）-（yk+1-yk）+1

给出一个示例，这个圆比用Bresenham画出来的好看多了：

#include<glglut.h>

classscreenPt

{

private:

intx,y;

public:

screenPt(){x=y=0;}

voidsetCoords(GLintxCoordValue,GLintyCoordValue)

{

x=xCoordValue;

y=yCoordValue;

}

GLintgetx()const

{

returnx;

}

GLintgety()const

{

returny;

}

voidincrementx(){x++;}

voiddecrementy(){y--;}

};

voiddraw_pixel(intxCoord,intyCoord)

{

glBegin(GL_POINTS);

glVertex2i(xCoord,yCoord);

glEnd();

}

voidcircleMidpoint(GLintxc,GLintyc,GLintradius)

{

screenPtcircPt;

GLintp=1-radius;

circPt.setCoords(0,radius);

voidcirclePlotPoints(GLint,GLint,screenPt);

circlePlotPoints(xc,yc,circPt);

while(circPt.getx()<circPt.gety())

{

circPt.incrementx();

if(p<0)

p+=2*circPt.getx()+1;

else

{

circPt.decrementy();

p+=2*(circPt.getx()-circPt.gety())+1;

}

circlePlotPoints(xc,yc,circPt);

}

}

voidcirclePlotPoints(GLintxc,GLintyc,screenPtcircPt)//描绘八分圆各点

{

draw_pixel(xc+circPt.getx(),yc+circPt.gety());

draw_pixel(xc-circPt.getx(),yc+circPt.gety());

draw_pixel(xc+circPt.getx(),yc-circPt.gety());

draw_pixel(xc-circPt.getx(),yc-circPt.gety());

draw_pixel(xc+circPt.gety(),yc+circPt.getx());

draw_pixel(xc-circPt.gety(),yc+circPt.getx());

draw_pixel(xc+circPt.gety(),yc-circPt.getx());

draw_pixel(xc-circPt.gety(),yc-circPt.getx());

}

voiddisplay()

{

//screenPtPt;

glClear(GL_COLOR_BUFFER_BIT);

circleMidpoint(250,250,200);

glFlush();

}

voidmyinit()

{

glClearColor(0.8,1.0,1.0,1.0);

glColor3f(0.0,0.0,1.0);

glPointSize(1.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(0.0,500.0,0.0,500.0);

}

voidmain(intargc,char**argv)

{

glutInit(&argc,argv);

glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);

glutInitWindowSize(500,500);

glutInitWindowPosition(200.0,200.0);

glutCreateWindow("CG_test_中点画圆example");

glutDisplayFunc(display);

myinit();

glutMainLoop();

}

运行效果：

‘肆’ 怎样用C语言画圆

#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char* argv[])
{
char arg[50]={0};
arg[0]= '\ " ';
strcpy(arg+1,argv[0]);
int len=int(strlen(arg));
arg[len]= '\ " ';

HWND hWnd=FindWindow(NULL,arg); //找到程序运行窗口的句柄
HDC hDC=GetDC(hWnd);//通过窗口句柄得到该窗口的设备场境句柄
HPEN hPen,hOldPen; //画笔
int i=0;

for(;i <500;++i)
SetPixel(hDC,10+i,10+i,0x0000ff);//用画点的办法画一根线,最后一个参数是颜色（32位）

hPen=CreatePen(PS_SOLID,2,0x00ff00);//生成绿色画笔
hOldPen=(HPEN)SelectObject(hDC,hPen);//把画笔引入设备场境

MoveToEx(hDC,20,50,NULL); //设置画线起点
LineTo(hDC,520,550); //画到终点

Arc(hDC,100,100,300,300,350,500,350,500);//画圆

SelectObject(hDC,hOldPen);
ReleaseDC(hWnd,hDC);

//下面是对比，表明它确实是控制台程序

printf( "hello console ");
system( "pause ");
return 0;

}

‘伍’ 直线和圆的显示（在线等答案）

实验2 圆与椭圆
给出圆心坐标(xc, yc)和半径r，逐点画出一个圆周的公式有下列两种。
一 直角坐标法
直角坐标系的圆的方程为

由上式导出：

当x-xc从-r到r做加1递增时，就可以求出对应的圆周点的y坐标。但是这样求出的圆周上的点是不均匀的，| x-xc | 越大，对应生成圆周点之间的圆周距离也就越长。因此，所生成的圆不美观。
二 中点画圆法
如图1所示，函数为F(x, y)=x2+y2-R2的构造圆，圆上的点为F(x, y)=0，圆外的点F(x, y)>0，圆内的点F(x, y)<0，构造判别式：
d=F(M)=F(xp+1, yp-0.5)=(xp+1)2+(yp-0.5)2
若d＜0，则应取P1为下一像素，而且下一像素的判别式为
d=F(xp+2, yp-0.5)= (xp+2)2+(yp-0.5)2-R2=d+2xp+3
若d≥0，则应取P2为下一像素，而且下一像素的判别式为
d=F(xp+2, yp-1.5)= (xp+2)2+(yp-1.5)2-R2=d+2(xp- yp)+5
我们讨论按顺时针方向生成第二个八分圆，则第一个像素是（0, R），判别式d的初始值为
d0=F(1, R-0.5)=1.25-R
三 圆的Bresenham算法
设圆的半径为r，先考虑圆心在(0, 0)，从x=0、y=r开始的顺时针方向的1/8圆周的生成过程。在这种情况下，x每步增加1，从x=0开始，到x=y结束，即有xi+1 = xi + 1；相应的，yi+1则在两种可能中选择：yi+1=yi或者yi+1 = yi - 1。选择的原则是考察精确值y是靠近yi还是靠近yi-1（见图2），计算式为
y2= r2-(xi+1)2
d1 = yi2-y2 = yi2-r2+(xi+1)2
d2 = y2- (yi - 1)2 = r2-(xi+1)2-(yi - 1)2
令pi=d1-d2，并代入d1、d2，则有
pi = 2(xi+1)2 + yi2+ (yi - 1)2 -2r2 （1.6）
pi称为误差。如果pi＜0，则yi+1=yi，否则yi+1=yi - 1。
pi的递归式为
pi+1 = pi + 4xi +6+2(yi2+1- yi2)-2(yi+1-yi) （1.7）
pi的初值由式(1.6)代入xi=0，yi=r，得
p1 = 3-2r （1.8）
根据上面的推导，圆周生成算法思想如下：
（1）求误差初值，p1=3-2r，i=1，画点(0, r)。
（2）求下一个光栅位置，其中xi+1=xi+1，如果pi＜0则yi+1=yi，否则yi+1=yi - 1。
（3）画点(xi+1, yi+1)。
（4）计算下一个误差，如果pi＜0则pi+1=pi+4xi+6，否则pi+1=pi+4(xi - yi)+10。
（5）i=i+1，如果x=y则结束，否则返回步骤（2）。
程序设计步骤如下。
（1）创建应用程序框架，以上面建立的单文档程序框架为基础。
（2）编辑菜单资源。
在工作区的ResourceView标签中，单击Menu项左边"+"，然后双击其子项IDR_MAINFRAME，并根据表1中的定义添加编辑菜单资源。此时建好的菜单如图3所示。
表1 菜单资源表
菜单标题 菜单项标题 标示符ID
圆 中点画圆 ID_MIDPOINTCIRCLE
Bresenham画圆 ID_BRESENHAMCIRCLE
（3）添加消息处理函数。
利用ClassWizard（建立类向导）为应用程序添加与菜单项相关的消息处理函数，ClassName栏中选择CMyView，根据表2建立如下的消息映射函数，ClassWizard会自动完成有关的函数声明。
表2 菜单项的消息处理函数
菜单项ID 消 息 消息处理函数
ID_MIDPOINTCIRCLE CONMMAN OnMidpointcircle
ID_BRESENHAMCIRCLE CONMMAN OnBresenhamcircle
（4）程序结构代码，在CMyView.cpp文件中的相应位置添加如下代码。

void CMyView::OnMidpointcircle() //中点算法绘制圆，如图4所示
{
// TODO: Add your command handler code here
CDC* pDC=GetDC();
int xc=300, yc=300, r=50, c=0;
int x,y;
float d;
x=0; y=r; d=1.25-r;
pDC->SetPixel ((xc+x),(yc+y),c);
pDC->SetPixel ((xc-x),(yc+y),c);
pDC->SetPixel ((xc+x),(yc-y),c);
pDC->SetPixel ((xc-x),(yc-y),c);
pDC->SetPixel ((xc+y),(yc+x),c);
pDC->SetPixel ((xc-y),(yc+x),c);
pDC->SetPixel ((xc+y),(yc-x),c);
pDC->SetPixel ((xc-y),(yc-x),c);
while(x<=y)
{ if(d<0) d+=2*x+3;
else { d+=2*(x-y)+5; y--;}
x++;
pDC->SetPixel ((xc+x),(yc+y),c);
pDC->SetPixel ((xc-x),(yc+y),c);
pDC->SetPixel ((xc+x),(yc-y),c);
pDC->SetPixel ((xc-x),(yc-y),c);
pDC->SetPixel ((xc+y),(yc+x),c);
pDC->SetPixel ((xc-y),(yc+x),c);
pDC->SetPixel ((xc+y),(yc-x),c);
pDC->SetPixel ((xc-y),(yc-x),c);
}
}
void CMyView::OnBresenhamcircle() //// Bresenham算法绘制圆，如图5所示
{
CDC* pDC=GetDC();
int xc=100, yc=100, radius=50, c=0;
int x=0,y=radius,p=3-2*radius;
while(x<y)
{
pDC->SetPixel(xc+x, yc+y, c);
pDC->SetPixel(xc-x, yc+y, c);
pDC->SetPixel(xc+x, yc-y, c);
pDC->SetPixel(xc-x, yc-y, c);
pDC->SetPixel(xc+y, yc+x, c);
pDC->SetPixel(xc-y, yc+x, c);
pDC->SetPixel(xc+y, yc-x, c);
pDC->SetPixel(xc-y, yc-x, c);
if (p<0)
p=p+4*x+6;
else
{
p=p+4*(x-y)+10;
y-=1;
}
x+=1;
}
if(x==y)
pDC->SetPixel(xc+x, yc+y, c);
pDC->SetPixel(xc-x, yc+y, c);
pDC->SetPixel(xc+x, yc-y, c);
pDC->SetPixel(xc-x, yc-y, c);
pDC->SetPixel(xc+y, yc+x, c);
pDC->SetPixel(xc-y, yc+x, c);
pDC->SetPixel(xc+y, yc-x, c);
pDC->SetPixel(xc-y, yc-x, c);
}

四 椭圆扫描转换中点算法
下面讨论椭圆的扫描转换中点算法，设椭圆为中心在坐标原点的标准椭圆，其方 程为
F(x, y)=b2x2+a2y2-a2b2=0
（1）对于椭圆上的点，有F(x, y)=0；
（2）对于椭圆外的点，F(x, y)>0；
（3）对于椭圆内的点，F(x, y)<0。
以弧上斜率为-1的点作为分界将第一象限椭圆弧分为上下两部分（如图6所示）。
法向量：

而在下一个点，不等号改变方向，则说明椭圆弧从上部分转入下部分。
与中点绘制圆算法类似，一个像素确定后，在下面两个候选像素点的中点计算一个判别式的值，再根据判别式符号确定离椭圆最近的点。先看椭圆弧的上半部分，具体算法如下：
假设横坐标为xp的像素中与椭圆最近点为（xp, yp），下一对候选像素的中点应为（xp+1，yp-0.5），判别式为

，表明中点在椭圆内，应取正右方像素点，判别式变为

若 ，表明中点在椭圆外，应取右下方像素点，判别式变为

判别式 的初始条件确定。椭圆弧起点为(0, b)，第一个中点为(1,b - 0.5)，对应判别式为

在扫描转换椭圆的上半部分时，在每步迭代中需要比较法向量的两个分量来确定核实从上部分转到下半部分。在下半部分算法有些不同，要从正上方和右下方两个像素中选择下一个像素。在从上半部分转到下半部分时，还需要对下半部分的中点判别式进行初始化。即若上半部分所选择的最后一个像素点为(xp, yp)，则下半部分中点判别式应在（xp+0.5, yp-1）的点上计算。其在正下方与右下方的增量计算同上半部分。具体算法的实现请参考下面的程序设计。
程序设计步骤如下。
（1）创建应用程序框架，以上面建立的单文档程序框架为基础。
（2）编辑菜单资源。
在工作区的ResourceView标签中，单击Menu项左边"+"，然后双击其子项IDR_MAINFRAME，并根据表3中的定义添加编辑菜单资源。此时建好的菜单如图7所示。
表3 菜单资源表
菜单标题 菜单项标题 标示符ID
椭圆 中点画椭圆 ID_MIDPOINTELLISPE

图7 程序主菜单
（3）添加消息处理函数。
利用ClassWizard（建立类向导）为应用程序添加与菜单项相关的消息处理函数，ClassName栏中选择CMyView，根据表4建立如下的消息映射函数，ClassWizard会自动完成有关的函数声明。
表4 菜单项的消息处理函数
菜单项ID 消 息 消息处理函数
ID_MIDPOINTELLISPE CONMMAN OnMidpointellispe
（4）程序结构代码如下：

void CMyView:: OnMidpointellispe () //中点算法绘制椭圆，如图8所示
{
CDC* pDC=GetDC();
int a=200,b=100,xc=300,yc=200,c=0;
int x,y;
double d1,d2;
x=0;y=b;
d1=b*b+a*a*(-b+0.25);
pDC->SetPixel(x+300,y+200,c);
pDC->SetPixel(-x+300,y+200,c);
pDC->SetPixel(x+300,-y+200,c);
pDC->SetPixel(-x+300,-y+200,c);
while(b*b*(x+1)<a*a*(y-0.5))
{
if(d1<0){
d1+=b*b*(2*x+3);
x++;}
else
{d1+=b*b*(2*x+3)+a*a*(-2*y+2);
x++;y--;
}
pDC->SetPixel(x+xc,y+yc,c);
pDC->SetPixel(-x+xc,y+yc,c);
pDC->SetPixel(x+xc,-y+yc,c);
pDC->SetPixel(-x+xc,-y+yc,c);
}
d2=sqrt(b*(x+0.5))+a*(y-1)-a*b;
while(y>0)
{
if(d2<0){
d2+=b*b*(2*x+2)+a*a*(-2*y+3);
x++;y--;}
else
{d2+=a*a*(-2*y+3);
y--;}
pDC->SetPixel(x+xc,y+yc,c);
pDC->SetPixel(-x+xc,y+yc,c);
pDC->SetPixel(x+xc,-y+yc,c);
pDC->SetPixel(-x+xc,-y+yc,c);
}
}

实验一: 直 线
数学上，理想的直线是由无数个点构成的集合，没有宽度。计算机绘制直线是在显示器所给定的有限个像素组成的矩阵中，确定最佳逼近该直线的一组像素，并且按扫描线顺序，对这些像素进行写操作，实现显示器绘制直线，即通常所说的直线的扫描转换，或称直线光栅化。
由于一图形中可能包含成千上万条直线，所以要求绘制直线的算法应尽可能地快。本节介绍一个像素宽直线的常用算法：数值微分法（DDA）、中点画线法、Bresenham 算法。
一. DDA（数值微分）算法
DDA算法原理：如图1-1所示，已知过端点 的直线段 ；直线斜率为 ，从 的左端点 开始，向 右端点步进画线，步长=1（个像素），计算相应的 坐标 ；取像素点 [ , round（y）] 作为当前点的坐标。计算 ，当 ，即当x每递增1，y递增k（即直线斜率）。
注意：上述分析的算法仅适用于k1的情形。在这种情况下，x每增加1, y最多增加1。当 时，必须把x，y地位互换，y每增加1，x相应增加1/k（请参阅后面的Visual C++程序）。
二. 生成直线的中点画线法
中点画线法的基本原理如图1-2所示。在画直线段的过程中，当前像素点为P，下一个像素点有两种选择，点P1或P2。M为P1与P2中点，Q为理想直线与X=Xp+1垂线的交点。当M在Q的下方时，则P2应为下一个像素点；当M在Q的上方时，应取P1为下一点。
中点画线法的实现：令直线段为L[ p0(x0,y0), p1(x1, y1)]，其方程式F(x, y)=ax+by+c=0。
其中，a=y0–y1, b=x1–x0, c=x0y1–x1y0；点与L的关系如下。
在直线上，F(x, y)=0；
在直线上方，F(x, y)>0；
在直线下方，F(x, y)<0。
把M代入F（x, y），判断F的符号，可知Q点在中点M的上方还是下方。为此构造判别式d=F(M)=F(xp+1, yp+0.5)=a(xp+1)+b(yp+0.5)+c。
当d < 0，L(Q点)在M上方，取P2为下一个像素。
当d > 0，L(Q点)在M下方，取P1为下一个像素。
当d=0，选P1或P2均可，取P1为下一个像素。
其中d是xp, yp的线性函数。
三. Bresenham算法
Bresenham算法是计算机图形学领域使用最广泛的直线扫描转换算法。由误差项符号决定下一个像素取右边点还是右上方点。
设直线从起点(x1, y1)到终点(x2, y2)。直线可表示为方程y = mx+b，其中b=y1–mx1， m = (y2–y1)/(x2–x1)=dy/dx；此处的讨论直线方向限于第一象限，如图1-3所示，当直线光栅化时，x每次都增加1个单元，设x像素为(xi，yi)。下一个像素的列坐标为xi+1，行坐标为yi或者递增1为yi+1，由y与yi及yi+1的距离d1及d2的大小而定。计算公式为
y = m(xi + 1) + b （1.1）
d1 = y – yi （1.2）
d2=yi+1–y （1.3）
如果d1–d2>0，则yi+1=yi+1，否则yi+1=yi。
式（1.1）、（1.2）、（1.3）代入d1–d2，再用dx乘等式两边，并以Pi=(d1–d2)，dx代入上述等式，得
Pi = 2xidy–2yidx+2dy+(2b–1)dx （1.4）
d1–d2是用以判断符号的误差。由于在第一象限，dx总大于0，所以Pi仍旧可以用做判断符号的误差。Pi+1为
Pi+1 = Pi+2dy–2(yi+1–yi)dx （1.5）
求误差的初值P1，可将x1、y1和b代入式（1.4）中的xi、yi，而得到
P1 = 2dy–dx
综述上面的推导，第一象限内的直线Bresenham算法思想如下：
（1）画点（x1, y1），dx=x2–x1，dy=y2–y1，计算误差初值P1=2dy–dx，i=1。
（2）求直线的下一点位置xi+1 = xi + 1，如果Pi>0，则yi+1=yi+1，否则yi+1=yi。
（3）画点(xi+1, yi+1)。
（4）求下一个误差Pi+1，如果Pi>0，则Pi+1=Pi+2dy–2dx，否则Pi+1=Pi+2dy。
（5）i=i+1；如果i<dx+1则转步骤（2）；否则结束操作。
四. 程序设计
1 程序设计功能说明
为编程实现上述算法，本程序利用最基本的绘制元素（如点、直线等），绘制图形。如图1-4所示，为程序运行主界面，通过选择菜单及下拉菜单的各功能项分别完成各种对应算法的图形绘制。

图1-4 基本图形生成的程序运行界面
2 创建工程名称为“基本图形的生成”单文档应用程序框架
（1）启动VC，选择“文件”|“新建”菜单命令，并在弹出的新建对话框中单击“工程”标签。
（2）选择MFC AppWizard(exe)，在“工程名称”编辑框中输入 “基本图形的生成”作为工程名称，单击“确定”按钮，出现Step 1对话框。
（3）选择“单个文档”选项，单击“下一个”按钮，出现Step 2对话框。
（4）接受默认选项，单击“下一个”按钮，在出现的Step 3～Step 5对话框中，接受默认选项，单击“下一个”按钮。
（5）在Step 6对话框中单击“完成”按钮，即完成“基本图形的生成”应用程序的所有选项，随后出现工程信息对话框（记录以上步骤各选项选择情况），如图1-5所示，单击“确定”按钮，完成应用程序框架的创建。

图1-5 信息程序基本
3 编辑菜单资源
设计如图1-4所示的菜单项。在工作区的ResourceView标签中，单击Menu项左边“+”，然后双击其子项IDR_MAINFRAME，并根据表1-1中的定义编辑菜单资源。此时VC已自动建好程序框架，如图1-5所示。
表1-1 菜单资源表
菜单标题 菜单项标题 标示符ID
直线 DDA算法生成直线 ID_DDALINE
Bresenham算法生成直线 ID_BRESENHAMLINE
中点算法生成直线 ID_MIDPOINTLINE
4 添加消息处理函数
利用ClassWizard（建立类向导）为应用程序添加与菜单项相关的消息处理函数，ClassName栏中选择CMyView，根据表1-2建立如下的消息映射函数，ClassWizard会自动完成有关的函数声明。
表1-2 菜单项的消息处理函数
菜单项ID 消 息 消息处理函数
ID_DDALINE CONMMAN OnDdaline
ID_MIDPOINTLINE CONMMAN OnMidpointline
ID_BRESENHAMLINE CONMMAN OnBresenhamline
5 程序结构代码，在CMyView.cpp文件中相应位置添加如下代码：
// DDA算法生成直线
void CMyView:: OnDdaline()
{
CDC* pDC=GetDC();//获得设备指针
int xa=100,ya=300,xb=300,yb=200,c=RGB(255,0,0);//定义直线的两端点，直线颜色
int x,y;
float dx, dy, k;
dx=(float)(xb-xa), dy=(float)(yb-ya);
k=dy/dx, y=ya;
if(abs(k)<1)
{
for (x=xa;x<=xb;x++)
{pDC->SetPixel (x,int(y+0.5),c);
y=y+k;}
}
if(abs(k)>=1)
{
for (y=ya;y<=yb;y++)
{pDC->SetPixel (int(x+0.5),y,c);
x=x+1/k;}
}
ReleaseDC(pDC);
}

说明：
（1）以上代码理论上通过定义直线的两端点，可得到任意端点之间的一直线，但由于一般屏幕坐标采用右手系坐标，屏幕上只有正的x, y值，屏幕坐标与窗口坐标之间转换知识请参考第3章。
（2）注意上述程序考虑到当k1的情形x每增加1，y最多增加1；当k>1时，y每增加1，x相应增加1/k。在这个算法中，y与k用浮点数表示，而且每一步都要对y进行四舍五入后取整。

//中点算法生成直线
void CMyView::OnMidpointline()
{
CDC* pDC=GetDC();
int xa=300, ya=200, xb=450, yb=300,c=RGB(0,255,0);
int a, b, d1, d2, d, x, y;
a=ya-yb, b=xb-xa, d=2*a+b;
d1=2*a, d2=2* (a+b);
x=xa, y=ya;
pDC->SetPixel(x, y, c);
while (x<xb)
{ if (d<0) {x++, y++, d+=d2; }
else {x++, d+=d1;}
pDC->SetPixel(x, y, c);
}
ReleaseDC(pDC);
}

说明：
（1）其中d是xp, yp的线性函数。为了提高运算效率，程序中采用增量计算。具体算法如下：若当前像素处于d>0情况，则取正右方像素P1(xp+1, yp)，判断下一个像素点的位置，应计算d1=F(xp+2, yp+0.5)=a(xp+2)+b(yp+0.5)=d+a；，其中增量为a。若d<0时，则取右上方像素P2（xp+1, yp+1）。再判断下一像素，则要计算d2 = F(xp+2, yp+1.5)=a(xp+2)+b(yp+1.5) + c=d+a+b，增量为a+b。
（2） 画线从(x0, y0)开始，d的初值d0=F(x0+1, y0+0.5)=F(x0, y0)+a+0.5b，因F(x0, y0)=0，则d0=a+0.5b。
（3）程序中只利用d的符号，d的增量都是整数，只是初始值包含小数，用2d代替d，使程序中仅包含整数的运算。

//Bresenham算法生成直线
void CMyView::OnBresenhamline()
{
CDC* pDC=GetDC();
int x1=100, y1=200, x2=350, y2=100,c=RGB(0,0,255);
int i,s1,s2,interchange;
float x,y,deltax,deltay,f,temp;
x=x1;
y=y1;
deltax=abs(x2-x1);
deltay=abs(y2-y1);
if(x2-x1>=0) s1=1; else s1=-1;
if(y2-y1>=0) s2=1; else s2=-1;
if(deltay>deltax){
temp=deltax;
deltax=deltay;
deltay=temp;
interchange=1;
}
else interchange=0;
f=2*deltay-deltax;
pDC->SetPixel(x,y,c);
for(i=1;i<=deltax;i++){
if(f>=0){
if(interchange==1) x+=s1;
else y+=s2;
pDC->SetPixel(x,y,c);
f=f-2*deltax;
}
else{
if(interchange==1) y+=s2;
else x+=s1;
f=f+2*deltay;
}
}
}

说明：
（1）以上程序已经考虑到所有象限直线的生成。
（2）Bresenham算法的优点如下：
① 不必计算直线的斜率，因此不做除法。
② 不用浮点数，只用整数。
③ 只做整数加减运算和乘2运算，而乘2运算可以用移位操作实现。
④ Bresenham算法的运算速度很快。

‘陆’ 画圆的常见算法

画圆的基本算法有逐点比较和DDA积分法，
代码示例 WinC下运行

#include "Conio.h"
#include "graphics.h"
#include "process.h"
#define Ni_circle 0
#define Shun_circle 1
#define closegr closegraph

void initgr();
void draw_Base_circle();
void draw_cabu_circle();
void close_graph();
void acrroods();
static float x0,y0;

void initgr(void) /* BGI初始化 */
{
int gd = DETECT, gm = 0; /* 和gd = VGA,gm = VGAHI是同样效果 */
registerbgidriver(EGAVGA_driver);/* 注册BGI驱动后可以不需要.BGI文件的支持运行 */
initgraph(&gd, &gm, "");
}

void acrroods() /*屏幕中心坐标 */
{
x0=getmaxx()/2;
y0=getmaxy()/2;
}

void draw_Base_circle() /*画圆及写参数*/
{
line(x0-200,y0,x0+200,y0); outtextxy(x0+220,y0,"Z");
line(x0,y0-180,x0,y0+180); outtextxy(x0+10,y0+180,"X");
outtextxy(x0-10,y0+10,"O");
circle(x0,y0,150);
textcolor(YELLOW);
directvideo=0;
gotoxy(46,2);cprintf("Circle start:X0 Y0 Z150");
gotoxy(46,3);cprintf("Circle end :X0 Y0 Z150");
gotoxy(46,4);cprintf("Units :Pixel");
gotoxy(46,5);cprintf("Circle now:");
}

void close_graph() /*关图形系统*/
{
closegraph();
}

void draw_cabu_circle(int sstep,int Directory)/*关键的圆插补函数*/
{
int flag=0;
float Fm,Xm,Ym;
Xm=x0+150; Ym=y0;
moveto(Xm,Ym);
setcolor(RED);
while(1) /*分象限，顺圆和逆圆讨论*/
{
Fm=(Xm-x0)/(Xm-x0)+(Ym-y0)/(Ym-y0)-150/150;/*圆判断公式*/
if(Fm>=0){
if(!Directory){ /*逆圆判断*/
if(Xm>=x0&&Ym<=y0)
{
if(flag) break; /*if语句判断象限，以下一样*/
else Xm=Xm-sstep;
}
if(Xm<=x0&&Ym<=y0)
{
flag=1; Ym=Ym+sstep;
}
if(Xm<=x0&&Ym>=y0)
Xm=Xm+sstep;
if(Xm>=x0&&Ym>=y0)
Ym=Ym-sstep;
}
else { /*it is Directory's else*/
if(Xm>x0&&Ym<y0)
Ym=Ym+sstep;
if(Xm<=x0&&Ym<=y0)
Xm=Xm+sstep;
if(Xm<x0&&Ym>y0) {
flag=1; Ym=Ym-sstep;}
if(Xm>=x0&&Ym>=y0) {
if(flag) break;
Xm=Xm-sstep;}
}
}
else{ /*it is Fm's else*/
if(!Directory) {
if(Xm>x0&&Ym<y0)
{
if(flag) break;
else Ym=Ym-sstep;
}
if(Xm<=x0&&Ym<=y0)
{
flag=1; Xm=Xm-sstep;
}
if(Xm<=x0&&Ym>=y0)
Ym=Ym+sstep;
if(Xm>=x0&&Ym>=y0)
Xm=Xm+sstep;
}
else{
if(Xm>x0&&Ym<y0)
Xm=Xm+sstep;
if(Xm<=x0&&Ym<=y0)
Ym=Ym-sstep;
if(Xm<=x0&&Ym>=y0){
flag=1; Xm=Xm-sstep;}
if(Xm>=x0&&Ym>=y0) {
if(flag) break;
else Ym=Ym+sstep;}
}
}
lineto(Xm,Ym);
gotoxy(58,5); printf("X%3.0f Y0 Z%3.0f ",Ym-y0,Xm-x0);
delay(800);
}
}

void circle_demo(int Directory) /*控制圆插补两次*/
{
int i=0,sstep;
initgr(); /* BGI初始化 */
sleep(2);
acrroods(&x0,&y0);
for(i=0;i<2;i++)
{
draw_Base_circle(150);
if(i==0){
sstep=6;
draw_cabu_circle(sstep,Directory);}
else{
sstep=1;
draw_cabu_circle(sstep,Directory);}
getch();
cleardevice();
setcolor(WHITE);
}
}

/* 圆插补部分的函数区结束*/

int main(void)
{
int choice=0;
initgr(); /* BGI初始化 */

while(choice!=4)
{
setfillstyle(1,RED);
bar(200,30,400,80);
setcolor(GREEN);
settextstyle(3,0,10);
outtextxy(220,50,"DEMO PROGRAM BY P.Y.F");
setcolor(WHITE);
settextstyle(0,0,1);
outtextxy(200,140,"2. Shun_Circle demo.");
outtextxy(200,160,"3. Ni_Circle demo.");
outtextxy(200,180,"4. Quit the program.");
outtextxy(160,200,"Please enter your choice:"); gotoxy(46,13);
scanf("%d",&choice);

switch(choice)
{
case 2: circle_demo(Ni_circle);break;
case 3: circle_demo(Shun_circle);break;
case 4: break;
default: printf("\nChoice wrong,try again!");
}
}

getch(); /* 暂停一下，看看前面绘图代码的运行结果 */
closegr(); /* 恢复TEXT屏幕模式 */
return 0;
}

具体看看《计算机图形学》。

‘柒’ CAD怎么在一条直线中间加个圆 说的简明些

对象捕捉选项里把中点勾上
然后以直线的中间为圆心,画一个圆

‘捌’ 图形学中的中点画线法与Bresenham算法画线的区别

个人认为最关键的区别就是那个决策参数的计算方式！
在Bresenham算法中，假设我们在（x0，y0）处画了一个点，那我们就要决定下一个点是在（x0+1，y0）还是在（x0+1，y0+1）处画，这两个点一般都不在直线上，我们要计算这两个点离直线有多远，分别设两个点离直线的距离为p1、p2，然后决策参数就是p=p2-p1，再根据p的符号来判断选择哪个点
至于中点法，我没有用它来画过直线，只用来画过圆（自我感觉画圆用这个算法比Bresenham算法要好很多），但原理应该差不多！
在中点算法中，决策参数的就是方式就是圆的方程（换成直线就是直线的方程了），比如要画x^2+y^2=r^2的圆，那决策参数p=x^2+y^2-r^2,然后就不是代入上面找到的两个点直接代进去，而是代这两个点的中点进去，求出p的值，根据p的符号来判断那个中点是在圆上、圆内还是圆外，再进一步决定选择绘哪个点！
具体的计算过程没办法在这里完整演示，但个人认为不同之处还是在于决策参数的选择与计算

‘玖’ lisp,一直线中点绘制一个圆，怎么实现的

(defunc:ttt(/#os1baqdzdjl1jdzxdr1r2)
(setvar"cmdecho"0)
(setvar"blipmode"0)
(setq#os1(getvar"osmode"));;取得捕捉设置
(if(nullvlax-mp-object)(vl-load-com));;加载vlax扩展函数
(setqb(entsel"
请选择直线"))
(if(/=bnil);;如果有选择;如果没有选择就结束
(progn;;继续分析
(setqb(entget(carb)));;取得属性列表
(setqa(cdr(assoc0b)));;取得图元名
(if(=a"LINE");;如果是直线;如果不是直线就结束
(progn;;继续分析
(setqqd(cdr(assoc10b)));;取得起点;要加cdr才可以得到点
(setqzd(cdr(assoc11b)));;取得端点
(setqjl1(distanceqdzd));;取得长度
(setqjl1(/jl12));;取得长度一半;如果后面用不到这个jl1可以使用jl1
(setqjd(angleqdzd));;取得角度
(setqzxd(polarqdjdjl1));;取得中点
(setqr1100);;设置半径默认为100
(setqr2(getint(strcat"
请输入半径:<"(rtosr120)">")));;输入半径
(if(=r2nil)(setqr2r1));;如果没有输入就默认
(setvar"osmode"0);;关闭捕捉;如不关闭可能绘图不正确
(command"circle"zxdr2);;绘制圆
(setvar"osmode"#os1);;还原捕捉设置
)
)
)
)
(princ)
)

你仔细核对有那里不同

(defunc:ttt(/#os1bqdzdjd)
(setvar"cmdecho"0)
(setvar"blipmode"0)
(setq#os1(getvar"osmode"));;取得捕捉设置
(if(nullvlax-mp-object)(vl-load-com));;加载vlax扩展函数
(setqb(entsel"
请选择直线"))
(if(/=bnil);;如果有选择
(progn;;继续分析
(setqb(entget(carb)));;取得属性列表
(setqqd(cdr(assoc0b)));;取得图元名
(if(=qd"LINE");;如果是直线
(progn;;继续分析
(setqqd(cdr(assoc10b)));;取得起点
(setqzd(cdr(assoc11b)));;取得端点
(setqjd(angleqdzd));;取得角度
(setqzd(distanceqdzd));;取得长度
(setqzd(/zd2));;取得长度一半;如果后面用不到这个zd可以使用zd
(setqzd(polarqdjdzd));;取得中点
(setqqd100);;设置为100
(setqjd(getint(strcat"
请输入半径:<"(rtosqd20)">")))
(if(=jdnil)(setqjdqd));;如果没有输入就默认
(setvar"osmode"0);;关闭捕捉;如不关闭可能绘图不正确
(command"circle"zdjd)
(setvar"osmode"#os1)
)
)
)
)
(princ)
);;这个程序减少了很多参数因为后面的不使用了所有可以重复使用