中点画圆算法代码（中点画椭圆算法）

今天给各位分享中点画圆算法代码的知识，其中也会对中点画椭圆算法进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、怎样用C语言画圆？
• 2、如何用C语言画圆
• 3、C语言用Bresenham算法画圆，哪位高手教教，主要是算法里的内容，谢谢！
• 4、请问中点bresenham算法画圆与bresenham算法画圆有区别吗？

怎样用C语言画圆？

#include math.h

#include graphics.h /*预定义库函数*/

void circlePoint(int x,int y) /*八分法画圆程序*/

{

circle(320+x*20,240+y*20,3);

circle(320+y*20,240+x*20,3);

circle(320-y*20,240+x*20,3);

circle(320-x*20,240+y*20,3);

circle(320-x*20,240+y*20,3);

circle(320-x*20,240-y*20,3);

circle(320-y*20,240-x*20,3);

circle(320+y*20,240-x*20,3);

circle(320+x*20,240-y*20,3);

}

void MidBresenhamcircle(int r) /* 中点Bresenham算法画圆的程序 */

{

int x,y,d;

x=0;y=r;d=1-r; /* 计算初始值 */

while(xy)

{ circlePoint(x,y); /* 绘制点(x,y)及其在八分圆中的另外7个对称点 */

if(d0) d+=2*x+3; /* 根据误差项d的判断,决定非最大位移方向上是走还是不走 */

else

{ d+=2*(x-y)+5;

y--;

}

x++;

delay(900000);

} /* while */

}

main()

{

int i,j,r,graphmode,graphdriver;

detectgraph(graphdriver,graphmode);

initgraph(graphdriver,graphmode," ");

printf("中点Bresenhamcircle算法画圆的程序\n"); /*提示信息*/

printf("注意 |r|=11");

printf("\n输入半径值 r:");

scanf("%d",r);

printf("按任意键显示图形...");

getch();

cleardevice();

setbkcolor(BLACK);

for(i=20;i=620;i+=20) /*使用双循环画点函数画出表格中的纵坐标*/

for(j=20;j=460;j++)

putpixel(i,j,2);

for(j=20;j=460;j+=20) n欢迎光临学网,收藏本篇文章 [1] [2]

$False$

bsp; /*使用双循环画点函数画出表格中的横坐标*/

for(i=20;i=620;i++)

putpixel(i,j,2);

outtextxy(320,245,"0"); /*原点坐标*/

outtextxy(320-5*20,245,"-5");circle(320-5*20,240,2); /*横坐标值*/

outtextxy(320+5*20,245,"5");circle(320+5*20,240,2);

outtextxy(320-10*20,245,"-10");circle(320-10*20,240,2);

outtextxy(320+10*20,245,"10");circle(320+10*20,240,2);

outtextxy(320-15*20,245,"-15");circle(320-15*20,240,2);

outtextxy(320+15*20,245,"15");circle(320+15*20,240,2);

outtextxy(320,240-5*20,"-5");circle(320,240-5*20,2); /*纵坐标值*/

outtextxy(320,240+5*20,"5");circle(320,240+5*20,2);

outtextxy(320,240-10*20,"-10");circle(320,240-10*20,2);

outtextxy(320,240+10*20,"10");circle(320,240+10*20,2);

outtextxy(20,10,"The center of the circle is (0,0) "); /*坐标轴左上角显示提示信息*/

setcolor(RED); /*标记坐标轴*/

line(20,240,620,240); outtextxy(320+15*20,230,"X");

line(320,20,320,460); outtextxy(330,20,"Y");

setcolor(YELLOW);

MidBresenhamcircle(r);

setcolor(BLUE); /*绘制圆*/

circle(320,240,r*20);

setcolor(2);

getch();

closegraph();

}

如何用C语言画圆

利用x*x+y*y=r*r的方程式，依次变换x,可以得出一系列点（x,y），这些点组成的就是一个圆。

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

的确哈，关键在于对delta的理解

可以看到，都是delta=2*(1-radius)这样的，起作用应该是判断要画的点x、y坐标的变化趋势，先把我注释了的代码贴下，加了getch();可以看到画的过程

-----------------------------------------------------------------

#includegraphics.h

#includestdio.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算法画圆有区别吗？

Bresenham算法画圆：

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

直接给出Bresenham画圆的代码：

#include gl/glut.h

#include math.h

#include stdio.h

void draw_pixel(int ix,int iy)

{

glBegin(GL_POINTS);

glVertex2i(ix,iy);

glEnd();

}

//int inline round(const float a){return int (a+0.5);}

void Bresenham(int x1,int y1,int r,double a,double b,double c)/*圆心在（x1，y1），半径为r的圆*/

{

glColor3f(a,b,c);

int dx=r;//int dy=abs(yEnd-y1);

//      int p=2*dy-dx;

//      int twoDy=2*dy,twoDyMinusDx=2*dy-2*dx;

int x,y,d1,d2;

/*     if (x1xEnd)

{

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);

}

}

}

void display()

{

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();

}

void myinit()

{

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);

}

void main(int argc,char **argv )

{

glutInit(argc,argv);

glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);

glutInitWindowSize(500,500);

glutInitWindowPosition(200.0,200.0);

glutCreateWindow("CG_test_Bresenham_Circle example");

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

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

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

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

#includegl\glut.h

class screenPt

{

private:

int x,y;

public:

screenPt(){ x=y=0;}

void setCoords(GLint xCoordValue,GLint yCoordValue)

{

x=xCoordValue;

y=yCoordValue;

}

GLint getx()const

{

return x;

}

GLint gety()const

{

return y;

}

void incrementx(){x++;}

void decrementy(){y--;}

};

void draw_pixel(int xCoord,int yCoord)

{

glBegin(GL_POINTS);

glVertex2i(xCoord,yCoord);

glEnd();

}

void circleMidpoint(GLint xc,GLint yc,GLint radius)

{

screenPt circPt;

GLint p=1-radius;

circPt.setCoords(0,radius);

void circlePlotPoints(GLint ,GLint, screenPt);

circlePlotPoints(xc,yc,circPt);

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

{

circPt.incrementx();

if(p0)

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

else

{

circPt.decrementy();

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

}

circlePlotPoints(xc,yc,circPt);

}

}

void circlePlotPoints(GLint xc,GLint yc,screenPt circPt)//描绘八分圆各点

{

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());

}

void display()

{

//screenPt Pt;

glClear(GL_COLOR_BUFFER_BIT);

circleMidpoint(250,250,200);

glFlush();

}

void myinit()

{

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);

}

void main(int argc,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();

}

运行效果：

中点画圆算法代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于中点画椭圆算法、中点画圆算法代码的信息别忘了在本站进行查找喔。