bresenham演算法畫圓簡單代碼

A. 怎樣用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;

}

B. 關於Bresenham演算法的求助

今天一下子遇到三個類似的問題，所以我這篇東西就連續復制粘貼了三遍：

（下面的坐標本來是有下標的，但復制過來就變沒了，你可能看的有點暈）

Bresenham演算法是Bresenham提出的一種光柵線生成演算法！

DDA演算法表面上看起來很有效，並且代碼也比較容易實現，但是顯示每個像素都需要進行一次浮點數加法運算，而Bresenham演算法的最大優點是不需要進行浮點數運算！這是一種精確而有效的光柵線生成演算法，該演算法僅使用增量整數計算，計算速度比DDA要快，另外，Bresenham演算法還可用於顯示圓和其他曲線，這里暫時只顯示直線！

與DDA一樣，我們假設線段的兩個端點坐標是整數值（x0,y0）（xEnd,yEnd）,且斜率m滿足0<=m>=1!坐標軸的垂直軸表示掃描線位置，水平軸標識像素列，假設以單位x間隔取樣，需要確定下一個每次取樣時兩個可能的像素位置中的哪一個更接近於線路徑！

從給定線段的左端點（x0,y0）開始,逐步處理每個後繼列（x位置），並在其掃描線y值最接近線段的像素處描出一點，假如已經確定要顯示的像素在（xk,yk），那麼下一步就要確定在列xk+1=xk+1上繪制哪個像素，是在位置(xk+1,yk)還是在(xk+1,yk+1)

在取樣位置xk+1，我們使用dlower和pper來標識兩個像素與數學上線路徑的垂直偏移（就是通過這兩個值來比較哪個點離線上的點最近，以下推導過程你可能看得有點暈，但都是為了推出後續的點而已，你可以結合下面例子程序中的Bresenham函數來看），在像素列xk+1處的直線上的y坐標根據直線方程可計算得：

y=m(xk+1)+b

那麼可求得：

dlower=y-yk=m(xk+1)+b-yk

pper=(yk+1)-y=yk+1-m(xk+1)-b

令斜率m=dy/dx,引入決策參數Pk，定義為：

Pk=dx(dlower-pper)

=2dx*xk-2dy*yk+c

C是一個常數，值為2dx+dx(2b-1)

由此可以計算得到

pk+1=Pk+2dy-2dx(yk+1-yk)

其中yk+1-yk取0還是取1取決於參數Pk的符號，Pk為負時取0，Pk非負時取1！

而Pk為負時，下一個要繪制的點就是（xk+1,yk）且pk+1=Pk+2dy

Pk為非負時則下一個要繪制的點就是（xk+1,yk+1）且pk+1=Pk+2dy-2dx

至此，Bresenham演算法介紹完畢，以下為某個示例：

#include<gl/glut.h>

#include<math.h>

#include<stdio.h>

voiddraw_pixel(intix,intiy)

{

glBegin(GL_POINTS);

glVertex2i(ix,iy);

glEnd();

}

voidBresenham(intx1,inty1,intxEnd,intyEnd)

{

intdx=abs(xEnd-x1),dy=abs(yEnd-y1);

intp=2*dy-dx;

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

intx,y;

if(x1>xEnd)

{

x=xEnd;y=yEnd;

xEnd=x1;

}

else

{

x=x1;

y=y1;

}

draw_pixel(x,y);

while(x<xEnd)

{

x++;

if(p<0)

p+=twoDy;

else

{

y++;

p+=twoDyMinusDx;

draw_pixel(x,y);

}

}

}

voiddisplay()

{

glClear(GL_COLOR_BUFFER_BIT);

Bresenham(0,0,400,400);

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

glutDisplayFunc(display);

myinit();

glutMainLoop();

}

運行效果：

C. 【譯】Bresenham 直線演算法

原文鏈接： deepnight.net/tutorial/.../ 作者：Sébastien Bénard 譯者：mnikn

1. 什麼是 Bresenham 直線演算法

Bresenham 直線演算法是一種廣泛使用的演算法，它在繪制兩點之間的直線時特別有效，尤其適合於像素網格。其優點是生成的直線像素精確，看起來非常酷。此外，該演算法還應用於多種其他用途，包括 AI、尋路演算法優化、路徑平滑、視野檢測、光照檢測等。

2. 實現

基於 Haxe 的實現可以在我的 GitHub 倉庫中找到：BRESENHAM.HXFrom deepnightLibs on GitHub

以下是一個基於 Haxe 的示例代碼：

注意：fastAbs 和 fastFloor 是絕對值和向下取整的高效實現。

要使用 Bresenham 演算法，您可以參考維基網路上關於常規實現的資料，並在必要時對演算法進行特殊優化。下面是一些使用案例：

3. 使用案例

3.1. AI

在編寫怪物敵人的 AI 時，可以使用 Bresenham 直線演算法來檢測視野中的障礙物。例如，通過在直線路徑上檢查每個點來確定是否有障礙物。

3.2. 尋路演算法優化

在實現尋路演算法（如 A-star 演算法）時，可以使用 Bresenham 直線演算法來減少不必要的尋路調用，從而提高性能。

3.3. 平滑尋路路徑

通過應用 Bresenham 直線演算法，可以優化尋路演算法結果，使其路徑看起來更加平滑。

3.4. 視野檢測（圓錐）

可以使用 Bresenham 直線演算法實現像 Metal Gear Solid 或 Commando 那樣的圓錐視野檢測，檢測敵人是否能看到玩家。

3.5. 關於對角的注意點

應注意，即使游戲中有對角的牆，基本的 Bresenham 直線演算法也能穿透它們。

3.6. 光照

使用 Bresenham 直線演算法檢測火炬是否能照亮特定點，可以實現動態光照效果。預計算光照值可以顯著降低性能開銷。

3.7. Pixel perfect 的圓

Bresenham 直線演算法不僅可以繪制直線，還可以用於繪制圓。雖然它不如直線常用，但在某些情況下仍然有用，而且實現相對簡單。

總結：Bresenham 直線演算法是一個多功能的演算法，廣泛應用於游戲開發中的多種場景。雖然現代游戲引擎可能內置了類似功能，但了解 Bresenham 演算法的基本原理和應用依然非常有價值。

D. 請問中點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();

}

運行效果：

E. 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;
}
}
}