Bresenham算法画直线
生成直线的bresenham算法
生成直线的bresenham算法
Bresenham算法是由Jack E. Bresenham在1962年提出的一种用于生成直线图形的算法。
它可以根据两个点的坐标来计算出中间所有点的位置，即通过这两个端点可以确定出整条直线的像素点。
Bresenham算法的核心思想是，沿着已知的两个点之间的点，从起点开始向终点靠近，沿途计算斜率的误差，依据误差大小判断是选择水平方向或者垂直方向上的点，从而确定最终的直线图形。
具体步骤如下：
（1）根据两个点坐标计算出斜率dx和dy；
（2）令x0=x1, y0=y1；
（3）计算当前点处斜率误差p，公式为：p=2dy-dx；
（4）根据p的大小，决定下一步是沿水平方向还是垂直方向：
（a）p>0时，下一步沿垂直方向前进，即y++；
（b）p<=0时，下一步沿水平方向前进，即x++；
（5）重复步骤3、4，直到到达终点。
【实验目标】 通过实验,进一步理解和掌握生成直线的bresenham算法。 【实验要求】 -回复
【实验目标】通过实验,进一步理解和掌握生成直线的bresenham算法。
【实验要求】-回复【实验目标】通过实验，进一步理解和掌握生成直线的Bresenham算法。
【实验要求】一步一步回答以下问题，写一篇1500-2000字的文章。
一、什么是生成直线的算法？生成直线的算法是用来在计算机图形学中绘制直线的数学方法。
直线是图形学中最基本的图元之一，绘制直线是计算机图形学中最基本的操作之一。
二、为什么需要Bresenham算法？在计算机图形学中，绘制直线一般使用笔直线算法（Digital Differential Analyzer或称DDA算法）来实现。
然而，DDA算法存在一个问题：每个点坐标需要进行浮点数运算，这会导致计算速度较低。
为了解决这个问题，Bresenham算法被提出。
Bresenham算法使用整数运算，避免了浮点数运算，从而大大提高了计算速度。
三、Bresenham算法的原理是什么？Bresenham算法的原理是通过计算出直线上各个点的位置来绘制直线。
它使用了整数运算和不断逼近的方法。
具体来说，给定直线的起点和终点坐标，Bresenham算法通过每次移动一个单位点来画出直线。
对于直线的每个点，算法会计算出两个候选点，并根据这两个候选点与直线的实际位置的距离来选择下一个点。
四、Bresenham算法的步骤是什么？1. 输入直线的起点（x0, y0）和终点（x1, y1）；2. 计算直线在x方向上的长度dx和在y方向上的长度dy；3. 计算斜率的绝对值与1/2的差值，记为pk；4. 设置初始的坐标值（x, y）为起点坐标（x0, y0）；5. 循环dx次，每次循环中：- 绘制当前坐标（x, y）；- 如果pk < 0，选择右侧点为下一个点，pk更新为pk + dy；- 如果pk >= 0，选择右上侧点为下一个点，pk更新为pk + dy - dx；- x坐标递增，y坐标不变；6. 循环结束。
bresenham算法实现直线段插值函数
在计算机图形学中，Bresenham算法是一种用于在离散坐标系上绘制直线段的算法。
它是一种高效的算法，能够准确地计算出直线段上的所有像素点，使得在计算机屏幕上显示出直线段来。
Bresenham算法的实现可以帮助我们更好地理解画线原理，并且在计算机视觉、图像处理等领域有着广泛的应用。
1. Bresenham算法的原理Bresenham算法是通过计算直线段的斜率来确定每个像素点的位置。
具体来说，它利用了直线的对称性和整数的特性，通过计算像素点与真实直线的距离来判断下一个像素点应该取的位置。
这样可以避免使用浮点运算，使得算法更加高效。
2. 实现Bresenham算法的关键步骤在实现Bresenham算法时，需要考虑以下几个关键步骤：- 初始化各个变量，包括起始点(x0, y0)和终点(x1, y1)，以及斜率的计算值，例如dx和dy。
- 根据斜率的正负情况，确定每个像素点的增量步长，以便在遍历过程中准确计算出像素点来。
- 利用对称性和整数特性，进行迭代计算，逐步确定直线段上的所有像素点的位置。
3. Bresenham算法的优缺点Bresenham算法作为一种离散直线段插值算法，具有以下几个优点：- 算法简单高效，节省存储空间和运算时间。
- 可以高效地解决像素化显示问题，避免了浮点运算的复杂性。
- 在硬件上实现时，只需少量的资源就能完成计算，适合嵌入式系统和图形处理器。
然而，Bresenham算法也存在一些缺点，比如对于曲线的绘制就不太奏效，因为它是基于直线段的形式来处理的。
4. 我对Bresenham算法的理解在我看来，Bresenham算法是一种经典的离散直线段插值算法，其思想简洁高效。
它通过逐步迭代的方式，计算出直线段上的所有像素点位置，使得在计算机屏幕上显示出直线段来更加精确。
这种算法的实现可以帮助我们更好地理解画线的原理，对于理解计算机图形学和计算机视觉都有着重要的意义。
总结起来，Bresenham算法作为一种高效的离散直线段插值算法，具有着重要的理论和实际价值。
python语言实现的bresenham算法
python语言实现的bresenham算法Bresenham算法是一种用于绘制直线的经典算法，它能够有效地计算出直线上的像素点，减少了计算与绘制的开销。
本文将逐步介绍如何使用Python语言实现Bresenham算法。
第一步，我们需了解Bresenham算法的原理及其背后的数学思想。
该算法基于直线的一般方程y = mx + b，其中m为斜率，b为y轴截距。
Bresenham算法的核心在于决策，即在每一个像素点处，选择最合适的下一个像素点。
其思想是，在给定的直线段中，比较由当前像素点到两个候选像素点的斜率值，从而决定下一步绘制的方向。
利用整数计算，避免了实数运算，提高了运行效率。
接下来，我们将使用Python语言实现Bresenham算法。
首先，需要引入必要的图形库，如matplotlib或者pygame。
这些库能够帮助我们在屏幕上绘制图形。
以matplotlib为例，我们首先需要创建一个画布，并在画布上绘制直线。
代码如下：pythonimport matplotlib.pyplot as plt# 创建画布fig, ax = plt.subplots()# 绘制直线def bresenham(x1, y1, x2, y2): dx = abs(x2 - x1)dy = abs(y2 - y1)if x1 < x2:sx = 1else:sx = -1if y1 < y2:sy = 1else:sy = -1err = dx - dywhile True:ax.plot(x1, y1, 'bo')if x1 == x2 and y1 == y2:breake2 = 2 * errif e2 > -dy:err = err - dyx1 = x1 + sxif e2 < dx:err = err + dxy1 = y1 + sy# 调用函数绘制直线bresenham(1, 1, 10, 8)# 显示画布plt.show()在上述代码中，我们首先创建了一个画布，并用`fig, ax = plt.subplots()`语句生成对应的`figure`和`axes`。
DDA、Bresenham、Midpoint算法画直线报告1
课程名称计算机图形学实验名称DDA、Bresenham、Midpoint算法画直线一、实验目的及要求（1）理解窗口到视区的变换（2）理解MFC创建工程实现动画的原理(3) 学习MFC类库的概念与结构（4）学习使用VC++编写Win32应用的方法（单文档，多文档，对话框）（5）学习使用MFC的图形编程软件环境：Microsoft studio visual C++ 6.0 MFC硬件：计算机二、实验内容（1）添加代码实现DDA算法画直线（2）添加代码实现Bresenham算法画直线（3）添加代码实现Midpointline画直线(4) 添加代码实现画圆三、实验步骤选择工作环境添加工程名选择程序类型前几步省略全选默认值选择resource-Menu添加不同函数画直线和圆为每个函数建立类向导在fileview中打开source filesview.cpp输入各函数代码并编译运行无误四、实验源码// 直线和圆View.cpp : implementation of the CMyView class//#include "stdafx.h"#include "直线和圆.h"#include "直线和圆Doc.h"#include "直线和圆View.h"#ifdef _DEBUG#define new DEBUG_NEW#undef THIS_FILEstatic char THIS_FILE[] = __FILE__;#endif///////////////////////////////////////////////////////////////////////////// // CMyViewIMPLEMENT_DYNCREATE(CMyView, CView)BEGIN_MESSAGE_MAP(CMyView, CView)//{{AFX_MSG_MAP(CMyView)ON_COMMAND(ID_DDALINE, OnDdaline)ON_COMMAND(ID_MIDPOINTLINE, OnMidpointline)ON_COMMAND(ID_BRESENHAMLINE, OnBresenhamline)ON_COMMAND(ID_MIDPOINTCIRCLE, OnMidpointcircle)//}}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()///////////////////////////////////////////////////////////////////////////// // CMyView construction/destructionCMyView::CMyView(){// TODO: add construction code here}CMyView::~CMyView(){}BOOL CMyView::PreCreateWindow(CREATESTRUCT& cs){// TODO: Modify the Window class or styles here by modifying// the CREATESTRUCT csreturn CView::PreCreateWindow(cs);}///////////////////////////////////////////////////////////////////////////// // CMyView drawingvoid CirclePoints(int x,int y,int color ,CDC* pDC ){pDC->SetPixel(x,y,color);pDC->SetPixel(y,x,color);pDC->SetPixel(-x,y,color);pDC->SetPixel(y,-x,color);pDC->SetPixel(x,-y,color);pDC->SetPixel(-y,x,color);pDC->SetPixel(-x,-y,color);pDC->SetPixel(-y,-x,color);}void Midpointcircle(int r,int color,CDC* pDC){int x,y;float d;x=0;y=r;d=1.25-r;CirclePoints(x,y,color,pDC);pDC->SetViewportOrg(200,100);while(x<=y){if(d<0)d+=2*x+3;else{d+=2*(x-y)+5; y--;}x++;CirclePoints(x,y,color,pDC);}}void DDA(int x0,int y0,int x1,int y1,int color,CDC* pDC){int x;float dx,dy,y,k;dx=x1-x0;dy=y1=y0;k=dy/dx;y=y0;for(x=x0;x<=x1;x++){pDC->SetPixel(x,int (y+0.5), color);y=y+k;}}void Bresenhamline(int x0,int y0,int x1,int y1,int color,CDC* pDC) {int x,y,dx,dy;float k,e;dx=x1-x0;dy=y1-y0 ;k=dy/dx;e=-0.5;x=x0;y=y0;for(int i=0;i<=dx;i++){pDC->SetPixel(x,y,color);x=x+1;e=e+k;if(e>=0){y++;e=e-1;}}}void Midpointline(int x0,int y0,int x1,int y1,int color,CDC* pDC) {int a,b,d1,d2,d,x,y;a=y0-y1;b=x1-x0;d=2*a+b;d1=2*a;d2=2*(a+b);x=x0;y=y0;pDC->SetPixel(x,y,color);while (x<x1){if(d<0){x++;y++;d+=d2;}else{x++;d+=d1;}pDC->SetPixel(x,y,color);}}void CMyView::OnDraw(CDC* pDC){CMyDoc* pDoc = GetDocument();ASSERT_VALID(pDoc);Midpointcircle(100,RGB(0,168,168),pDC) ;DDA(0,0, 250,300,RGB (255,0,255),pDC);Midpointline(0,0, 500,200,RGB (255,255,0),pDC);Bresenhamline(0,0, 150,600,RGB (168,200,168),pDC);// TODO: add draw code for native data here}///////////////////////////////////////////////////////////////////////////// // CMyView printingBOOL CMyView::OnPreparePrinting(CPrintInfo* pInfo){// default preparationreturn DoPreparePrinting(pInfo);}void CMyView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/){// TODO: add extra initialization before printing}void CMyView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/){// TODO: add cleanup after printing}///////////////////////////////////////////////////////////////////////////// // CMyView diagnostics#ifdef _DEBUGvoid CMyView::AssertValid() const{CView::AssertValid();}void CMyView::Dump(CDumpContext& dc) const{CView::Dump(dc);}CMyDoc* CMyView::GetDocument() // non-debug version is inline{ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CMyDoc)));return (CMyDoc*)m_pDocument;}#endif //_DEBUG///////////////////////////////////////////////////////////////////////////// // CMyView message handlersvoid CMyView::OnDdaline(){// TODO: Add your command handler code here}void CMyView::OnMidpointline(){// TODO: Add your command handler code here}void CMyView::OnBresenhamline(){// TODO: Add your command handler code here}void CMyView::OnMidpointcircle(){// TODO: Add your command handler code here}五.实验结果六. 实验总结分析通过做这个实验学会了使用这个软件，也了解到指针的用法，在做之初由于对指针用法的不熟悉，所以遇到很多问题，从提示中弹出的CDC类，通过对它的学习，我将源码中的drawpixel改写成调用CDC类的pDC指针的用法，再插入pDC->SetViewportOrg(200,100);实现了圆心的移动，实现了对直线的绘制，现在对它的操作已基本掌握了。
bresenham算法画直线例题
Bresenham算法是计算机图形学中常用的一种画直线的算法。
它的原理是利用像素点在屏幕上的排列规律，从而高效地计算出直线上的像素点。
本文将以一个具体的例题来说明Bresenham算法的原理及应用。
1. 问题描述假设我们需要在一个分辨率为800x600的屏幕上，画一条直线，起点坐标为(100, 200)，终点坐标为(400, 300)。
请使用Bresenham算法计算直线上的像素点，并用符号“*”表示出来。
2. Bresenham算法原理Bresenham算法的核心思想是利用像素点的整数坐标值与直线的斜率之间的关系，从而逐个确定直线上的像素点。
具体步骤如下：- 计算直线的斜率k，即k = (y2 - y1) / (x2 - x1)，其中(x1, y1)为起点坐标，(x2, y2)为终点坐标。
- 以起点坐标作为初始值，从左至右依次求解直线上各点像素的坐标。
- 对于每一个x坐标，根据斜率k的大小确定y坐标的增长方向。
3. Bresenham算法应用根据上述原理，我们来解决具体的例题。
计算直线的斜率k：k = (300 - 200) / (400 - 100) = 1/3以起点坐标(100, 200)作为初始值，从左至右依次求解直线上各点像素的坐标。
当x坐标从100递增至400时，y坐标的增长方向由斜率k来确定。
具体计算如下：- 当x=100时，y=200- 当x=101时，y=200+1/3≈200- 当x=102时，y=200+2/3≈201- ...- 当x=400时，y=300现在，我们可以得到直线上的像素点坐标，并用符号“*”表示出来。
4. 结果展示根据上述计算，我们可以得到该直线上的像素点坐标，展示如下：(100, 200) *(101, 200) *(102, 201) *...(400, 300) *通过Bresenham算法，我们成功地计算出了直线上的像素点，并用符号“*”进行了展示。
bresenham算法例题详解
让我们回顾一下Bresenham算法的基本原理。
Bresenham算法是一种用于绘制直线、圆和椭圆的算法，它最初是由Jack Elton Bresenham在1962年提出的。
这个算法的核心思想是利用整数运算来高效地计算出图形上的点，从而避免使用浮点运算，提高了绘制图形的速度。
接下来，我们来看一个简单的例题，以便更好地理解Bresenham算法的具体应用。
假设我们需要在一个像素点阵上绘制一条直线，起点坐标为（2, 3），终点坐标为（8, 5）。
我们可以利用Bresenham算法来计算出直线上的所有像素点，具体步骤如下：1. 计算直线斜率k：k = (终点y坐标 - 起点y坐标) / (终点x坐标 - 起点x坐标)2. 初始化误差项：误差项e = 03. 从起点开始，依次计算直线上的像素点：- 如果斜率k < 1，选择沿x轴方向的像素点，即x轴加1，y轴不变- 如果斜率k > 1，选择沿y轴方向的像素点，即x轴不变，y轴加1- 更新误差项e：e = e + |k|通过以上步骤，我们可以依次计算出直线上的像素点，并用Bresenham算法高效地绘制直线。
在这个例题中，我们可以看到Bresenham算法的简单实现步骤，它不仅可以用于绘制直线，还可以应用于绘制圆和椭圆。
这种基于整数运算的高效算法在图形学和计算机图形学中有着广泛的应用。
通过对Bresenham算法的例题详解，我们对这个算法的原理和应用有了更深入的理解。
Bresenham算法的高效性和简单性使得它成为了计算机图形学中不可或缺的重要算法，而且它的应用也不仅限于直线的绘制，还可以拓展到更多的图形绘制领域。
希望通过这个例题的解析，你对Bresenham算法有了更清晰的认识。
Bresenham算法的应用不仅限于直线的绘制，它还可以被推广应用到其他图形绘制的领域，比如圆和椭圆的绘制。
在这些领域，Bresenham算法同样能够高效地计算出图形上的像素点，从而实现快速绘制图形的效果。
Bresenham快速画3D直线算法
Bresenham快速画3D直线算法--------yangzhengyun一、简述前段时间一个学弟正在做一个LED立方，说想做了送给女友。
但他说在画直线，球，波浪等图案时，总是找不到一个很好的算法，导致显示刷屏很慢甚至出现闪屏的现象，问我有没有什么好的算法。
刚好前段时间我也在弄这个，刚开始的时候，我竟然也被“如何画一条3D直线”难倒了，有的人说——画直线还不简单啊，两个点确定一条直线，那是高中数学里面最简单不过的方程式了。
没错，如果是运用高中的方程式来编程，确实很简单，但是……我们先来看一下直线的方程式吧：如我们知道了两个坐标点：A（x1,y1,z1）,B(x2,y2,z2)。
那么直线的方程是：K=(x-x1)/(x2-x1)＝(y-y1)/(y2-y1)＝(z-z1)/(z2-z1)这就不化简了，但是你们有木有发现一个问题。
对，那就是都是进行浮点运算。
我们试想想，如果是用8位的单片机来做的话，速度不知道将会慢到什么程度了。
且，画直线函数基本可以说是底层的驱动函数，如果一个驱动函数都占据了很多的运行时间的话，上层的代码写的再好也是无用的。
为此我们必须找到一个好的办法，避开浮点运算。
即把浮点数据转换成整形数据进行运算，这样速度可以得到很大的提升。
为此，我们首选的就是Bresenham算法了，它引入了一个误差常量e(即后面用到的ey,ez)，e的值为-1/2；在这个运算思路中，我们还是要用到上面的直线方程做为基础。
所以，在看这个代码的时候，你必须先有这点数学的基本知识才行，不然你看的就云里雾里，两眼冒金星了。
下面帖出的是本人经过上网预览大量资料后，写出的三维基于Bresenham算法的画直线函数，二维的就不贴出了，因为二维的在网上有大把的源码，但是三维现成源码就不多了，当然资料还是有的。
里面的算法，和二维算法的思路是一样的，具体的各位学弟们自己去网上查吧，百度一下“Bresenham算法”够你看了，要有多详细有多详细。
Bresenham画直线算法
Bresenham画直线算法发表于：03-28 20:23 | 分类：代码阅读：(4) 评论：(0)给定两个点起点P1(x1, y1), P2(x2, y2),如何画它们直连的直线呢，即是如何得到上图所示的蓝色的点。
假设直线的斜率0<k>0,直线在第一象限，Bresenham算法的过程如下：1.画起点(x1, y1).2.准备画下一个点，X坐标加1，判断如果达到终点，则完成。
否则找下一个点，由图可知要画的点要么为当前点的右邻接点，要么是当前点的右上邻接点。
2.1.如果线段ax+by+c=0与x=x1+1的交点y坐标大于(y+*y+1))/2则选右上那个点2.2.否则选右下那个点。
3.画点4.跳回第2步5.结束具体的算法如下，原理就是比较目标直线与x+1直线交点的纵坐标，哪个离交点近就去哪个void Bresenhamline(int x0, int y0, int x1, int y1, int color){int x, y, dx, dy;float k, e;dx = x1 - x0;dy = y1 - y0;k = dy / dx;e = -0.5;x = x0;y = y0;for (x= x0;x < x1; x++){drawpixel(x, y, color);//这个是画点子函数e = e + k;if (e > 0){y++;e = e - 1;}}}上述Bresenham算法在计算直线斜率与误差项时用到小数与除法。
可以改用整数以避免除法。
等式两边同时乘以2*dx，得到2*e*dx = 2*e*dx + 2dy, 2*e*dx = 2*e*dx - 2*dx.由于算法中只用到误差项的符号，因此可作如下替换：2*e*dx.改进的Bresenham画线算法程序：将e统一乘以2*dx即变成了整数的Bresenhan算法了，^_^void InterBresenhamline (int x0, int y0, int x1, int y1, int color){int dx = x1 - x0；int dy = y1 - y0；int dx2 = dx << 1;//乘2int dy2 = dy << 1;//乘2int e = -dx;int x = x0；int y = y0;for (x = x0; x < x1; x++){drawpixel (x, y, color);e=e + dy2;if (e > 0){y++;e = e - dx2;}}}其他象限或斜率不同可以转换一下位置即可，这里不具体展开。
DDA法,中点法,Bresenham法画直线
实验名称 DDA 法，中点法，Bresenham 法画直线一、实验目的学会用DDA 法，中点法，Bresenham 法这三种思想画直线，同时，对画直线的操作有一定的了解。
二、实验原理及内容1. DDA 法的基本思想如下：已知过端点P0(x0,y0) , P1(x1,y1)的直线段L ：y=kx+b ,直线斜率为k=(y1-y0)/x1-x0 ,从x 的左端点x0开始，向x 右端点步进。
步长=1(个象素)，计算相应的y 坐标y=kx+b ；取象素点(x, round(y))作为当前点的坐标。
2. 中点法的基本思想如下：当前象素点为(xp, yp) 。
下一个象素点为P1 或P2 。
设M=(xp+1, yp+0.5)，为p1与p2之中点，Q 为理想直线与x=xp+1垂线的交点。
将Q 与M 的y 坐标进行比 较。
当M 在Q 的下方，则P2 应为下一个象素点；M 在Q 的上方，应取P1为下一点。
构造判别式:d=F(M)=F(xp+1,yp+0.5)=a(xp+1)+b(yp+0.5)+c ,其中a=y0-y1, b=x1-x0, c=x0y1-x1y0当d<0，M 在L(Q 点)下方，取右上方P2为下一个象素；当d>0，M 在L(Q 点)上方，取右方P1为下一个象素；当d=0，选P1或P2均可，约定取P1为下一个象素；但这样做，每一个象素的计算量是4个加法，两个乘法。
采用增量算法改进如下：d 是xp, yp 的线性函数，因此可采用增量计算，提高运算效率。
若当前象素处于d 0情况，则取正右方象素P1 (xp+1, yp), 要判下一个象素位置，应计算d1=F(xp+2, yp+0.5)=a(xp+2)+b(yp+0.5)+c=d+a ； 增量为a ，若d<0时，则取右上方象素P2 (xp+1, yp+1)。
要判断再下一象素，则要计算d2= F(xp+2, yp+1.5)=a(xp+2)+b(yp+1.5)+c=d+a+b ；增量为a ＋b画线从(x0, y0)开始，d 的初值d0=F(x0+1, y0+0.5)=F(x0, y0)+a+0.5b =a+0.5b 。
直线的Bresenham算法
直线的Bresenham算法在实验课上⽤⾃⼰的算法画直线被diss效率低花了半天时间看了下Bresenham算法真总结⼀下其中的精妙之处Bresebham直线⽣成算法的基本原理是，每次在最⼤位移⽅向上⾛⼀步，⽽另⼀个⽅向是⾛步还是不⾛步取决于误差项的判别。
声明k为斜率在0≤k<1的情况下，假设当前点是P(x1,y1)，则下⼀个点在P u(x1+1,y1+1)与P d(x1+1,y1)中选⼀。
以M表⽰P u与P d的中点，即M(x1+1,y1+0.5)。
设Q是理想直线与x=x i+1的交点；显然，若M在Q的下⽅，则P u(x1+1,y1+1)离直线较近，应取为下⼀个像素；否则应取P d(x1+1,y1)。
理解并不难主要在于实现依据该算法的原理基本能够实现窝先试着⾃⼰写了⼀会如果要实现各个⽅向的⼆维直线绘制需要考虑多种情况写出来很不美观教材上给出了更好的解决⽅案：同样以0≤k<1为例每次选取下个点时理想直线的y坐标都步进k个单位长度累加值即为误差项d i当d i⼤于0.5时选取P u否则选取P d并使d i-1令e i=d i-0.5则e i>0时选取P u否则选取P d经过改进，算法的效率⼤幅提升但其中在计算斜率与误差项时会⽤到⼩数和除法并且下⼀步的选择只与误差项的符号有关因此可以进⼀步改进：可知e i的值由三种值组成：e i=-1/2(初始值)+(n个)y/x(步进值)-(m个)1(调整值)...同乘2x即得2*x*e i=-x+(n个)2*y-(m个)2*x....这样即可得到仅由整数构成的算法以上仅为对0≤k<1情况下的讨论其余的情况类似附⼀段杂乱⽆章的代码1 point<Type> now_point = start;2 point<Type> e_step, point_step;3 e_step.x = abs(step.x);4 e_step.y = abs(step.y);5 glBegin(GL_POINTS);6if (step.x == 0 && step.y == 0) //No Step7return;8 point_step.x = (step.x == 0) ? 1 : step.x / e_step.x;9 point_step.y = (step.y == 0) ? 1 : step.y / e_step.y;10if (step.x == 0) { // k is endless11do{12 glVertex2i(now_point.x, now_point.y);13 now_point.y += point_step.y;14 } while (now_point.y != end.y);15 }16else if (step.y == 0) { //k is zero17do {18 glVertex2i(now_point.x, now_point.y);19 now_point.x += point_step.x;20 } while (now_point.x != end.x);21 }22else if (abs(step.y / step.x) == 0) { // |k| < 1 23 Type e = -e_step.x;24do {25 glVertex2i(now_point.x, now_point.y);26 e += 2 * e_step.y;27 now_point.x += point_step.x;28if (e > 0) {29 now_point.y += point_step.y;30 e -= 2 * e_step.x;31 }32 } while (now_point.x != end.x);33 }34else { // |k| >= 135 Type e = -e_step.y;36do {37 glVertex2i(now_point.x, now_point.y);38 e += 2 * e_step.x;39 now_point.y += point_step.y;40if (e > 0) {41 now_point.x += point_step.x;42 e -= 2 * e_step.y;43 }44 } while (now_point.y != end.y);45 }46 glEnd();47 glFlush();本菜鸡的辣鸡代码。
计算机图形学--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算法的基本原理和递推公式。
一、中点Bresenham算法的基本原理1.1 数值方式直线的差值算法在了解中点Bresenham算法之前，我们需要先了解数值方式直线的差值算法。
通过计算两个端点的坐标差值，可以得到直线的斜率和步长，从而在光栅化的像素网格上绘制直线。
然而，这种算法需要进行浮点数运算，对于嵌入式系统和低性能设备来说，性能较差。
1.2 中点Bresenham算法的优势中点Bresenham算法通过整数运算和递推公式来高效地绘制直线，避免了浮点数运算的开销，因此在嵌入式系统和低性能设备上具有很高的应用价值。
它利用了直线的对称性和整数坐标的特点，通过逐个像素的递推计算来实现直线的绘制。
1.3 算法的基本思想中点Bresenham算法的基本思想是从直线的起点到终点，在每一步选择最接近直线的像素作为下一个像素，从而逐步绘制整条直线。
通过比较像素的位置和理想直线的位置关系，选择最接近直线的像素进行绘制，从而得到了中点Bresenham算法的递推过程。
二、中点Bresenham算法的递推公式2.1 直线斜率的计算我们需要计算直线的斜率m。
对于给定的两个端点P1(x1, y1)和P2(x2, y2)，直线的斜率可以通过以下公式计算得到：m = (y2 - y1) / (x2 - x1)2.2 中点Bresenham算法的关键递推公式中点Bresenham算法通过比较像素的位置和理想直线的位置关系，选择最接近直线的像素进行绘制。
其关键递推公式如下：对于斜率0 ≤ m ≤ 1的直线：d = 2 * (y - y0) - (x - x0)若d < 0，则选择(x, y)为下一个像素，d = d + 2 * (y1 - y0)若d ≥ 0，则选择(x, y)为下一个像素，d = d + 2 * (y1 - y0) - 2 * (x1 - x0)对于斜率m > 1的直线：d = 2 * (x - x0) - (y - y0)若d < 0，则选择(x, y)为下一个像素，d = d + 2 * (x1 - x0)若d ≥ 0，则选择(x, y)为下一个像素，d = d + 2 * (x1 - x0) - 2 * (y1 - y0)2.3 递推过程通过以上递推公式，我们可以在每一步选择最接近直线的像素进行绘制，从而逐步绘制整条直线。
Bresenham快速画直线算法
Bresenham快速画直线算法⼀、算法原理简介：算法原理的详细描述及部分实现可参考： Fig. 1假设以(x, y)为绘制起点，⼀般情况下的直观想法是先求m = dy /dx（即x每增加1， y的增量），然后逐步递增x, 设新的点为x1 = x + j,则y1 = round(y + j * m)。
可以看到，这个过程涉及⼤量的浮点运算，效率上是⽐较低的（特别是在嵌⼊式应⽤中，DSP可以⼀周期内完成2次乘法，⼀次浮点却要上百个周期）。
下⾯，我们来看⼀下Bresenham算法，如Fig. 1,(x, y +ε)的下⼀个点为(x, y + ε + m)，这⾥ε为累加误差。
可以看出，当ε+m < 0.5时，绘制(x + 1, y)点，否则绘制(x + 1, y + 1)点。
每次绘制后，ε将更新为新值：ε = ε + m ,如果(ε + m) <０.５ (或表⽰为2*(ε + m) < 1)ε = ε + m – 1, 其他情况将上述公式都乘以dx, 并将ε*dx⽤新符号ξ表⽰，可得ξ = ξ + dy, 如果2*(ξ + dy) < dxξ = ξ + dy – dx, 其他情况可以看到，此时运算已经全变为整数了。
以下为算法的伪代码：ξ← 0, y ← y1For x ← x1 to x2 doPlot Point at (x, y)If (2(ξ + dy) < dx)ξ←ξ + dyElsey ← y + 1,ξ←ξ + dy – dxEnd IfEnd For⼆、算法的注意点：Fig. 2在实际应⽤中，我们会发现，当dy > dx或出现Fig.2 右图情况时时，便得不到想要的结果，这是由于我们只考虑dx > dy，且x, y的增量均为正的情况所致。
经过分析，需要考虑8种不同的情况，如Fig. 3所⽰：(Fig. 3)当然，如果直接在算法中对8种情况分别枚举，那重复代码便会显得⼗分臃肿，因此在设计算法时必须充分考虑上述各种情况的共性，后⾯将给出考虑了所有情况的实现代码。
Bresenham直线算法与画圆算法
Bresenham直线算法与画圆算法文章分类:Java编程计算机是如何画直线的？简单来说，如下图所示，真实的直线是连续的，但我们的计算机显示的精度有限，不可能真正显示连续的直线，于是我们用一系列离散化后的点（像素）来近似表现这条直线。
（上图来自于互联网络，《计算机图形学的概念与方法》柳朝阳，郑州大学数学系）接下来的问题就是如何尽可能高效地找到这些离散的点，Bresenham直线算法就是一个非常不错的算法。
Bresenham直线算法是用来描绘由两点所决定的直线的算法，它会算出一条线段在 n 维光栅上最接近的点。
这个算法只会用到较为快速的整数加法、减法和位元移位，常用于绘制电脑画面中的直线。
是计算机图形学中最先发展出来的算法。
(引自wiki百科布雷森漢姆直線演算法)这个算法的流程图如下：可以看到，算法其实只考虑了斜率在 0 ~ 1 之间的直线，也就是与 x 轴夹角在 0 度到 45 度的直线。
只要解决了这类直线的画法，其它角度的直线的绘制全部可以通过简单的坐标变换来实现。
下面是一个C语言实现版本。
Java代码1.view sourceprint?2. // 交换整数 a 、b 的值3.4.inline void swap_int(int *a, int *b)5.{6. *a ^= *b;7. *b ^= *a;8. *a ^= *b;9.}10.11.// Bresenham's line algorithm12.13.void draw_line(IMAGE *img, int x1, int y1, int x2, int y2, unsigned long c)14.{15. // 参数 c 为颜色值16. int dx = abs(x2 - x1),17. dy = abs(y2 - y1),18. yy = 0;19.20. if(dx < dy)21. {22. yy = 1;23. swap_int(&x1, &y1);24. swap_int(&x2, &y2);25. swap_int(&dx, &dy);26. }27.28. int ix = (x2 - x1) > 0 ? 1 : -1,29. iy = (y2 - y1) > 0 ? 1 : -1,30. cx = x1,31. cy = y1,32. n2dy = dy * 2,33. n2dydx = (dy - dx) * 2,34. d = dy * 2 - dx;35.36.// 如果直线与 x 轴的夹角大于45度37. if(yy)38. {39. while(cx != x2)40. {41. if(d < 0)42. {43. d += n2dy;44. }45. else46. {47. cy += iy;48. d += n2dydx;49. }50.51. putpixel(img, cy, cx, c);52.53. cx += ix;54. }55. }56.57.// 如果直线与 x 轴的夹角小于度58. else59. {60. while(cx != x2)61. {62. if(d < 0)63. {64. d += n2dy;65. }66. else67. {68. cy += iy;69. d += n2dydx;70. }71.72. putpixel(img, cx, cy, c);73.74. cx += ix;75. }76. }77.}可以看到，在画线的循环中，这个算法只用到了整数的加法，所以可以非常的高效。
Bresenham直线算法
Bresenham直线算法是用来描绘由两点所决定的直线的算法，它会算出一条线段在 n 维光栅上最接近的点。
这个算法只会用到较为快速的整数加法、减法和位元移位，常用于绘制电脑画面中的直线。
是计算机图形学中最先发展出来的算法。
经过少量的延伸之后，原本用来画直线的算法也可用来画圆。
且同样可用较简单的算术运算来完成，避免了计算二次方程式或三角函数，或递归地分解为较简单的步骤。
以上特性使其仍是一种重要的算法，并且用在绘图仪、绘图卡中的绘图芯片，以及各种图形程式库。
这个算法非常的精简，使它被实作于各种装置的固件，以及绘图芯片的硬件之中。
“Bresenham”至今仍经常作为一整个算法家族的名称，即使家族中绝大部份算法的实际开发者是其他人。
该家族的算法继承了 Bresenham 的基本方法并加以发展，详见参考资料。
目录[隐藏]∙ 1 演算方法∙ 2 一般化∙ 3 最佳化∙ 4 历史∙ 5 参考资料∙ 6 参阅∙7 外部链接[编辑]演算方法Bresenham直线算法描绘的直线。
假设我们需要由 (x0, y0) 这一点，绘画一直线至右下角的另一点(x1, y1)，x,y分别代表其水平及垂直座标，并且x1 - x0 > y1 - y0。
在此我们使用电脑系统常用的座标系，即x座标值沿x轴向右增长，y座标值沿y轴向下增长。
因此x及y之值分别向右及向下增加，而两点之水平距离为x1−x0且垂直距离为y1-y0。
由此得之，该线的斜率必定介乎于1至0之间。
而此算法之目的，就是找出在x0与x1之间，第x行相对应的第y列，从而得出一像素点，使得该像素点的位置最接近原本的线。
对于由(x0, y0)及(x1, y1)两点所组成之直线，公式如下：因此，对于每一点的x，其y的值是因为x及y皆为整数，但并非每一点x所对应的y皆为整数，故此没有必要去计算每一点x所对应之y值。
反之由于此线之斜率介乎于1至0之间，故此我们只需要找出当x 到达那一个数值时，会使y上升1，若x尚未到此值，则y不变。
1.论述直线的bresenham算法的原理,方法和步骤。
论述直线的bresenham算法的原理,方法和步骤。
Bresenham算法是一种用于计算直线段的算法，它是一种基于中点画线思想的折线逼近算法。
该算法可以在二维平面中以最小的误差逼近直线。
B resenham算法的主要优点是它只需要计算整数坐标，而不需要使用浮点数计算，因此运行速度快，精度高。
Bresenham算法的原理是：从直线的一个端点开始，按照一定的方向和步长绘制一系列点，直到另一个端点为止。
这些点之间的间距逐渐减小，使得视觉效果上形成一条直线。
在这个过程中，通过计算每个点的坐标，可以得到一条近似于直线的折线。
Bresenham算法的方法如下：1. 初始化参数：设定直线的两个端点坐标（x1，y1）和（x2，y2），以及画线的方向变量k。
初始方向k等于两点横坐标之差与纵坐标之差的比值，即k = (y2 - y1) / (x2 - x1)。
2. 计算第一个点：根据初始方向k，计算第一个点的坐标。
第一个点的横坐标为x1 + k/2，纵坐标为y1。
3. 迭代计算后续点：从第二个点开始，每次迭代都将当前点的横坐标加上k，纵坐标加上1/k。
同时，检查当前点的横坐标是否超过终点坐标x2，如果是，则结束绘制。
4. 输出结果：将计算出的所有点按照顺序连接起来，形成一条折线，这条折线近似于原始直线。
Bresenham算法的步骤如下：1. 初始化参数：设置直线的两个端点坐标和方向k。
2. 计算第一个点：根据方向k，计算第一个点的坐标。
3. 迭代计算后续点：按照迭代公式，依次计算出所有点的位置。
4. 输出结果：将计算出的所有点连接起来，形成一条折线。
5. 终止条件：当计算出的点的横坐标超过终点坐标时，绘制过程结束。
通过以上方法和步骤，Bresenham算法可以高效地绘制出直线段，适用于各种图形绘制和计算场景。
在实际应用中，可以根据需要调整算法的参数和精度，以满足不同的需求。