中点Bresenham算法画圆

bresenham圆弧算法

bresenham圆弧算法Bresenham圆弧算法Bresenham圆弧算法是一种用于绘制圆弧的算法，它是Bresenham 线算法的扩展。

Bresenham线算法是一种用于绘制直线的算法，而Bresenham圆弧算法则是在此基础上实现的。

圆弧是一个弧线段，它是由圆的一部分组成。

绘制圆弧的方法有很多种，但Bresenham圆弧算法是一种简单而高效的方法。

它通过使用离散的像素点来逼近圆弧的曲线，从而实现圆弧的绘制。

Bresenham圆弧算法的核心思想是利用圆的对称性和连续性，在每个象限内只绘制其中一部分弧线，然后通过变换和旋转来得到其他象限的弧线。

具体来说，算法通过计算每个象限内的像素点与理想圆弧曲线的差距，然后选择最接近理想曲线的像素点来绘制圆弧。

为了实现Bresenham圆弧算法，我们需要知道圆心坐标、半径和起始角度。

首先，我们需要确定圆弧的起始点和终止点，这可以通过圆心坐标、半径和起始角度来确定。

然后，我们可以使用Bresenham线算法来绘制起始点和终止点之间的线段。

接下来，我们需要计算每个象限内的像素点与理想圆弧曲线的差距，并选择最接近理想曲线的像素点来绘制圆弧。

Bresenham圆弧算法的优点是效率高，绘制的圆弧曲线非常接近理想曲线。

这是因为算法利用了圆的对称性和连续性，只需绘制部分弧线即可得到完整的圆弧。

此外，算法的实现较为简单，只需使用基本的数学运算和判断即可完成绘制。

然而，Bresenham圆弧算法也存在一些局限性。

首先，算法只适用于绘制在屏幕上呈现为直线的圆弧。

对于曲线较为复杂的圆弧，Bresenham圆弧算法可能无法得到准确的结果。

此外，算法对圆心坐标和半径的限制较大，不适用于所有情况。

Bresenham圆弧算法是一种用于绘制圆弧的高效算法。

它通过使用离散的像素点来逼近圆弧的曲线，实现了圆弧的绘制。

虽然算法具有一定的局限性，但在满足条件的情况下，它可以得到准确且高效的结果。

中点bresenham算法过程

中点Bresenham算法是一种用于计算在直线上的格点的算法。

它是由Bresenham在1965年提出的，是一种高效的计算机图形学算法，通常用于直线、圆、椭圆等形状的绘制。

通过这篇文章，我们将详细介绍中点Bresenham算法的过程。

1. 背景知识在计算机图形学中，我们经常需要在屏幕上绘制直线、圆、椭圆等形状。

而计算机屏幕上的图像是由像素组成的，因此我们需要一种算法来计算出这些形状上的像素坐标，从而进行绘制。

中点Bresenham算法就是用来解决这个问题的。

2. 中点Bresenham算法的原理中点Bresenham算法的原理是通过巧妙的数学推导，找到离直线最近的像素点，从而确定需要绘制的像素坐标。

该算法通过利用误差项来判断下一个像素点的位置，具有高效、简洁的特点。

3. 中点Bresenham算法的过程中点Bresenham算法的过程可以分为以下几个步骤：3.1 初始化变量：首先需要确定直线的起点和终点，并初始化相关变量，如起点坐标(x0, y0)、终点坐标(x1, y1)、误差项d和增量变化量dx、dy等。

3.2 计算斜率k和误差项初始值：通过计算直线的斜率k，并根据斜率确定误差项的初始值。

3.3 循环计算像素点的坐标：根据误差项的大小，确定下一个像素点的位置，并更新误差项的值，直到绘制完整条直线。

4. 中点Bresenham算法的优势* 算法简洁高效：中点Bresenham算法通过简单的数学计算，即可确定直线上的像素坐标，避免了直接计算斜率导致的浮点数运算，因此在计算速度上具有较大优势。

* 适用范围广泛：中点Bresenham算法不仅适用于直线，还可以用于绘制圆、椭圆等图形，具有良好的通用性。

5. 中点Bresenham算法的应用中点Bresenham算法广泛应用于计算机图形学中的直线、圆、椭圆等图形的绘制。

其高效、简洁的特点使得它成为了计算机图形学中不可或缺的算法之一。

中点Bresenham算法是计算机图形学中的重要算法之一，通过巧妙的数学计算，实现了高效、简洁的直线绘制。

Bresenham画圆算法图形学讲义教学课件

共享顶点的两条边分别位于扫描线的两边，交点算一个。共享顶点的两条边都位于扫描线的下边，交点算零个。共享顶点的两条边都位于扫描线的上边，交点算二个。
右、上边界的象素不予填充。左、下边界的象素予以填充。
算法的实现
求交
所有的边和扫描线求交，效率很低。因为一条扫描线往往只和少数几条边相交。
如何判断多边形的一条边与扫描线是否相交？(ymin,ymax)
=(x+1)2 + (y-1)2 -R2 - 2(y-1) + 1 = D - 2(y-1) + 1
有了上述 D的递推计算公式，还需计算出D的初值。 ∵ 圆弧的起点为（0，R） ∴ D的初值为：
D = (0+1)2 +(R-1)2-R2 = 2 (1-R)
BresenhamCircle(r, color)
填充。
王选。
TrueType技术
Windows的字库
二次Bezier曲线描述轮廓，控制点按顺时针方向编号。
使用时先生成轮廓，再在内部填充形成点阵信息，显示或输出。
例子
H的TrueType字库控制信息 X方向 Y方向
标准字符集
• ASCII
• 共127个。 • 0－31 不可见，控制字符。 • 32－127可见（大小写字母，数字，运算
象素入栈多次，栈要很大的空间。
扫描线填充算法
沿扫描线，在扫描线与多边形的相交区间内填充。
只取一个种子象素。
种子象素入栈；当栈非空时执行以下四步操作：
1 栈顶元素出栈；
2 沿扫描线对出栈象素的左右象素进行填充，直至遇到边界象素为止。即对每个出栈象素，对包含该象素的整个区间进行填充。
}/*end of switch*/ }/*end of while*/ }/*end of BresenhamCircle*/

圆中点Bresenham算法

第5章本案例知识要点●掌握八分法中点Bresenham 算法绘制圆的原理 ●设计八分法绘制圆的中点Bresenham 算法 ●编写八分法绘制圆的CirclePoint(x,y) 子函数 ● 编写绘制整圆的Mbcircle()子函数一、案例需求1．案例描述使用中点Bresenham 算法绘制圆心位于屏幕客户区中心的圆。

2．案例效果图案例输入对话框及效果如图3-1所示。

（a ）输入对话框（b ）效果图3-1 圆中点Bresenham 算法效果图 3．功能说明（1）要求使用对话框输入圆的半径。

（2）圆的颜色为蓝色。

三、算法设计1. 输入圆的半径R 。

2. 定义圆当前点坐标x ，y 、定义中点偏差判别式d 、定义像素点颜色rgb 。

3. 计算R d -=25.1，x=0，y=R ，rgb ＝RGB(0,0,255)。

案例三圆中点Bresenham 算法4.绘制点（x，y）及其在八分圆中的另外7个对称点。

5.判断d的符号。

若d<0，则（x，y）更新为（x＋1，y），d更新为d+2x＋3；否则（x，y）更新为（x＋1，y－1），d更新为d＋2（x－y）＋5。

6.当x小于等于y，重复步骤⑷和⑸，否则结束。

四、案例实现1．CTestView.h文件// TestView.h : interface of the CTestView class/////////////////////////////////////////////////////////////////////////////#if !defined(AFX_TESTVIEW_H__A75FDCFB_621C_4E38_A154_C344803E6372__INCLUDED_)#define AFX_TESTVIEW_H__A75FDCFB_621C_4E38_A154_C344803E6372__INCLUDED_#if _MSC_VER > 1000#pragma once#endif // _MSC_VER > 1000#include "InputDlg.h"//包含对话框头文件class CTestView : public CView{protected: // create from serialization onlyCTestView();DECLARE_DYNCREATE(CTestView)// Attributespublic:CTestDoc* GetDocument();// Operationspublic:void GetMaxY();//获得屏幕的最大x值函数void GetMaxX();//获得屏幕的最大y值函数void CirclePoint(double x,double y);//八分法画圆子函数void Mbcircle();//圆中点Bresenham算法// Overrides// ClassWizard generated virtual function overrides//{{AFX_VIRTUAL(CTestView)public:virtual void OnDraw(CDC* pDC); // overridden to draw this viewvirtual BOOL PreCreateWindow(CREATESTRUCT& cs);protected:virtual BOOL OnPreparePrinting(CPrintInfo* pInfo);virtual void OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo);virtual void OnEndPrinting(CDC* pDC, CPrintInfo* pInfo);//}}AFX_VIRTUAL// Implementationpublic:virtual ~CTestView();#ifdef _DEBUGvirtual void AssertValid() const;virtual void Dump(CDumpContext& dc) const;#endifprotected:int MaxX,MaxY; //屏幕x和y的最大坐标double R; //圆的半径// Generated message map functionsprotected://{{AFX_MSG(CTestView)afx_msg void OnMENUMbcircle();//}}AFX_MSGDECLARE_MESSAGE_MAP()};#ifndef _DEBUG // debug version in TestView.cppinline CTestDoc* CTestView::GetDocument(){ return (CTestDoc*)m_pDocument; }#endif///////////////////////////////////////////////////////////////////////////////{{AFX_INSERT_LOCATION}}// Microsoft Visual C++ will insert additional declarations immediately before the previous line.#endif // !defined(AFX_TESTVIEW_H__A75FDCFB_621C_4E38_A154_C344803E6372__INCLUDED_) 2．CTestView. cpp文件// TestView.cpp : implementation of the CTestView class#include "stdafx.h"#include "Test.h"#include "TestDoc.h"#include "TestView.h"#define ROUND(a) int(a+0.5) //四舍五入#ifdef _DEBUG#define new DEBUG_NEW#undef THIS_FILEstatic char THIS_FILE[] = __FILE__;#endif///////////////////////////////////////////////////////////////////////////// // CTestViewIMPLEMENT_DYNCREATE(CTestView, CView)BEGIN_MESSAGE_MAP(CTestView, CView)//{{AFX_MSG_MAP(CTestView)ON_COMMAND(ID_MENU_Mbcircle, OnMENUMbcircle)//}}AFX_MSG_MAP// Standard printing commandsON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)END_MESSAGE_MAP()///////////////////////////////////////////////////////////////////////////// // CTestView construction/destructionCTestView::CTestView(){// TODO: add construction code here}CTestView::~CTestView(){}BOOL CTestView::PreCreateWindow(CREATESTRUCT& cs){// TODO: Modify the Window class or styles here by modifying// the CREATESTRUCT csreturn CView::PreCreateWindow(cs);}///////////////////////////////////////////////////////////////////////////// // CTestView drawingvoid CTestView::OnDraw(CDC* pDC){CTestDoc* pDoc = GetDocument();ASSERT_VALID(pDoc);// TODO: add draw code for native data here}///////////////////////////////////////////////////////////////////////////// // CTestView printingBOOL CTestView::OnPreparePrinting(CPrintInfo* pInfo){// default preparationreturn DoPreparePrinting(pInfo);}void CTestView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/){// TODO: add extra initialization before printing}void CTestView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/){// TODO: add cleanup after printing}///////////////////////////////////////////////////////////////////////////// // CTestView diagnostics#ifdef _DEBUGvoid CTestView::AssertValid() const{CView::AssertValid();}void CTestView::Dump(CDumpContext& dc) const{CView::Dump(dc);}CTestDoc* CTestView::GetDocument() // non-debug version is inline{ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CTestDoc)));return (CTestDoc*)m_pDocument;}#endif //_DEBUG///////////////////////////////////////////////////////////////////////////// // CTestView message handlersvoid CTestView::GetMaxX()//得到客户区的最大横坐标{CRect Rect;GetClientRect(&Rect);MaxX=Rect.right;}void CTestView::GetMaxY()//得到客户区最大纵坐标{R=dlg.m_R;}AfxGetMainWnd()->SetWindowText("基本图形扫描转换:Mbcircle");RedrawWindow();GetMaxX();GetMaxY();Mbcircle();}五、案例说明因为设备坐标系的原点在屏幕左上角，所以为了在屏幕中心绘制圆，定义了GetMaxX()和GetMaxY()函数来获得屏幕的MaxX和MaxY，参见案例1的实现部分。

圆绘制算法实验报告

一、实验背景圆是几何图形中最基本的图形之一，在计算机图形学中，绘制圆是图形处理的基础。

本实验旨在通过实现圆的绘制算法，加深对计算机图形学基本概念和方法的理解，提高编程能力。

二、实验目的1. 掌握圆的基本绘制方法；2. 熟悉Bresenham算法和中点算法的原理；3. 理解并实现圆的绘制算法；4. 分析不同算法的优缺点，提高算法选择能力。

三、实验内容1. Bresenham算法画圆2. 中点算法画圆四、实验原理1. Bresenham算法画圆Bresenham算法是一种光栅扫描算法，用于绘制圆、椭圆、直线等图形。

该算法的基本思想是：根据圆的几何特性，计算出每个像素点是否应该被绘制。

对于圆的绘制，我们可以利用以下公式：\[ x^2 + y^2 = r^2 \]其中，\( x \) 和 \( y \) 分别表示圆上一点的横纵坐标，\( r \) 表示圆的半径。

Bresenham算法的步骤如下：（1）初始化参数：设置起始点（0, r），终止点（r, 0），步长 \( p \)；（2）计算判别式 \( p = 2x - y \)；（3）根据判别式的值，更新 \( x \) 和 \( y \) 的值；（4）重复步骤（2）和（3），直到 \( x = y \)；（5）绘制圆。

2. 中点算法画圆中点算法是一种基于Bresenham算法的改进算法，它利用圆的对称性，减少了计算量。

中点算法的步骤如下：（1）初始化参数：设置起始点（0, r），终止点（r, 0），步长 \( p \)；（2）计算判别式 \( p = 1 - 2x \)；（3）根据判别式的值，更新 \( x \) 和 \( y \) 的值；（4）重复步骤（2）和（3），直到 \( x = y \)；（5）绘制圆。

五、实验步骤1. 创建一个OpenGL窗口，用于显示绘制的圆；2. 使用Bresenham算法绘制圆；3. 使用中点算法绘制圆；4. 比较两种算法的绘制效果，分析优缺点；5. 编写代码实现两种算法，并进行测试。

bresenham画圆算法原理

bresenham画圆算法原理宝子！今天咱们来唠唠这个Bresenham画圆算法的原理，可有趣儿啦！你想啊，画圆这个事儿，在计算机里可不像咱们拿个圆规在纸上画那么简单。

计算机就知道一个个的像素点，它得想办法把这些像素点组合起来，看起来像个圆才行。

Bresenham画圆算法就像是一个超级聪明的小工匠，在像素的世界里一点点雕琢出圆的形状。

那这个算法是咋开始的呢？咱们先得知道圆的方程，一般的圆方程是(x - a)^2+(y - b)^2 = r^2，这里的(a,b)是圆心坐标，r是半径。

但是这个算法可不会直接用这个方程来一个点一个点地找。

为啥呢？因为计算起来太麻烦啦，计算机可不喜欢干这么费劲的事儿。

这个算法呀，它很聪明地利用了圆的对称性。

圆多对称呀，关于x轴、y轴还有原点都对称。

所以呢，只要算出圆的八分之一部分的像素点，其他部分就可以根据对称关系得到啦。

就好像你有一个小拼图块，通过对称翻转，就能拼出整个大图案一样。

咱就拿第一象限里的八分之一圆来说吧。

这个算法开始的时候，先确定一个初始点。

这个初始点呢，是在x = 0的时候，y = r。

这就像是在圆的最上面的那个点，就像圆的小脑袋一样。

然后呢，它就要开始一步一步地找下一个点啦。

它怎么找下一个点呢？这里面就有个很妙的决策。

它会比较两个可能的下一个点到圆的距离。

你可以想象成有两个小蚂蚁，都想朝着圆的方向走，但是哪条路更近呢？算法就要判断这个。

它会根据一些简单的计算，这些计算都是基于整数的哦，计算机就喜欢整数计算，快得很。

它会看如果选择一个点，和选择另一个点，哪个会让这个点更接近真正的圆。

如果一个点离圆更近，那就选这个点作为下一个点。

然后呢，每确定一个新的点，就像在这个像素的世界里又铺了一块小砖头，慢慢地，这个八分之一圆的形状就出来了。

等这个八分之一圆的像素点都确定好了，就可以根据对称关系，把整个圆的像素点都找出来啦。

这个算法的好处可多啦。

它计算速度快，因为都是整数运算，不用做那些复杂的浮点数计算。

易懂的Bresenham布雷森汉姆算法画圆的原理与Python编程实现教程

易懂的Bresenham布雷森汉姆算法画圆的原理与Python编程实现教程Bresenham 布雷森汉姆算法画圆的原理与编程实现教程注意：Bresenham的圆算法只是中点画圆算法的优化版本。

区别在于Bresenham的算法只使⽤整数算术，⽽中点画圆法仍需要浮点数。

注意：不要因为我提到了中点画圆法你就去先看完再看Bresenham算法，这样是浪费时间。

中点画圆法和Bresenham画圆法只是思想⼀样，但是思路并没有很⼤关联。

所以直接看Bresenham算法就可以。

看下⾯这个图，这就是⼀个像素⼀个像素的画出来的。

我们平常的圆也是⼀个像素⼀个像素的画出来的，你可以试试在“画图”这个软件⾥⾯画⼀个圆然后放⼤很多倍，你会发现就是⼀些像素堆积起来的。

我们看出来圆它是⼀个上下左右都对称，⽽且也是中⼼对称的。

所以我们只⽤画好⼋分之⼀圆弧就可以，其他地⽅通过对称复制过去就好。

看下⾯这幅图，绿线夹住的那部分就是⼋分之⼀圆弧。

注意我们是逆时针画圆的（即从⽔平那个地⽅即(r,0)开始画因为⼀开始我们只知道⽔平位置的像素点该放哪其他地⽅我们都不知道）。

Bresenham 算法画完⼀个点(x,y)后注意x,y都是整数。

他们代表的是x,y⽅向上的第⼏个像素。

，它下⼀步有两个选择(x,y+1),(x-1,y+1)。

也就是说y⼀定增加,但是x要么保持不变要么减⼀（你也可以让x⼀定增加y要么不变要么加⼀，其实差不多的）。

当程序画到粉红⾊那个像素点的时候，程序选择下⼀步要绘制的点为(x-1，y+1)。

当程序画到黄⾊的那个像素点时候，程序选择下⼀步要绘制的点为(x,y+1)。

我们看看粉⾊的那个点的下⼀步是如何抉择的。

Bresenham是根据待选的两个点哪个离圆弧近就下⼀步选哪个。

那它是怎么判断的呢？这两个点⼀定有⼀个在圆弧内⼀个在圆弧外。

到底选哪个？Bresenham的⽅法就是直接计算两个点离圆弧之间的距离，然后判断哪个更近就选哪个。

算法画圆中点圆算法计算机图形学

绠楁硶鐢诲渾涓偣鍦嗙畻娉?璁＄畻鏈哄浘褰㈠Bresenham绠楁硶鐢诲渾涓偣鍦嗙畻娉曡绠楁満鍥惧舰瀛?010-12-02 20锛?8///////////////////////////////////////////////////////////////// /////涓偣鍦嗘暣鏁扮畻娉曠敾鍦?////////////////////////////////////////////////////////////////// ////void roundMid(int x1,int y1,int R,CDC*pDC){int x=0,y=R锛?/p>int d=1-R锛?/璧风偣(0,R),涓嬩竴鐐逛腑鐐?1,R-0.5),d=1*1+(R-0.5)*(R-0.5)-R*R=1.25-R,d鍙弬涓庢暣鏁拌繍绠楋紝鎵€浠ュ皬鏁伴儴鍒嗗彲鐪佺暐while(y x)//y x鍗崇涓€璞￠檺鐨勭2鍖哄叓鍒嗗渾{pDC-SetPixel(x+x1,y+y1,RGB(255,0,0))锛?/鍦嗗績(x1,y1),鐢荤偣鏃剁洿鎺ョ浉鍔犲钩绉?鐢?鍖?/p>pDC-SetPixel(y+x1,x+y1,RGB(255,0,0))锛?/鐢?鍖?/p>pDC-SetPixel(-x+x1,y+y1,RGB(255,0,0))锛?/鐢?鍖?/p>pDC-SetPixel(-y+x1,x+y1,RGB(255,0,0))锛?/鐢?鍖?/p>pDC-SetPixel(-x+x1,-y+y1,RGB(255,0,0))锛?/鐢?鍖?/p>pDC-SetPixel(-y+x1,-x+y1,RGB(255,0,0))锛?/鐢?鍖?/p>pDC-SetPixel(x+x1,-y+y1,RGB(255,0,0))锛?/鐢?鍖?/p>pDC-SetPixel(y+x1,-x+y1,RGB(255,0,0))锛?/鐢?鍖?/p>if(d 0)d=d+2*x+3锛?/d鐨勫彉鍖?/p>else{d=d+2*(x-y)+5锛?/d=0鏃?d鐨勫彉鍖?/p>y--锛?/y鍧愭爣鍑?}x++锛?/x鍧愭爣鍔?}}///////////////////////////////////////////////////////////////// /////Bresenham绠楁硶鐢诲渾/////////////////////////////////////////////////////////////////// ////void RoundBre(int x1,int y1,int R,CDC*pDC){//鍦嗗績(x1,y1),褰撳墠鍍忕礌I(xi,yi),鍙冲儚绱燞(xi+1,y),鍙充笅鍍忕礌D(xi+1,yi-1),涓嬪儚绱燰(xi,yi-1)int xi,yi,dd,m,n锛?/p>//鍦嗗績璺濆樊鍊煎钩鏂筪h=(xi+1)*(xi+1)+yi*yi-R*R锛沝d=(xi+1)*(xi+1)+(yi-1)*(yi-1)-R*R锛沝v=xi*xi+(yi-1)*(yi-1)-R*R锛?/p>xi=0锛?/璧风偣(0,R)yi=R锛?/p>dd=2-2*R锛?/璧风偣鐨勫彸涓嬪儚绱?1,R-1)鐨勫渾蹇冭窛宸€糳d=1+(R-1)*(R-1)-R*R pDC-SetPixel(x1,y1,RGB(0,0,255))锛?/鐢诲渾蹇?璇佹槑鍦嗗績蹇呴』鍗犵敤涓€涓儚绱?/p>while(yi=xi)//寰幆鍒板叓鍒嗕箣涓€鍦嗭紱yi=0鍗冲彲浠ョ敾鍑哄洓鍒嗗渾{pDC-SetPixel(xi+x1,yi+y1,RGB(255,0,0))锛?/2鍖?鍧愭爣骞崇Щ(x1,y1)鐢诲渾pDC-SetPixel(yi+x1,xi+y1,RGB(255,0,0))锛?/1鍖?/p>pDC-SetPixel(-xi+x1,yi+y1,RGB(255,0,0))锛?/3鍖?/p>pDC-SetPixel(-yi+x1,xi+y1,RGB(255,0,0))锛?/4鍖?/p>pDC-SetPixel(-yi+x1,-xi+y1,RGB(255,0,0))锛?/5鍖?/p>pDC-SetPixel(-xi+x1,-yi+y1,RGB(255,0,0))锛?/6鍖?/p>pDC-SetPixel(xi+x1,-yi+y1,RGB(255,0,0))锛?/7鍖?/p>pDC-SetPixel(yi+x1,-xi+y1,RGB(255,0,0))锛?/8鍖?/p>if(dd 0)//D鍦ㄥ渾鍐咃紱H鍦ㄥ渾涓婃垨鍦嗗锛涢€夋嫨H鎴朌,dh=0,dd 0,m=|dh|-|dd|=2*(dd+yi)-1锛?/p>{m=2*(dd+yi)-1锛?/p>if(m=0)//鍙栧彸鍍忕礌H(xi+1,yi)锛沵=0鏃跺彇鍙崇偣{dd=dd+2*xi+3锛?/姹侶鐨勫彸涓嬪儚绱?xi+2,yi-1),dd=(xi+2)*(xi+2)+(yi-1)*(yi-1)-R*R xi=xi+1锛?/p>}else//鍙栧彸涓嬪儚绱燚(xi+1,yi-1){dd=dd+2*(xi-yi+3)锛?/姹侱鐨勫彸涓嬪儚绱?xi+2,yi-2),dd=(xi+2)*(xi+2)+(yi-2)*(yi-2)-R*R xi=xi+1锛?/p>yi=yi-1锛?/p>}}else if(dd 0)//D鍦ㄥ渾澶栵紱V鍦ㄥ渾澶栨垨鍦嗕笂锛涢€夋嫨D鎴朧锛沝d 0,dv=0,n=|dd|-|dv|=2*(dd-xi)-1锛?/p>n=2*(dd-xi)-1锛?/p>if(n=0)//鍙栧彸涓嬪儚绱燚(xi+1,yi-1)锛沶=0鏃跺彇{dd=dd+2*(xi-yi+3)锛?/姹侱鐨勫彸涓嬪儚绱?xi+2,yi-2),dd=(xi+2)*(xi+2)+(yi-2)*(yi-2)-R*R xi=xi+1锛?/p>yi=yi-1锛?/p>}else//鍙栦笅鍍忕礌V(xi,yi-1){dd=dd-2*yi+3锛?/姹俈鐨勫彸涓嬪儚绱?xi+1,yi-2)dd=(xi+1)*(xi+1)+(yi-2)*(yi-2)-R*R yi=yi-1锛?/p>}}else if(dd==0)//D鍦ㄥ渾涓?鍙朌(xi+1,yi-1){dd=dd+2*(xi-yi+3)锛?/姹侱鐨勫彸涓嬪儚绱?xi+2,yi-2),dd=(xi+2)*(xi+2)+(yi-2)*(yi-2)-R*R xi=xi+1锛?/p>yi=yi-1锛?/p>}}。

bresenham中点画圆原理介绍

1.中点Bresenham 算法的原理圆心在原点、半径为R 的圆方程的隐函数表达式为：圆将平面划分成三个区域：对于圆上的点，F(x ，y)＝0；对于圆外的点，F （x ，y ）＞0；对于圆内的点，F （x ，y ）＜0。

事实上，考虑到圆在第一象限内的对称性，本算法可以进一步简化。

用四条对称轴x ＝0，y ＝0， x ＝y,x ＝－y 把圆分成8等份。

只要绘制出第一象限内的1/8圆弧，根据对称性就可绘制出整圆，这称为八分法画圆算法。

假定第一象限内的任意点为P （x,y ），可以顺时针确定另外7个点：P （y ，x ）,P （y ，－x ）,P （x,－ y ）,P （－x ，－y ），P （－y ，－x ），P （－y ，x ），P （－x ，y ）。

2.构造中点偏差判别式从P （xi ，yi ）开始，为了进行下一像素点的选取，需将Pu 和Pd 的中点M （x i+1，y i-0.5）代入隐函数，构造中点偏差判别式：⑴当d<0时，下一步的中点坐标为：M （xi ＋2，yi －0.5）。

下一步中点偏差判别式为：⑵当d ≥0时，下一步的中点坐标为：M （xi ＋2，yi －1.5）。

),(222=-+=R y x y xF )5.0,1(),(-+==i i M M y x F y x F d ⎩⎨⎧≥<=+)0( 1-)0(1d y d y y i i i 2221)5.0()2()5.0,2(R y x y x F d i i i i i --++=-+=+3232)5.0()1(222++=++--++=i i i i i x d x R yx2221)5.1()2()5.1,2(R y x y x F d i i i i i --++=-+=+。

3种画圆算法的优劣分析

三种画圆算法的优劣分析学生姓名：杨晓瑜指导教师：张俊花摘要通过对Bresenham画圆法、正负画圆法、中点画圆法的算法分析，以及实现算法的程序运行速度和程序存储空间分析的比较。

对此3种算法进行综合的优劣分析。

关键词Bresenham 画圆法；正负画圆法；中点画圆法AbstractBy analysing the algorithms of Bresenham drawcirclc right-and-lose drawcircle and midpoint drawcircle，comparing their proceduze，run speeds and the small circle radiuses they display，the virtues and defects of the three algorithms are analysed synthetically．Key wordsBresenham drawcircle；right—and—lose drawcircle，o midpoint drawcircle1、引言图形通常是由点、线、面、体等几何元素和灰度、色彩、线型、线宽等非几何属性组成．直线与曲线是组成图形的基本元素．其生成算法的优劣对整个图形系统的效率是至关重要的，因为在产生一幅图形的过程中要反复多次调用这些算法程序．曲线的生成算法可分为线生成和像素级(或称点)生成两类．所谓线生成就是以小的直线段来逼近和代替实际曲线而显示之；而点生成则是逐个像素地选择距离实际曲线最近的点而显示之．圆是一种基本的、常用的元素，其生成算法也有很多，围绕这些算法人们进行了讨论和探索，其核心无非是为了节省时间和空间。

本文仅以Bresenham画圆、正负画圆、中点画圆3种方法讨论圆的点生成算法，并对此3种算法进行优劣分析．2、3种圆的点生成算法2.1 Bresenham画圆法(1)只要画出圆上的1／8弧AB(设圆心在原点，A点是y轴正向与圆弧的交点，B点在第一限的圆弧上)，根据圆的对称性，即可画出整个圆．(2)在AB弧上取任一点。

计算机图形学课程设计报告--直线和圆中点Bresenham算法

计算机图形学课程设计报告课题名称直线和圆中点Bresenham算法1、课程设计目的 (2)2、课程设计描述及要求 (2)3、系统开发环境 (2)4、直线的Bresenham算法原理 (2)4.1中点Bresenham算法 (2)4.2该进的Bresenham算法 (5)5、圆的Bresenham算法原理 (7)6、程序运行结果 (9)7、总结 (11)8、参考资料 (11)9、附录 (11)计算机图形学课程设计报告1.课程设计目的本学期系统学习了计算机图形学的概论原理，在学期期末按课程要求进行实验。

通过实验，进一步理解和掌握中点算法、Bresenham 算法和二阶差分算法，并掌握以上算法生成圆和直线等图形的基本过程，提高学生对计算机图形学的了解与运用技巧，同时通过此次课程设计提高动手实践能力与学习分析能力。

2.课程设计描述及要求 ●直线中点Bresenham 算法掌握中点Bresenham 算法绘制直线的原理，设计中点Bresenham 算法，编写Mbline()子函数，使用中点Bresenham 算法绘制斜率为0≦k ≦1的直线 ●圆中点Bresenham 算法掌握八分法中点Bresenham 算法绘制圆的原理，设计八分法绘制圆的中点Bresenham 算法，编写八分法绘制圆的CirclePoint(x,y)子函数，编写绘制整圆的Mbcircle()子函数，使用中点Bresenham 算法绘制圆心位于屏幕客户区中心的圆。

此次课程设计的课题为通过编程，实现圆和直线等基本图形的绘制。

要求用Bresenham 算法实现圆和直线等基本图形的绘制，并给出代码和结果截图。

3．系统开发环境开发工具：VC 6.0操作系统：Microsoft Windows XP 4. 直线的Bresenham 算法原理 4.1中点Bresenham 算法给定直线的两个端点00111P X Y P X Y （，）和（，），可得到直线方程F(x,y)=y-kx-b=0且这时直线将平面分为三个区域：对于直线上的点，F(x,y)=0；对于直线上方的点，F(x,y)>0；对于直线下方的点，F(x,y)<0。

画圆形（Bresenham算法）

画圆形（Bresenham算法）下⾯先简要介绍常⽤的画圆算法（Bresenham算法），然后再具体阐述笔者对该算法的改进。

⼀个圆，如果画出了圆上的某⼀点，那么可以利⽤对称性计算余下的七段圆弧：Plot(x，y)，Plot(y，x)，Plot(y，-x)，Plot(x，-y)，Plot(-x，-y)，Plot(-y，-x)，Plot(-y，x)，Plot(-x，y)。

1、Bresenham 画圆算法。

Bresenham算法的主要思想是：以坐标原点（0，0）为圆⼼的圆可以通过0度到45°的弧计算得到，即x从0增加到半径，然后利⽤对称性计算余下的七段圆弧。

当x从0增加到时，y从R递减到。

设圆的半径为R，则圆的⽅程为：f(x，y)＝(x+1)2+y2-R2＝0 (1)假设当前列（x=xi列）中最接近圆弧的像素已经取为P(xi，yi)，根据第⼆卦限1/8圆的⾛向，下⼀列（x=xi+1列）中最接近圆弧的像素只能在P的正右⽅点H(xi+1，yi)或右下⽅点L(xi+1，yi-1)中选择，如图1所⽰。

Bresenham画圆算法采⽤点T(x，y)到圆⼼的距离平⽅与半径平⽅之差D(T)作为选择标准，即D(T)=(x+1)2+y2-R2 (2)通过⽐较H、L两点各⾃对实圆弧上点的距离⼤⼩，即根据误差⼤⼩来选取，具有最⼩误差的点为绘制点。

根据公式(2)得：对H(xi+1，yi)点有：D(H)=(xi+1)2+yi2-R2；对L(xi+1，yi-1)点有：D(L)=(xi+1)2+(yi-1)2-R2；根据Bresenham画圆算法，则选择的标准是：如果|D(H)|<|D(L)|，那么下⼀点选取H(xi+1，yi)；如果|D(H)|>|D(L)|，那么下⼀点选取L(xi+1，yi-1)；如果|D(H)|=|D(L)|，那么下⼀点可以取L(xi+1，yi-1)，也可以选取H(xi+1，yi)，我们约定选取H(xi+1，yi)。

中点画圆和Bresehnm画圆算法

二、中点画圆算法
void huayuan(int x0,int y0,int r,int color) { int x,y,d; x=0;y=r;d=1.25-r; while(y>=x) { huadian(x0,y0,x,y,color); if(d<0) {d=d+2*x+3;x++;} else {d=d+2*(x-y)+5;x++;y--;} } } void main() { int r, c=RGB(255,0,0); initgraph(640,480); huayuan(200,200,100,c); if(getch()==1) exit; closegraph(); }
四、两种画圆算法的优劣
算法比较和启发：通过实际的程序运行比较分析，是中点画圆法速度快．就算法本身而言，该算法仍可在某些方面进行改进，如将其中的浮点运算改为整数运算等，执行速度将更快。生成直线和圆这类基础算法在编程时要被无数次的调用，可能每生成一帧画面就要被调用成百上千次，因此其执行速度是至关重要的．而这类基础算法的长度都很短，即使多用一些分支，多用一些变量和语句，一般来说只不过增加几十个语句．这样的空间增加与算法极重要的速度要求来比较是相对次要的因素，因此在开发图形学的基础算法时，如果有可能提高算法的速度，应不惜多占一些存储空间．
三、 Bresenham 画圆算法原理
算法原理： Bresenham画圆算法与Bresenham 直线算法一样，其基本的方法是利用判别变量来判断选择最近的像素点，判别变量的数值仅仅用一些加、减和移位运算就可以计算出来。为了简便起见，考虑一个圆心在坐标原点的圆，而且只计算八分圆周上的点，其余圆周上的点利用对称性就可得到。

Bresenham画圆算法

GIS专业实验报告（计算机图形学）实验2 使用Bresenham画圆算法，绘制一个圆一．实验目的及要求根据Bresenham画圆算法，掌握绘制圆的程序设计方法。

在绘制时应利用圆的对称性。

注意，不能使用语言库中的画圆函数。

二．理论基础1.Bresenham画圆算法：在Bresenham画线算法的基础之上，根据输入的圆心点坐标和半径，每次绘制出八分之一圆弧，进而逐步绘制出整个圆形。

三．算法设计与分析程序源码如下：#include <gl/gl.h>#include <gl/glu.h>#include <gl/glut.h>void bresenham_arc(int r){int x,y,d;x=0;y=r;d=1-r;while(x<=y){glBegin(GL_POINTS );glVertex2f(x,y);if(d<0)d+=2*x+3;else{d+=2*(x-y)+5; y--;}x++;glVertex2f(x,y);glVertex2f(x,-y);glVertex2f(-x,y);glVertex2f(-x,-y);glVertex2f(y,x);glVertex2f(y,-x);glVertex2f(-y,x);glVertex2f(-y,-x);glEnd();}}void myDisplay(void){glClear(GL_COLOR_BUFFER_BIT);glPushAttrib(GL_POINT_BIT); glBegin(GL_POINTS);glColor3f(255.0f,0.0f,0.0f);glVertex2f(0.0f,0.0f);glEnd();glPopAttrib();glPolygonMode(GL_FRONT_AND_BACK,GL_LINE); bresenham_arc(90); glFlush();}void Init(){ glClearColor(0.0,0.0,0.0,0.0);glShadeModel(GL_FLAT);}void Reshape(int w,int h){ glViewport(30,30,(GLsizei)w,(GLsizei)h);glMatrixMode(GL_PROJECTION);glLoadIdentity();gluOrtho2D(-100,(GLdouble)w,-100,(GLdouble)h);}int main(int argc ,char*argv[]){glutInit(&argc,argv);glutInitDisplayMode(GLUT_RGB|GLUT_SINGLE); glutInitWindowPosition(100,100);glutInitWindowSize(450,450);glutCreateWindow("Bresenham ?");Init();glutDisplayFunc(myDisplay);glutReshapeFunc(Reshape);glutMainLoop();return 0;}四.程序调试及运行结果的自我分析与自我评价图1 运行结果四．实验心得及建议。

计算机图形学--Bresenham完整算法-画直线、椭圆和圆

#include<windows.h>#include<gl/glut.h>#include"stdio.h"int m_PointNumber = 0; //动画时绘制点的数目int m_DrawMode = 1; //绘制模式 1 DDA算法画直线// 2 中点Bresenham算法画直线// 3 改进Bresenham算法画直线// 4 八分法绘制圆// 5 四分法绘制椭圆//绘制坐标线void DrawCordinateLine(void){int i = -250 ;//坐标线为黑色glColor3f(0.0f, 0.0f ,0.0f);glBegin(GL_LINES);for (i=-250;i<=250;i=i+10){glVertex2f((float)(i), -250.0f);glVertex2f((float)(i), 250.0f);glVertex2f(-250.0f, (float)(i));glVertex2f(250.0f, (float)(i));}glEnd();}//绘制一个点，这里用一个正方形表示一个点void putpixel(GLsizei x, GLsizei y){glRectf(10*x,10*y,10*x+10,10*y+10);}/////////////////////////////////////////////////////////////////////DDA画线算法 //// //// //// /////////////////////////////////////////////////////////////////////void DDACreateLine(GLsizei x0, GLsizei y0, GLsizei x1, GLsizei y1, GLsizei num) {//设置颜色glColor3f(1.0f,0.0f,0.0f);//对画线动画进行控制if(num == 1)printf("DDA画线算法：各点坐标\n");else if(num==0)return;//画线算法的实现GLsizei dx,dy,epsl,k;GLfloat x,y,xIncre,yIncre;dx = x1-x0;dy = y1-y0;x = x0;y = y0;if(abs(dx) > abs(dy)) epsl = abs(dx);else epsl = abs(dy);xIncre = (float)dx / epsl ;yIncre = (float)dy / epsl ;for(k = 0; k<=epsl; k++){putpixel((int)(x+0.5), (int)(y+0.5));if (k>=num-1) {printf("x=%f , y=%f,取整后 x=%d,y=%d\n", x, y, (int)(x+0.5),(int)(y+0.5));break;}x += xIncre;y += yIncre;if(x >= 25 || y >= 25) break;}}/////////////////////////////////////////////////////////////////////中点Bresenham算法画直线(0<=k<=1) //// //// //// /////////////////////////////////////////////////////////////////////void BresenhamLine(GLsizei x0, GLsizei y0, GLsizei x1, GLsizei y1, GLsizei num){glColor3f(1.0f,0.0f,0.0f);if(num == 1)printf("中点Bresenham算法画直线各点坐标及判别式的值\n");else if(num==0)return;//画线算法的实现GLsizei p=0;GLfloat UpIncre,DownIncre,x,y,d,k,dx,dy;if(x0>x1){x=x1;x1=x0;x0=x;y=y1;y1=y0;y0=y;}x=x0;y=y0;dx=x1-x0;dy=y1-y0;k=dy/dx;if(k>=0&&k<=1){d=dx-2*dy;UpIncre=2*dx-2*dy;DownIncre=-2*dy;while(x<=x1){putpixel(x,y);if (p>=num-1) {printf("x=%d,y=%d\n", x, y);break;}p++;x++;if(d<0){y++;d+=UpIncre;}else d+=DownIncre;}}if(k>1){d=dy-2*dx;UpIncre=2*dy-2*dx;DownIncre=-2*dx;while(y<=y1){putpixel(x,y);if (p>=num-1) {printf("x=%d,y=%d\n", x, y);break;}p++;y++;if(d<0){x++;d+=UpIncre;}else d+=DownIncre;}}if(k<0&&k>=-1){d=dx-2*dy;UpIncre=-2*dy;DownIncre=-2*dx-2*dy;while(x<=x1){putpixel(x,y);if (p>=num-1) {printf("x=%d,y=%d\n", x, y);break;}p++;x++;if(d>0){y--;d+=DownIncre;}else d+=UpIncre;}}if(k<-1){d=-dy-2*dx;UpIncre=-2*dx-2*dy;DownIncre=-2*dx;while(y>=y1){putpixel(x,y);if (p>=num-1) {printf("x=%d,y=%d\n", x, y);break;}p++;y--;if(d<0){x++;d+=UpIncre;}else d+=DownIncre;}}}/////////////////////////////////////////////////////////////////////改进的Bresenham算法画直线(0<=k<=1) //// //// x1,y1 终点坐标 //// /////////////////////////////////////////////////////////////////////void Bresenham2Line(GLsizei x0, GLsizei y0, GLsizei x1, GLsizei y1, GLsizei num) {glColor3f(1.0f,0.0f,0.0f);GLsizei x,y,dx,dy,e,k;if(num == 1)printf("改进的Bresenham算法画直线各点坐标及判别式的值\n");else if(num==0)return;//画线算法的实现GLsizei p=0;if(x0>x1){x=x1;x1=x0;x0=x;y=y1;y1=y0;y0=y;}dx=x1-x0;dy=y1-y0;k=dy/dx;if(k>=0&&k<=1){e=-dx;x=x0;y=y0;while(x<=x1){putpixel(x,y);if (p>=num-1) {printf("x=%d,y=%d\n", x, y);break;}p++;x++;e=e+2*dy;if(e>0){y++;e=e-2*dx;}}}if(k>1){e=-dy;x=x0;y=y0;while(y<=y1){putpixel(x,y);if (p>=num-1) {printf("x=%d,y=%d\n", x, y);break;}p++;y++;e=e+2*dx;if(e>0){x++;e=e-2*dy;}}}if(k<0&&k>=-1){e=-dx;x=x0;y=y0;while(x<=x1){putpixel(x,y);if (p>=num-1) {printf("x=%d,y=%d\n", x, y);break;}p++;x++;e=e+2*dy;if(e<0){y--;e=e+2*dx;}}}if(k<-1){e=-dy;x=x0;y=y0;while(y>=y1){putpixel(x,y);if (p>=num-1) {printf("x=%d,y=%d\n", x, y);break;}p++;y--;e=e-2*dx;if(e<0){x++;e=e-2*dy;}}}}///////////////////////////////////////////////////////////Bresenham算法画圆 //// //// //// ///////////////////////////////////////////////////////////void CirclePoint(GLsizei x,GLsizei y){ putpixel(x,y);putpixel(x,-y);putpixel(y,-x);putpixel(-y,-x);putpixel(-x,-y);putpixel(-x,y);putpixel(-y,x);putpixel(y,x);}void BresenhamCircle(GLsizei x, GLsizei y, GLsizei R, GLsizei num) {glColor3f(1.0f,0.0f,0.0f);GLsizei d;x=0;y=R;d=1-R;if(num == 1)printf("Bresenham算法画圆：各点坐标及判别式的值\n");else if(num==0)return;while(x<=y){CirclePoint(x,y);if (x>=num-1) {printf("x=%d,y=%d,d=%d\n", x, y,d);break;}if(d<0)d+=2*x+3;else{d+=2*(x-y)+5;y--;}x++;}}void Bresenham2Circle(GLsizei a,GLsizei b,GLsizei num){glColor3f(1.0f,0.0f,0.0f);if(num==1)printf("Bresenham算法画椭圆：各点坐标及判别式的值\n");else if(num==0)return;GLsizei x,y;float d1,d2;x=0;y=b;d1=b*b+a*a*(-b+0.5);putpixel(x,y); putpixel(-x,-y);putpixel(-x,y);putpixel(x,-y);while(b*b*(x+1)<a*a*(y-0.5)){if (x>=num-1) {printf("x=%d,y=%d,d1=%d\n", x, y,d1);break;}if(d1<=0){d1+=b*b*(2*x+3);x++;}else{d1+=b*b*(2*x+3)+a*a*(-2*y+2);x++;y--;}putpixel(x,y); putpixel(-x,-y);putpixel(-x,y);putpixel(x,-y);}//while上半部分d2=b*b*(x+0.5)*(x+0.5)+a*a*(y-1)*(y-1)-a*a*b*b;while(y>0){if (x>=num-1) {printf("x=%d,y=%d,d2=%d\n", x, y,d2);break;}if(d2<=0){d2+=b*b*(2*x+2)+a*a*(-2*y+3);x++;y--;}else{d2+=a*a*(-2*y+3);y--;}putpixel(x,y); putpixel(-x,-y);putpixel(-x,y);putpixel(x,-y);}}//初始化窗口void Initial(void){// 设置窗口颜色为蓝色glClearColor(0.0f, 0.0f, 1.0f, 1.0f);}// 窗口大小改变时调用的登记函数void ChangeSize(GLsizei w, GLsizei h){if(h == 0) h = 1;// 设置视区尺寸glViewport(0,0, w, h);// 重置坐标系统glMatrixMode(GL_PROJECTION);glLoadIdentity();// 建立修剪空间的范围if (w <= h)glOrtho (-250.0f, 250.0f, -250.0f, 250.0f*h/w, 1.0, -1.0);elseglOrtho (-250.0f, 250.0f*w/h, -250.0f, 250.0f, 1.0, -1.0);}// 在窗口中绘制图形void ReDraw(void){//用当前背景色填充窗口glClear(GL_COLOR_BUFFER_BIT);//画出坐标线DrawCordinateLine();switch(m_DrawMode){case 1:DDACreateLine(0,0,20,15,m_PointNumber);break;case 2:BresenhamLine(0,0,-20,15,m_PointNumber);break;case 3:Bresenham2Line(1,1,8,6,m_PointNumber);break;case 4:BresenhamCircle(0,0,20,m_PointNumber);break;case 5:Bresenham2Circle(10,8,m_PointNumber);default:break;}glFlush();}//设置时间回调函数void TimerFunc(int value){if(m_PointNumber == 0)value = 1;m_PointNumber = value;glutPostRedisplay();glutTimerFunc(500, TimerFunc, value+1);}//设置键盘回调函数void Keyboard(unsigned char key, int x, int y) {if (key == '1') m_DrawMode = 1;if (key == '2') m_DrawMode = 2;if (key == '3') m_DrawMode = 3;if (key == '4') m_DrawMode = 4;if (key == '5') m_DrawMode = 5;m_PointNumber = 0;glutPostRedisplay();}//void main(void)int main(int argc, char* argv[]){glutInit(&argc, argv);//初始化GLUT库OpenGL窗口的显示模式glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);glutInitWindowSize(600,600);glutInitWindowPosition(100,100);glutCreateWindow("基本图元绘制程序);glutDisplayFunc(ReDraw);glutReshapeFunc(ChangeSize);glutKeyboardFunc(Keyboard);//键盘响应回调函数glutTimerFunc(500, TimerFunc, 1);// 窗口初始化Initial();glutMainLoop(); //启动事件处理循环return 0;}。

Bresenham算法画圆

bresenham画圆算法bresenham画圆算法中点画圆算法在一个方向上取单位间隔，在另一个方向的取值由两种可能取值的中点离圆的远近而定。

实际处理中，用决策变量的符号来确定象素点的选择，因此算法效率较高。

一、中点画圆算法描述设要显示圆的圆心在原点(0，0)，半径为R，起点在(0，R)处，终点在(，)处，顺时针生成八分之一圆，利用对称性扫描转换全部圆。

为了应用中点画圆法，我们定义一个圆函数F(x，y)=x2+y2-R2 (2－19)任何点(x，y)的相对位置可由圆函数的符号来检测：F(x，y) <0点(x，y)位于数学圆内=0点(x，y)位于数学圆上>0点(x，y)位于数学圆外(2－20)如下图所示，图中有两条圆弧A和B，假定当前取点为Pi(xi，yi)，如果顺时针生成圆，那么下一点只能取正右方的点E(xi+1，yi)或右下方的点SE(xi+1，yi-1)两者之一。

中点画线算法假设M是E和SE的中点，即，则：1、当F(M)<0时，M在圆内(圆弧A)，这说明点E距离圆更近，应取点E作为下一象素点；2、当F(M)>0时，M在圆外(圆弧B)，表明SE点离圆更近，应取SE点；3、当F(M)=0时，在E点与SE点之中随便取一个即可，我们约定取SE点。

二、中点画圆算法思想因此，我们用中点M的圆函数作为决策变量d i，同时用增量法来迭代计算下一个中点M的决策变量d i+1。

(2－21)下面分两种情况来讨论在迭代计算中决策变量d i+1的推导。

1、见图（a），若d i <0，则选择E点，接着下一个中点就是，这时新的决策变量为：(2－22)（a）(di<0) 中点画线算法式(2－22)减去(2－21)得：d i+1=d i+2x i+3(2－23)2、见图（b），若di≥0，则选择SE点，接着下一个中点就是，这时新的决策变量为：(2－24)（b）(d i ≥0) 中点画线算法式(2－24)减去(2－21)得：d i+1=d i+2(x i-y i)+5(2－25)我们利用递推迭代计算这八分之一圆弧上的每个点，每次迭代需要两步处理：（1）用前一次迭代算出的决策变量的符号来决定本次选择的点。

Bresenham画圆算法与中点画圆法

Bresenham画圆算法与中点画圆法Bresenham画圆算法不失⼀般性，假设圆的圆⼼位于坐标原点（如果圆⼼不在原点，可以通过坐标平移使其与原点重合），半径为R。

以原点为圆⼼的圆C有四条对称轴：x = 0, y = 0, x = y和x = -y。

若已知圆弧上⼀点P1＝C（x, y），利⽤其对称性便可以得到关于四条对称轴的其它7个点，即： P2＝C（x,－y）， P3＝C（－x, y）， P4＝C（－x,－y）， P5＝C（y，x）， P6＝C（－y，x）， P7＝C（y，－x）， P8＝C（－y，－x）。

这种性质称为⼋对称性。

因此，只要扫描转换⼋分之⼀圆弧，就可以通过圆弧的⼋对称性得到整个圆。

【Bresenham算法】简单图形的扫描转换常⽤算法是Bresenham算法。

它的思想在于⽤误差量来衡量点选取的逼近程度。

其过程如下：以平⾯⼆维图形的扫描转换为例，设要画的图形⽅程为F(x, y)=0，要画的区域为[x0, x]（不妨设x⽅向是最⼤位移⽅向，即△x > △y），则Ｆ(x,y) 也是⼀个误差度量函数，我们拿离散的点值代⼊如果⼤于0则正向偏离，否则负向偏离，等于0的情况⽐较少，它表⽰的是不偏离即恰好与真实点重合。

既然x是最⼤位移⽅向，那每次对x⾃增1，相应的y可以选择不增或增1(或-1，具体问题具体分析)，选择的⽅法就是d = F(x + 1, y ± 0.5)的正负情况进⾏判断从⽽选择y的值。

实际情况中还要考虑到浮点数的计算问题，因为基本的图形扫描转换算法最好能够硬件实现，所以摆脱浮点数是最好的，常⽤的⽅法是对d 进⾏递推，⽽不是直接由Ｆ(x,y)给出(直接给出速度会慢)。

【圆的扫描转换算法】以画圆为例，给出圆⼼的坐标(0, 0)和半径Ｒ，求圆图像的最佳逼近点。

圆是中⼼对称的特殊图形，所以可以将圆⼋等分，则只须对⼋分之⼀圆孤求解，其它圆孤可以由对称变换得到，我们求的⼋分之⼀圆孤为(0, R) -(R√2,R√2)，可知最⼤位移⽅向是x⽅向，x0 = 0, y0 = R，每次对x⾃增，然后判断y是否减1，直到x >= y为⽌(从点(0, R)到圆的⼋分之⼀处就有这种情况)。