计算机图形学-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的实现部分。

bresenham圆生成算法

bresenham圆生成算法Bresenham圆生成算法是一种经典的计算机图形学算法，用于在计算机屏幕上绘制圆形。

该算法是由美国计算机科学家Jack E. Bresenham于1965年发明的。

这个算法非常简单，但是它却非常有效，因为它只需要使用整数运算。

Bresenham圆生成算法的基本思想是使用一个叫做“决策参数”的变量来决定下一个像素点的位置。

该变量根据当前像素点到圆心的距离和半径之间的差异进行调整。

如果该差异小于0，则移动到右上方的像素点；否则，移动到右上方和正上方之间的像素点。

具体来说，Bresenham圆生成算法可以通过以下步骤来实现：1. 输入圆心坐标和半径。

2. 初始化x和y坐标为0，并计算出初始决策参数d=3-2r。

3. 在每个步骤中，检查当前像素点是否在圆内。

如果是，则将该像素点绘制出来；否则，不绘制。

4. 计算下一个像素点的位置。

如果d小于0，则移动到右上方；否则，移动到右上方和正上方之间。

5. 更新决策参数d。

Bresenham圆生成算法的优点是它非常快速和有效。

它只需要使用整数运算，因此可以在计算机上非常快速地执行。

此外，该算法还可以轻松地扩展到三维空间中的球体和其他形状。

尽管Bresenham圆生成算法已经有几十年的历史了，但它仍然是计算机图形学中最常用的算法之一。

它被广泛应用于游戏开发、计算机辅助设计、虚拟现实等领域。

此外，该算法还被用于许多其他领域，如数字信号处理和图像处理。

总之，Bresenham圆生成算法是一种简单而有效的计算机图形学算法。

它可以快速地绘制出圆形，并且可以轻松地扩展到其他形状。

尽管这个算法已经有几十年的历史了，但它仍然是计算机图形学中最常用的算法之一，并且在许多其他领域也得到了广泛应用。

图形学实验报告-Bresenham算法画圆

计算机图形学实验报告姓名：张晓波学号：090081322010 年10月实验1 实用OpenGL 绘制二维图形实验目的1.进一步了解OpenGL程序的框架。

2.掌握利用OpenGL绘制简单视图的方法。

3.利用OpenGL中的Bresenham算法直接利用像素点绘制图形。

实验要求1.明确实验目的，按实验内容及基本步骤完成实验。

2.在实验过程中，结合思考与探究中的问题，通过实验进行理解。

3.理解并掌握本实验的内容。

实验内容及基本步骤1.绘制圆形分析：利用Bresenham算法，可以在自定了第一个点之后算出下一个点的位置，由于要保证斜率小于1，而且只在一个象限内绘制，所以找出的只是1/8圆弧，因此在找点的时候，利用对称性，同时找到8个点，进行绘制。

void Circle(int r){int x=0,y=r; //初始点int d=0; //声明决策变量d=3-2*r;while(x<=y){CircleVertex(x,y);//画圆上点FillCircle(x,y); //选取对应点，用矩形填充if(d<0)d=d+4*x+6;else{d=d+4*(x-y)+10;y --;}x++;}}void CircleVertex(int x, int y){glBegin(GL_POINTS);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();}试验结果如下：2.填充圆形分析：在一次寻找确定出8个点之后，可以将其上下两端的点作为一组，左右两端的点作为一组分别绘制实心四边形。

画圆形（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)。

圆绘制算法实验报告

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

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

二、实验目的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. 编写代码实现两种算法，并进行测试。

§3.2圆、圆弧的生成—Bresenham算法

§3.2圆的生成——Bresenham算法条件：给定圆心(x c,y c)和半径R约定：只考虑圆心在原点，半径为整数R的圆x2+y2.=R2。

对于圆心不在原点的圆，可先通过平移转换，化为圆心在原点的圆，再进行扫描转换，把所得到的像素集合加上一个位移量，就可以把目标圆光栅化。

在众多圆的生成算法，如逐点比较法、角度DDA法、Bresenham算法中，Bresenham画圆法是一种最简单有效的的方法。

首先注意到只要生成一个八分圆，那么，圆的其它部分就可以通过一系列的对成变换得到。

12345678由算法生成y=x第一八分圆关于y=x对称变换第一四分圆关于x=0对称变换上半圆关于y=0对称变换如果以点x=0，y=R为起点按顺时针方向生成圆，则在第一象限内y是x 的单调递减函数。

要在这三个像素中选择一个使其与理想圆的距离的平方达到最小，即下列数值中的最小者。

R(0,R)(R,0)xy这样，从圆上任一点出发，按顺时针方向生成圆时，为了最佳逼近该圆，对于下一像素的取法只有三种可能的选择，即正右方像素、正下方像素和右下角像素，分别记作：m H、m V、m D。

从圆心到右下角像素(x i+1,y i-1)的距离平方m D与圆心到圆上点的距离平方R2之差等于：Δi=(x i+1)2+(y i-1)2-R2如果Δi<0,那么右下角像素(x i+1,y i-1)在该圆内(图中①、②)，显然这时只能取像素(x i+1,y i)，即m H；或像素(x i+1,y i-1)，即m D。

Bresenham画圆算法

计算机图形学编程实习一之Bresenham画圆算法
实习报告
学号2014301750057 姓名李帅旗一、实习目的
1.熟悉Visual C++开发环境，能够自己搭建OpenGL图形开发框架，并用C/C+语言实现Bresenham画圆算法。

2.初步了解图元生成算法的实现过程、验证方法，通过实现Bresenham画圆算法，理解图元的参数表示法、光栅扫描、显示输出的概念。

二、实习内容与过程
1. 熟悉Visual C++开发环境；
2.了解Win32控制台开发框架；
3.完成Bresenham画圆算法程序的输入、编译和运行；
4.掌握程序调试的方法。

三、遇到的问题
Bresenman画圆算法和中点画圆算法非常相似，参考着老师提供的中点画圆法的代码，在理解其要义的基础上，再写Bresenman画圆的代码就很简单了。

唯一的疑难点是教材上的Bresenman算法的推导过程有些问题，它省略了重要的步骤，在老师的提示下方才理解明白。

四、实习总结
本次实习还是比较简单的，重点是理解Bresenman画圆算法的过程，在此基础上才可能写出正确的代码。

易懂的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中点画圆原理介绍

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 --++=-+=+。

Bresenham画线画圆算法

Bresenham画线算法以前看到Bresenham画线算法，直接拿来用，没有去推导它,近日,参考一些资料,特整理其算法推导过程如下。

各位大虾如果知道其细节，赶紧闪过，不用浪费时间了。

基本上Bresenham画线算法的思路如下:// 假设该线段位于第一象限内且斜率大于0小于1,设起点为(x1,y1),终点为(x2,y2).// 根据对称性,可推导至全象限内的线段.1.画起点(x1,y1).2.准备画下个点。

x坐标增1，判断如果达到终点，则完成。

否则，由图中可知,下个要画的点要么为当前点的右邻接点,要么是当前点的右上邻接点.2.1.如果线段ax+by+c=0与x=x1+1的交点的y坐标大于M点的y坐标的话,下个点为U(x1+1,y1+1)2.2.否则,下个点为B(x1+1,y1)3.画点(U或者B).4.跳回第2步.5.结束.这里需要细化的是怎么判断下个要画的点为当前点的右邻接点还是当前点的右上邻接点.设线段方程：ax+by+c=0(x1<x<x2,y1<y<y2)令dx=x2-x1,dy=y2-y1则：斜率-a/b = dy/dx.从第一个点开始，我们有F(x,1,y1) = a*x1+b*y1+c=0下面求线段ax+by+c=0与x=x1+1的交点:由a*(x1+1)+b*y+c = 0, 求出交点坐标y=(-c-a(x1+1))/b所以交点与M的y坐标差值Sub1 = (-c-a(x1+1))/b - (y1+0.5) = -a/b-0.5，即Sub1的处始值为-a/b-0.5。

则可得条件当 Sub1 = -a/b-0.5>0时候,即下个点为U.反之,下个点为B.代入a/b,则Sub1 = dy/dx-0.5.因为是个循环中都要判断Sub,所以得求出循环下的Sub表达式,我们可以求出Sub的差值的表达式.下面求x=x1+2时的Sub，即Sub21.如果下下个点是下个点的右上邻接点，则Sub2 = (-c-a(x1+2))/b - (y1+1.5) = -2a/b - 1.5故Sub差值Dsub = Sub2 - Sub1 = -2a/b - 1.5 - (-a/b-0.5) = -a/b - 1.代入a/b得Dsub = dy/dx -1;2.如果下下个点是下个点的右邻接点，Sub2 = (-c-a(x1+2))/b - (y1+0.5) = -2a/b - 0.5故Sub差值Dsub = Sub2 - Sub1 = -2a/b - 0.5 - (-a/b-0.5) = -a/b. 代入a/b得Dsub = dy/dx;于是，我们有了Sub的处始值Sub1 = -a/b-0.5 = dy/dx-0.5,又有了Sub的差值的表达式Dsub = dy/dx -1 （当Sub1 > 0）或 dy/dx（当Sub1 < 0）.细化工作完成。

生成圆的bresenham算法原理描述详细

生成圆的bresenham算法原理描述详细Bresenham算法是计算机图形学中非常重要的算法之一，可以生成各种形状的图像。

其中，生成圆形图像的Bresenham算法也是应用比较广泛的算法之一。

本文将详细描述生成圆的Bresenham算法原理。

1. 圆的数学表示圆是一个几何图形，其数学表示为：x² + y² = r²，其中，x、y是圆上点的坐标，r是圆的半径。

因此，生成圆的Bresenham算法需要计算出符合该数学表示的所有点的坐标。

2. Bresenham算法的核心思想Bresenham算法的核心思想是利用对称性和递推式来快速计算出每个点的坐标。

对于圆而言，其有四分之一的区域可以通过对称性计算出来，而另外四分之三的区域可以通过递推式来得出。

3. 圆的对称性对于圆而言，其具有对称性，即当坐标为（x,y）在圆上时，也必然存在（y,x）、（y,-x）、（x,-y）、(-x,-y)、(-y,-x)、(-y,x)、(-x,y)在圆上的点，也就是说，直接通过圆的对称性可以得到大约四分之一的在圆上的点。

4. 圆的递推式对于圆的另外四分之三的部分，我们可以使用递推式来获得。

根据圆的坐标表示式x² + y² = r²，我们可以得到下届式：x² + y² - r² = 0根据这个方程，可以计算出下一个点的坐标为：x + 1, y 或 x + 1, y - 1如果采用当前点（x,y）的对称点来计算，比如（y,x），那么坐标可以改成：y + 1, x 或 y + 1, x - 1通过这种方式，就可以逐个计算出每个点的坐标了。

5. 算法步骤生成圆的Bresenham算法的步骤如下：1）确定圆的中心点的坐标和半径；2）以圆心为原点建立坐标系，以x轴为基准线向右，y轴向上；3）通过圆的对称性计算出直径上的点的坐标；4）使用递推式计算出剩余的坐标；5）根据得到的坐标渲染圆的边缘。

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 运行结果四．实验心得及建议。

计算机图形学实验报告模板圆的扫描转换

北京联合大学应用文理学院实验报告课程名称计算机图形学实验（实训）名称圆的扫描转换班级信息与计算科学2009级姓名学号同组者实验（实训）日期完成日期本实验（实训）所用学时统计预习实验（实训）报告总计评阅意见：成绩北京联合大学应用文理学院实验报告一、实验目的1、掌握用中点画圆法进行圆的扫描转换方法；2、掌握用Bresenham画圆法进行圆的扫描转换方法；3、理解中点画圆法与Bresenham画圆法的区别；二、算法原理介绍1、中点画圆算法假设x坐标为xp的各像素点中，与该圆弧最近者已确定，为P（xp,yp），那么，下一个与圆弧最近的像素只能是正右方的P1(xp+1,yp)，或右下方的P2（xp+1,yp-1）两者之一。

令M为P1和P2的中点，易知M的坐标为（xp+1,yp-0.5）。

显然，若M在圆内，则P1离圆弧近，应取为下一个像素；否则应取P2。

判别式d：d = F(M)=F(xp+1,yp-0.5)=(xp+1)^2+(yp-0.5)^2-R^2d的初始值为：d0 = F(1,R-0.5)=1+(R-0.5)^2-R^2=1.25-R在d≥0的情况下，取右下方像素P2，d = F(xp+2,yp-1.5)=(xp+2)^2+(yp-1.5)^2-R^2=d+2(xp-yp)+5在d<0的情况下，取正右方像素P1，d = F(xp+2,yp-0.5)=(xp+2)^2+(yp-0.5)^2-R^2=d+2xp+32、 Bresenham画圆算法假设生成圆心在坐标原点，半径为r，从x=0到x=y的1/8圆弧。

xi+1=xi +1相应的y则在两种可能中选择：y=yi，或者y=yi-1选择的原则是考察理想的y值是靠近yi还是靠近yi-1判别式：d i+1=2(xi+1)2+yi2+(yi-1)2-2r2判断式d的初始值为：d0= 3-2r。

如果d i+1>=0，则y=yi-1，di+2 =d i+1 + 4(xi- yi)+10如果d i+1<0，则y=yi，d i+2 =d i+1+ 4x i+6三、程序源代码1、中点画圆算法#include"graphics.h"#include"math.h"#include"conio.h"main(){void MidPointCircle(int,int);/*定义主函数变量，MidPointCircle中点画圆算法函数*/int gdriver,gmode; /*gdriver和gmode分别表示图形驱动器和模式*/gdriver=DETECT; /*DETECT是自动选择显示模式*/initgraph(&gdriver,&gmode,"c:\\tc3.0\\BGI");/*图形驱动文件的路径*/ MidPointCircle(200,YELLOW); /*定义圆的半径和颜色*/getch();/*getch();会等待你按下任意键，再继续执行下面的语句*/closegraph();/*关闭图形系统*/return(0); /*返回值为0*/}void MidPointCircle(int r,int color) /*定义函数变量半径和颜色*/{ int x,y;float d; /*float类型中小数位数为7位，即可精确到小数点后7位 */x=0; y=r; d=1.25-r;while(x<y) /*满足条件x<y时进入循环，不满足跳出*/{ if(d<0){d+=2*x+3; x++;}else { d+=2*(x-y)+5; x++; y--;}putpixel(x+200,y+200,color); putpixel(y+200,x+200,color);putpixel(200-x,y+200,color); putpixel(y+200,200-x,color);putpixel(200+x,200-y,color); putpixel(200-y,x+200,color);putpixel(200-x,200-y,color); putpixel(200-y,200-x,color);/* putpixel 在指定位置画一像素*/}}2、 Bresenham画圆算法#include"graphics.h"#include"math.h"#include"conio.h"main(){void Bresenham_Circle(int,int);/* Bresenham_Circle为 Bresenham画圆算法函数*/int gdriver,gmode;gdriver=DETECT;initgraph(&gdriver,&gmode,"c:\\tc3.0\\BGI");Bresenham_Circle(200,YELLOW); /*定义圆的半径和颜色*/getch();closegraph();return(0);}void Bresenham_Circle(int R,int color){ int x,y,delta,delta1,delta2,direction;x=0;y=R;delta=2*(1-R);while(y>=0) /*满足条件y>=0时进入循环，不满足跳出*/{putpixel(x+200,y+200,color); putpixel(y+200,x+200,color);putpixel(200-x,y+200,color); putpixel(y+200,200-x,color);putpixel(200+x,200-y,color); putpixel(200-y,x+200,color);putpixel(200-x,200-y,color); putpixel(200-y,200-x,color);if(delta<0){delta1=2*(delta+y)-1;if(delta1<=0)direction=1;else direction=2;}else if(delta>0){delta2=2*(delta-x)-1;if(delta2<=0) direction=2;else direction=3;}elsedirection=2;switch (direction)/*switch语句，即“切换”语句；case即“情况*/ {case 1:x++;delta+=2*x+1;break;/*执行 break 语句会退出当前循环或语句*/case 2:x++;y--;delta+=2*(x-y+1);break;case 3: y--;delta+=(-2*y+1);break;}}}四、实验结果图1中点画圆算法生成的圆半径r=200，颜色为黄色图2 Bresenham画圆算法生成的圆半径R=200，颜色为黄色五、总结与体会通过运用 C 语言环境下的图像显示设置，本次实验我学会了用中点画圆法、Bresenham 画圆法进行圆的扫描转换，更加深刻的理解了中点画圆法、Bresenham 画圆法进行圆的扫描转换的生成原理。

计算机图形学--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;}。

计算机图形学-画椭圆和圆

y--;
}
x++;
glVertex2i(x +xc, y +yc);
glVertex2i(y +xc, x +yc);
glVertex2i(y +xc, -x +yc);
glVertex2i(x +xc, -y +yc);
glVertex2i(-x +xc, -y +yc);
glVertex2i(-y +xc, -x +yc);
绘图过程如下：
.输入直线的两端点P0(X0,Y0)和P1(X1,Y1)。
.计算初始值△x, △y,d=△x-2△y,x=X0,y=Y0.
.绘制点(x,y)。判断d的符号，若d<0，则(x,y)更新为(x+1,y+1),d更新为d+2△x-2△y;否则(x,y)更新为(x+1，y)，d更新为△y。
.当直线没有画完时，重复步骤 ,否则结束。
intx = 0;
inty =b;
Ellipsepot(x0,y0, x, y);
// 1
while(sqb*(x + 1) < sqa*(y - 0.5))
{
if(d < 0)
{
d += sqb*(2 * x + 3);
}
else
{
d += (sqb*(2 * x + 3) + sqa*((-2)*y + 2));
glVertex2i(198,2);
glEnd();
glFlush(); //清空OpenGL命令缓冲区，执行OpenGL程序

计算机图形学画圆实验报告

洛阳理工学院实验报告用纸（2）画理想圆流程图如图-1：图-1：画理想圆流程图（3）中点画圆法图-2 中点画圆法当前象素与下一象素的候选者数，将乘法运算改成加法运算，即仅用整数实现中点画圆法。

（4）Bresenham画圆法Bresenham画线法与中点画线法相似，，它通过每列象素中确定与理想直线最近的象素来进行直线的扫描的转换的。

通过各行，各列的象素中心构造一组虚拟网格线的交点，然后确定该列象素中与此交点最近的的象素。

该算法的巧妙之处在于可以采用增量计算，使得对于每一列，只要检查一个误差项的符号，就可以确定该列的所求对象。

假设x列的象素已确定，其行下标为y。

那么下一个象素的列坐标必为x+1。

而行坐标要么不变，要么递增1。

是否递增1取决于如图所示的误差项d的值。

因为直线的起始点在象素中心，所以误差项d的初始值为0。

X下标每增加1，d的值相应递增直线的斜率值，即d=d+k（k=y/x为直线斜率）。

一旦d>=1时，就把它减去，这样保证d始终在0、1之间。

当d>0.5时，直线与x+1垂直网络线交点最接近于当前象素（x,y）的右上方象素(x+1,y+1)；而当d<0.5时，更接近于象素（x+1，y），当d=0。

5时，与上述二象素一样接近，约定取（x+1，y+1）。

令e=d-0。

5。

则当e>=0时，下一象素的y下标增加1，而当e〈0时，下一象素的y下标不增。

E的初始值为-0.5.（二）实验设计画填充点流程图，如图-3：图-3：圆的像素填充过程NS图画理想圆，记录圆心坐标，计算半径大小，并记录是否开始填充否是初始化计数器、标志变量，设置最大计数值调用Bresenha m画圆算法否是填充标记是否为真（While）计数变量小于最大计数值循环变量temp + 1填充计算出来的temp个坐标点计算需要填充坐标数组的前temp个坐标附录图-4 Bresenham画圆算法最终效果图。