bresenham椭圆算法

① 请问中点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();

}

运行效果：

② 画圆为什么要用Bresenham算法

算法引入的本意是解决像素填充的问题的
点和线这种东西在理论上都是没有宽度的，但是要在屏幕上绘制的时候就要去填充像素以形成痕迹
一行上经常有2个以上的像素都被线所贯穿， 如何填充是个问题

而且像素填充本身是使用非常频繁的需求，故而画线的算法效率是非常重要的，对整个系统影响巨大

Bresenham算法是通过增量计算的方式快速判别下一个行或者列上的要填充的像素的位置，从计算上来说非常的节省，几乎都是整数的算法，速度非常的快

③ 关于椭圆中点Bresenham算法，请教高手，急用！分暂时不够，够了之后一定补上，谢谢各位了！

Bresenham算法;
多边形迫近法—圆与椭圆
...
推导出圆弧的增量算法的表达式:
缺点：所产生的圆是不封闭的，且该圆的半径有不断增大的趋势。

④ bresenham算法的算法

void IntegerBresenhamlin(int x0,int y0,int x1,int y1,int color)
{
int x,y,dx,dy,unitx,unity,fabs_dx,fabs_dy,e;
unsigned char i;
dx=x1-x0;
dy=y1-y0;
fabs_dx = (int)fabs(dx);
fabs_dy = (int)fabs(dy);
unitx = dx / fabs_dx ;
unity = dy / fabs_dy ;
x=x0;
y=y0;
if( fabs_dx> fabs_dy )
{
e=-fabs_dx;
for(i=0;i<=fabs_dx;i++)
{
drawpixel(x,y,color);
x+=unitx,e=e+2*fabs_dy;
if(e>=0)
{
y+=unity;e=e-2*fabs_dx;
}
} // for end
}
else
{
e-=fabs_dy;
for(i=0;i<=fabs_dy;i++)
{
drawpixel(x,y,color);
y+=unity,e=e+2*fabs_dx;
if(e>=0)
{
x+=unitx;e=e-2*fabs_dy;
}
} // for end
}// if end
} //:~

⑤ 会用C语言画图的(圆)Bresenham算法的高手帮忙看下！

//包含头文件这个不用我说了吧
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<graphics.h>
//交换a,b的值函数
void Swap(int *a,int *b);
//Bresenhen画园函数,圆心坐标(centerx,centery)半径radius线条颜色color
void BresenhemCircle(int centerx, int centery, int radius, int color, int type);
void initgr(void) /* BGI初始化 */
{
int gd = DETECT, gm = 0; /* 和gd = VGA,gm = VGAHI是同样效果 */
registerbgidriver(EGAVGA_driver);/* 注册BGI驱动后可以不需要.BGI文件的支持运行 */
initgraph(&gd, &gm, "");//初始化图形,必须写的
setbkcolor(WHITE);//设置背景颜色
}

int main(void)
{
int centerx,centery,radius,color,type;//变量定义总该知道的吧
printf("centerx,centery\n");//输出提示信息，这个总该知道的吧
scanf("%d",¢erx);//输入中心坐标横坐标
scanf("%d",¢ery);//
printf("radius\n");
scanf("%d",&radius);
printf("color,type\n");
scanf("%d",&color);
scanf("%d",&type);
initgr(); /*BGI初始化 */
BresenhemCircle(centerx,centery,radius,color,type);//重点理解这个函数
/*setcolor(RED);
circle(centerx, centery,radius);*/
/*Swap(&xs,&xe);
printf("%d,%d",xs,xe); */
getch();
closegraph();
}

void BresenhemCircle(int centerx, int centery, int radius, int color, int type)
{
int x =type= 0;//这些赋值语句应该能够看懂的吧
int y = radius;
int delta = 2*(1-radius);
int direction;
while (y >= 0) {//循环，如果y>=0就继续执行{}里面的语句
if (!type) { //!type表示如果type=0就执行{}里面的语句
putpixel(centerx+x, centery+y, color);
//前面两个参数是坐标，后面一个是颜色值，在(centerx+x, centery+y)画一个点
putpixel(centerx-x, centery+y, color);
putpixel(centerx-x, centery-y, color);
putpixel(centerx+x, centery-y, color);
}
else {//如果type=1就执行下面的
line(centerx+x, centery+y, centerx+x, centery-y);
line(centerx-x, centery+y, centerx-x, centery-y);
}
if (delta < 0) {//这个类似上面的，只不过这个嵌套了一层if-else if-else
if ((2*(delta+y)-1) < 0) {
direction = 1;
}
else {
direction = 2;
}
}
else if(delta > 0) {
if ((2*(delta-x)-1) <= 0) {
direction = 2;
}
else {
direction = 3;
}
}
else {
direction=2;
}

switch(direction) {//选择如果direction=1执行case 1:到case 2:直接的语句，如果没有break那么case 2:下面的语句也会被执行
case 1:
x++;
delta += (2*x+1);
break;
case 2:
x++;
y--;
delta += 2*(x-y+1);
break;
case 3:
y--;
delta += (-2*y+1);
break;
}

}
}

⑥ C语言用Bresenham算法画圆，哪位高手教教，主要是算法里的内容，谢谢！

的确哈，关键在于对delta的理解
可以看到，都是delta=2*(1-radius)这样的，起作用应该是判断要画的点x、y坐标的变化趋势，先把我注释了的代码贴下，加了getch();可以看到画的过程
-----------------------------------------------------------------
#include<graphics.h>
#include<stdio.h>

void BresenhemCircle(int centerx, int centery, int radius, int color, int type);

void main()
{
int drive=DETECT,mode;
int i,j;
initgraph(&drive,&mode,"");
BresenhemCircle(300,200,100,15,0);
getch();
}

void BresenhemCircle(int centerx, int centery, int radius, int color, int type)
{
int x =type = 0;/*初始横坐标为原点*/
int y = radius; /*初始纵坐标远离原点*/
int delta = 2*(1-radius);
int direction;
while (y >= 0)
{
getch();
if (!type)/*执行*/
{
/*在上半圆画两点*/
putpixel(centerx+x, centery+y, color);
putpixel(centerx-x, centery+y, color);
/*在下半圆画两点*/
putpixel(centerx-x, centery-y, color);
putpixel(centerx+x, centery-y, color);
getch();
}
else/*不执行*/
{
line(centerx+x, centery+y, centerx+x, centery-y);
line(centerx-x, centery+y, centerx-x, centery-y);
getch();
}
/*以下代码设置下次四点的位置，圆是对称的，且此方法相当于同时画四个圆弧
观察右上方圆弧可知，前一半是x增的要快些，后一半是y减的快些*/
if (delta < 0)
{
if ((2*(delta+y)-1) < 0)
direction = 1; /*选择横向加*/
else
direction = 2;
}
else if(delta > 0)
{
if ((2*(delta-x)-1) > 0)
direction = 3; /*选择纵向减*/
else
direction = 2;
}
else
direction=2;

switch(direction)
{
case 1:
x++;/*只横坐标远离原点*/
delta += (2*x+1); /*小执行到这，所以加*/
break;
case 2:
x++;
y--;/*横向远离，同时纵向靠近*/
delta += 2*(x-y+1); /*即(2*x+1)+(-2*y+1)*/
break;
case 3:
y--;/*只纵坐标靠近原点*/
delta += (-2*y+1); /*大执行到这，所以减*/
break;
}
}
}

⑦ 求大神解答 圆弧的Bresenham点生成算法，通常把圆分成__________个部分

圆弧的
Bresenham
点生成算法，
通常把圆分成
ˍ
8
ˍ
个部分，
如果
f
i
=(x
i
+1)
2
+y
i
2
-R
2
，
g
i
=(x
i
+1)
2
+(y
i
-1)

2
-R
2
，
e=
∣
f
i
∣
-
∣
g
i
∣，当点（
X
i
，
Y
i
）的
e
i
≥
0

则下一点为
D
，其坐标为（
X
i
+1
，
ˍ
yi-1
ˍ
），
若
e
i
＜
0

则
下一点为
H
，其坐标为
(X
i
+1
，
ˍ
yi

ˍ
)
。

⑧ c语言问题

一、 算法设计及流程

1. 点

不管什么样的图形归根结底到屏幕，都是由一些颜色不一的象素点组成，为提高图形的显示效率，没有用到系统的画点函数，而采用了640*480*16模式下的直接写屏技术画点，该模式下的直接写屏比320*200*256的直接写屏要复杂的多，后者的视频缓冲区是线性编址的，一个字节对应屏幕上一点的颜色，而前者的视频缓冲区被分成四个位面，屏幕上一点的颜色由每个位面上的一位组成的四位二进制数决定，由于四位二进制数的最大表示范围是16，所以在这种模式下最多可同时显示16种颜色。

在对视频缓冲区的读写时，是一个字节一个字节写的，只需要其中某一位时，就要用到位掩码屏蔽掉其他的位，位掩码就在图形控制寄存器的位屏蔽寄存器里设置。先通过向端口号为0x3ce的索引寄存器写入位屏蔽寄存器的索引号8，然后向端口号为0x3cf的寄存器写入位掩码值。设置好位掩码后，直接向视频缓冲区相应位置写入颜色即为画点函数。

取屏幕上一点颜色其实也就是画点的反操作，画点是将一个四位的二进制颜色值分配到四个位面，而取一点的颜色是将四个位面的颜色组合成一个四位二进制数。

2. 线

线其实就是由点组成的，通过连续的改变点的坐标，也就可以得到一条线。所以画线的函数归根结底也就是如何改变画点的坐标。

画线通常有DDA算法，BRESENHAM算法，这里采用的是BRESENHAM算法。这种算法从根本上讲，是通过横线与竖线的倍数关系来实现的。每次循环画点后x、y中位移大的坐标变化一个单位，而当循环次数是两者倍数关系时，x、y中位移小的坐标变化一个单位。为了使画线函数能在八个方向都能画，将增量为负的都转化正的增量。

画图程序经常要用到moveto、lineto等函数，用于把点移动到某点或从当前点画线到某点，为了模拟这些函数，设置了SX，SY两个全局变量用来作为Moveto（）的目的地和Drawlineto（）的起始坐标。

3. 矩形及填充矩形

矩形是通过两点确定的对角线来画的，直接连上各点的坐标就可以了。填充矩形是通过一条线一条线画的。这种算法速度比较慢，较好的方法是用Fillscreen（）里面用到的方法，那是一个字节一个字节处理的。就因为画矩形并不一定是整字节开始整字节结束的，开始处和结尾处就有了问题。我也把它们单独拿出来处理，但还是没做好，等有时间了再改吧。

4. 圆及弧

画圆采用的是参数方程的方法。为了提高速度，角度的sin、cos值建立了一个表，要用时直接查表。这是因为在用BRESENHAM算法画椭圆时，效果不是很好，画的椭圆不但厚薄不一，而且不闭合。估计是程序哪里出问题了，干脆都用参数方程的方法，又简单，又省事。我这人通常是比较懒的。

弧主要是用来画圆角矩形的，且只能画圆弧。这也是用参数方程来画的，跟画圆不同的只是有了角度的限制。

5. 贝塞尔曲线

贝塞尔曲线其实主要也就是一个公式，跟参数方程画圆是一回事，只是要传入的参数要多一些。在用鼠标控制时，因为有四个点，而用鼠标对多点的采集有点不好做，于是先就初始化了一个四点的数组，用不按键、按左键、按右键分别控制三个点，左右键同时按时，确定下一条曲线。

其实用鼠标画贝塞尔曲线因该把一次、二次、三次的处理函数都写出来，在按下左键时，标记下这点，再一次按下左键时，用画一次贝塞尔曲线的函数画，按下第三次时，用画二次曲线的函数画，按下第四次时才用画三次曲线的函数画。这样就不用为每个点分配一个鼠标按键了。

6. 填充

填充也是采用的种子填充法，不过不是直接从种子开始填色，而是先从种子出发，找到种子沿x最小的边界，然后填上一点，判断这一点的上边一点和下边一点，如果不为边界并且未被填色，则压入栈中，然后x增1后判断是否到达这一行x的最大值（既边界），如不是，则循环处理这一行，直到到达边界，再弹出一个点继续循环处理。由于是一个点一个点处理，所以速度比较慢。

为了对一个图形的不同颜色边界也能填充，填色时没有传入图形的边界颜色，而是采用先取出种子的颜色，在填充下一个点时，把下一点的颜色和种子颜色比较，如果相同则填色，不同则作为边界。

7. 汉字及字符

图形模式下显示汉字其实是一件比较麻烦的事，一般要用到汉字字库，生成的可执行文件也得在有字库的环境下运行。我这里采用了汉字无字库技术，生成的文件不依赖任何其他文件。

无字库技术是通过从字库文件提取需要的中文点阵字模建立一个类似字库的字库数组。它可以大大提高汉字的显示速度。在建立字库数组时，将字模数组进行了排序，所以在显示汉字时

文章来自: 好喜爱学习网(http://www.haoxiai.net) 网址：http://www.haoxiai.net/bianchengyuyan/cyuyan/11968.html

⑨ 用C实现Bresenham算法生成直线和圆的程序(要求具体步骤有必要解述)

Bresenham算法生成直线
假定直线从(x1,y1)到(x2,y2)，
令dx=x2-x1，dy=y2-y1
不妨设(dx,dy)在第一象限,并且直线的斜率不大于1

画线过程中有三个循环变量
x,y,d
初值
x=x1,y=y1,d=2*dy-dx

循环，直到x==x2为止
{
如果d>=0,y++,d+=2*(dy-dx)
如果d<0 ,x++,d+=2*dy
}

如果(dx,dy)不在第一象限，要做变换，即先把第一象限的画出来
如果斜率大于1，x,y交换

非常简单的，很容易实现
圆的算法：

int Bres(int x0,int y0,double r,int color)

{
int x,y,d;
x=0;
y=(int)r;
d=(int)(3-2*r);
while(x<y)
{
cirpot(x0,y0,x,y,color);
if(d<0)
d+=4*x+6;
else
{
d+=4*(x-y)+10;
y--;
}
x++;
}
if(x==y)
cirpot(x0,y0,x,y,color);
return(0);
}
int cirpot(int x0,int y0,int x,int y,int color)
{
setcolor(color);
putxicl((x0+x),(y0+y));
putxicl((x0+y),(y0+x));
putxicl((x0+y),(y0-x));
putxicl((x0+x),(y0-y));
putxicl((x0-x),(y0-y));
putxicl((x0-y),(y0-x));
putxicl((x0-y),(y0+x));
putxicl((x0-x),(y0+y));
setcolor(color);
return(0);
}

这是圆的算法，你若要整个程序，把你的电邮给我，我给你发过去、
运行环境是Turboc 2.0
int Bresline(int x1,inty1,int x2,int y2,int color)
{
int color,itag;
int dx,dy,tx,ty,inc1,inc2,d,curx,cury;
setcolor(color);
putxicl(x1,y1);
if(x1==x2&&y1==y2)
{
setcolor(color);
return(1);
}
itag=0;
dx=abs(x2-x1);
dy=abs(y2-y1);
if(dx<dy)
{
itag=1;]
iswap(&x1,&y1);
iswap(&x2,&y2);
iswap(&dx,&dy);
}
tx=(x2-x1)>0? 1:-1;
ty=(y2-y1)>0? 1:-1;
curx=x1;
cury=y1;
inc1=2*dy;
inc2=2*(dy-dx);
d=inc1-dx;
while(curx!x2)
{
if(d<0)
{
d+=inc1;
}
else
{
cury+=ty;
d+=inc2;
}
if(itag)
setpixel(cury,curx);
else
setpixel(curx,cury);
curxd+=tx;
}
setcolor(color);
return(0);
}
iswap(int*a,int*b)
{
int tmp;
tmp=*a;
*a=*b;
*b=tmp;
}

这是直线的算法：和圆的差不多，你可以参考一下：）

⑩ 椭圆成生算法

只写步骤，不写代码了。
和楼主共通过，楼主也是这方面的专家，因此步骤就不写太详细了，只写几个关键点吧。

方法1：（最通常）
通过 sin 和 cos 乘两轴长在原点画出正向椭圆，然后倾斜、偏移即可。
这样需要考虑弧度的间隔，否则两点之间并不连续。而盲目的细分弧度，会加重运算负担。
在许多 CAD 软件中，是通过设置圆的内接 n 边形来代表圆的，就是用线段连接。
将 n 边型的取值增大，椭圆就会很平滑了。
问题还有，就是长轴端的弧度，点会分布的比较稀少，因为屏幕分辨率并不是很高，所以可以用 长轴/短轴 的比值，来非等步长的增加弧度取值。

方法2：（近似求解）
通过4条贝塞尔曲线，可以连接成一个近似的椭圆。每段贝塞尔曲线代表原轴向椭圆的1/2*PI弧度，这样做最大误差只有0.027%。
每条贝塞尔曲线的四个控制点可以通过椭圆的外接矩形运算得出。

以扫描线方法的实现：
与楼主沟通过程中，提到了以扫描线的形式实现椭圆绘制过程。

常规方法：
纵向一个像素的移动扫描线，计算其与椭圆的两个交点，并与上一条扫描线的两个交点通过直线连接。第一次和最后一次与椭圆相交需要连接两个交点。
这种方法比较麻烦。

采用缓冲区的解决办法：
许多游戏都使用绘图缓冲区，不过这里用来实现扫描线绘制。
在内存中创建一个 DC 设备，将所有的绘图都转移到该 DC 设备上，然后通过 DC 设备和屏幕设备之间简单的行复制就可以了。

这样应该就完美的解决了楼主的问题。