画圆算法
‘壹’ 怎样用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;
}
‘贰’ 请问中点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();
}
运行效果：
‘叁’ 怎样用利用Turbo C实现圆生成的中点画圆算法。
#include <glut.h>
#include <math.h>
#include <stdlib.h>
#include <gl/GL.h>
#include <gl/GLU.h>
#include <gl/glaux.h>
#include <Windows.h>
#pragma comment(lib,"glaux.lib")
#pragma comment(lib,"glu32.lib")
#pragma comment(lib,"glut32.lib")
#pragma comment(lib,"opengl32.lib")
class scrpt
{
public:
GLint x,y;
};
void myinit(void);
void display(void);
void setPixel(GLint x,GLint y);
void circlePlotPoint(scrpt circCtr,scrpt circpt);
void circleMidpoint(scrpt circCtr,GLint radius);
void setPixel(GLint x,GLint y)
{
glBegin(GL_POINTS);
glVertex2i(x,y);
glEnd();
}
void myinit(void)
{
glClearColor(0.0,0.0,0.0,0.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0.0,800.0,0.0,600.0);
}
void circleMidpoint(scrpt circCtr,GLint radius)
{
scrpt circpt;
GLint p=1-radius;
circpt.x=0;
circpt.y=radius;
void circlePlotPoints(scrpt,scrpt);
circlePlotPoints(circCtr,circpt);
while(circpt.x<circpt.y)
{
circpt.x++;
if(p<0)
p+=2*circpt.x+1;
else
{
circpt.y--;
p+=2*(circpt.x-circpt.y)+1;
}
circlePlotPoints(circCtr,circpt);
}
}
void circlePlotPoints(scrpt circCtr,scrpt circpt)
{
setPixel(circCtr.x+circpt.x,circCtr.y+circpt.y);
setPixel(circCtr.x-circpt.x,circCtr.y-circpt.y);
setPixel(circCtr.x+circpt.x,circCtr.y-circpt.y);
setPixel(circCtr.x-circpt.x,circCtr.y+circpt.y);
setPixel(circCtr.x+circpt.y,circCtr.y+circpt.x);
setPixel(circCtr.x+circpt.y,circCtr.y-circpt.x);
setPixel(circCtr.x-circpt.y,circCtr.y+circpt.x);
setPixel(circCtr.x-circpt.y,circCtr.y-circpt.x);
}
void display(void)
{ scrpt point;
point.x=200;
point.y=210;
int radius=20;
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.5,0.6,1.0);
circleMidpoint(point,radius);
glFlush();
}
void main(int argc,char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowPosition(100,100);
glutInitWindowSize(400,400);
glutCreateWindow("pointcircle");
myinit();
glutDisplayFunc(display);
glutMainLoop();
}
‘肆’ 画圆为什么要用Bresenham算法
算法引入的本意是解决像素填充的问题的
点和线这种东西在理论上都是没有宽度的，但是要在屏幕上绘制的时候就要去填充像素以形成痕迹
一行上经常有2个以上的像素都被线所贯穿， 如何填充是个问题
而且像素填充本身是使用非常频繁的需求，故而画线的算法效率是非常重要的，对整个系统影响巨大
Bresenham算法是通过增量计算的方式快速判别下一个行或者列上的要填充的像素的位置，从计算上来说非常的节省，几乎都是整数的算法，速度非常的快
‘伍’ 1.应用中点画圆算法，仿照AutoCAD做法，编写用三点画圆的程序(用vc编写)。 2.应用中点画圆算法，编写画弧
发货部分与推进会让他
‘陆’ 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;
}
}
}
‘柒’ 求一个Java画圆或椭圆算法
所有点的坐标？？没搞明白！
‘捌’ 什么是“直角坐标画圆”算法
就是根据圆心在直角坐标系里的位置和半径，依次计算
圆周
各点
坐标，并依次连接
这些点
“画圆”
圆方程：
(x-x0)*(x-x0)
+
(y-y0)*(y-y0)
=
R*R
x0,y0
是圆心座标，R
是
半径。
x
范围是
x0-R
到
x0+R
y
范围是
y0-R
到
y0+R
或：
(x-x0)
=
R
cos(A);
(y-y0)
=
R
sin(A);
你可以给一个步长（例如dA=1度），计算圆周
各点
的
坐标。
这就是
“直角坐标画圆”算法。
‘玖’ 中点画圆算法原理
圆心到圆上各点的距离相等(等于圆的半径)
‘拾’ 计算机图形学中集坐标画圆的算法
非常抱歉，俺不会...混分的，不用介意哦！