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

合集下载

bresenham圆弧算法

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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算法）

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

bresenham画圆算法原理

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

这个算法的好处可多啦。

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

C语言生成圆弧的Bresenham算法

生成圆弧的Bresenham算法1. 算法思想如果我们构造函数F(x,y)=x2+y2-R2，则对于圆上的点有F(x,y)=0，对于圆外的点有F(x,y)>0，对于圆内的点F(x,y)<0 。

与中点画线法一样，构造判别式：d=F(M)=F(x p+1,y p-0.5)=(x p+1)2+(y p-0.5)2-R2若d<0，则应取P1为下一象素，而且再下一象素的判别式为：d=F(x p+2,y p-0.5)=(x p+2)2+(y p-0.5)2-R2=d+2x p+3若d≥0，则应取P2为下一象素，而且下一象素的判别式为d=F(x p+2,y p-1.5)=(x p+2)2+(y p-1.5)2-R2=d+2(x p-y p)+5我们这里讨论的第一个象素是（0,R），判别式d的初始值为：d0=F(1,R-0.5)=1.25-R为了进一步提高算法的效率，将上面的算法中的浮点数改写成整数，将乘法运算改成加法运算，即仅用整数实现中点画圆法。

2. C源程序#include<stdio.h>#include<graphics.h>int Center_x,Center_y,radius,color;/**********显示圆弧的八个对称点**********/void CirclePoints(int Center_x,int Center_y,int x,int y,int color){putpixel(x+Center_x,y+Center_y,color);putpixel(x+Center_x,-y+Center_y,color);putpixel(y+Center_x,x+Center_y,color);putpixel(y+Center_x,-x+Center_y,color);putpixel(-x+Center_x,-y+Center_y,color);putpixel(-x+Center_x,y+Center_y,color);putpixel(-y+Center_x,-x+Center_y,color);putpixel(-y+Center_x,x+Center_y,color);}/**********消除的乘法的中点算法**********/void MidPointCircle(int Center_x,int Center_y,int radius,int color) {int x,y;int d;int DeltaE,DeltaSE;x=0;y=radius;d=5-4*radius;DeltaE=12;DeltaSE=20-8*radius;putpixel(Center_x,Center_y,color);CirclePoints(Center_x,Center_y,x,y,color);while(y>x){if(d<=0){d+=DeltaE;DeltaSE+=8;}else{d+=DeltaSE;DeltaSE+=16;y--;}DeltaE+=8;x++;CirclePoints(Center_x,Center_y,x,y,color);}}/**********主函数**********/void main( ){int graphdriver=DETECT,graphmode;initgraph(&graphdriver,&graphmode,"\\tc");printf("************************************************************\n"); printf("* Middle-Point Algorithm for Circling *\n");printf("* Creator:Zhang Zujin *\n");printf("* *\n");printf("* Input: Center and Radius of Circle and Color Index *\n");printf("* Output: The Circle Related to Input *\n");printf("************************************************************\n\n"); printf("Please Input Center Coordinate(x,y):");scanf("%d%d",&Center_x,&Center_y);printf("Please Input Radius:");scanf("%d",&radius);printf("Input Color Index[0,15]:");scanf("%d",&color);MidPointCircle(Center_x,Center_y,radius,color); getch( );closegraph( );}。

§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算法思想：设圆的半径为r，先考虑圆心在（0,0），并从x=0、y=r开始的顺时针方向的1/8圆周的生成过程。

在这种情况下，x每步增加1，从x=0开始，到x=y结束。

即有X i+1=X i+1相应地yi+1则在两种可能中选择：Y i+1=y i或者y i+1=y i-1选择的原则是考虑精确值y是靠近yi还是靠近yi-1,计算公式为Y2=r2-(x i+1)2d1=y i2-y2=y i2-r2+(x i+1)2d2=y2-(y i-1)2=r2-(x i+1)2-(y i-1)2令pi=d1-d2,并代入d1、d2，则有P i=2(x i+1)2+y i2+(y i-1)2-2r2(1)Pi称为误差。

如果Pi<0,则yi+1=yi，否则yi+1=yi-1.pi的递归式为P i+1=p i+4x i+6+2(y i+12-y i2)-2(y i+1-y i) (2)P i的初值由式（1）代入xi=0,yi=r,而得P1=3-2r (3)根据上面的推导，圆周生成算法思想如下：(1)求误差初值，p1=3-2r，i=1,画点（0，r）；(2)求下一个光栅位置，其中x i+1=x i+1,如果p i<0,则y i+1=y i,否则y i+1=y i-1；(3)画点（x i+1,y i+1）；(4)计算下一个误差，如果p i<0，则p i+1=p i+4x i+6，否则p i+1=p i+4(x i-y i)+10；(5)I=i+1,如果x=y，则结束，否则返回步骤2；虽然（1）式表示p i+1的算法很复杂，但因为y i+1只能y i或y i-1，使得步骤（4）的算法变得简单，只需做加法和乘4的乘法。

圆的Bresenham算法的程序实现如下：#include<stdio.h>#include<conio.h>#include<stdlib.h>#include<graphics.h>void BresenhemCircle(int centerx, int centery, int radius, int color, int type);void initgr(void) /* BGI初始化*/{int gd = DETECT, gm = 0; /* 和gd = VGA,gm = VGAHI是同样效果*/ registerbgidriver(EGAVGA_driver);/* 注册BGI驱动后可以不需要.BGI文件的支持运行*/ initgraph(&gd, &gm, "");setbkcolor(WHITE);}int main(void){int centerx,centery,radius,color,type;printf("centerx,centery\n");scanf("%d",&centerx);scanf("%d",&centery);printf("radius\n");scanf("%d",&radius);printf("color,type\n");scanf("%d",&color);scanf("%d",&type);initgr(); /*BGI初始化*/BresenhemCircle(centerx,centery,radius,color,type);getch();closegraph();}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) {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);}else {line(centerx+x, centery+y, centerx+x, centery-y);line(centerx-x, centery+y, centerx-x, centery-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 = 2;}else {direction = 3;}}else {direction=2;}switch(direction) {case 1:x++;delta += (2*x+1);break;case 2:x++;y--;delta += 2*(x-y+1);break;case 3:y--;delta += (-2*y+1);break;}}}二．中心画圆法圆的特性：八对称性。

圆及圆弧生成算法

圆及圆弧生成算法圆及圆弧生成算法是计算机图形学中常用的算法之一，用于生成圆及圆弧的几何形状。

圆是一个闭合曲线，由一系列连续的点组成，其到中心点的距离都相等。

圆弧是圆的一部分，也是由一系列点组成的曲线。

下面将介绍几种常见的圆及圆弧生成算法。

1.中点圆生成算法：中点圆生成算法是一种常用的生成圆形的算法。

该算法从圆心开始，逐步生成圆上其它点的坐标，直到生成整个圆。

算法的基本思想是在每一步中选择一个点，使得该点的距离到圆的实际弧路径最接近满足圆方程的距离。

具体步骤如下：(1)初始化圆心坐标和半径；(2)设置初始点的坐标为(0,r)，即圆上的一个点；(3)设置初始参数值d，初始值为1-r；(4)当x小于等于y时，递归生成圆上的其它点的坐标，具体步骤如下：-如果d<0，则令d=d+2x+3，x=x+1，y=y；-如果d>=0，则令d=d+2x-2y+5，x=x+1，y=y-1；(5)重复步骤(4)直到x大于y结束。

2. Bresenham圆生成算法：Bresenham圆生成算法是基于中点圆生成算法的改进。

该算法的主要思想是通过对称性减少计算量，较中点圆生成算法更快速。

具体步骤如下：(1)初始化圆心坐标和半径；(2)设置初始点的坐标为(0,r)，即圆上的一个点；(3)设置初始参数值d，初始值为3-2r；(4)当x小于等于y时，递归生成圆上的其它点的坐标，具体步骤如下：-如果d<0，则令d=d+4x+6，x=x+1，y=y；-如果d>=0，则令d=d+4(x-y)+10，x=x+1，y=y-1；(5)重复步骤(4)直到x大于y结束。

3.中点圆弧生成算法：中点圆弧生成算法是用于生成圆弧的算法。

该算法通过给定圆心、弧的起始点和终止点，计算圆弧上的所有点的坐标。

具体步骤如下：(1)初始化圆心、起始点和终止点坐标；(2)计算圆上点的初始参数值d，初始值根据起始点和终止点的位置关系计算得到；(3)按递增顺序计算圆弧上的点的坐标，具体步骤如下：-如果d<0，则令d=d+4x+6，x=x+1，y=y；-如果d>=0，则令d=d+4(x-y)+10，x=x+1，y=y-1；-输出当前点的坐标；(4)重复步骤(3)直到到达终止点。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

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

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

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

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

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

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

R
(0,R)
(R,0)
x
y
这样，从圆上任一点出发，按顺时针方向生成圆时，为了最佳逼近该圆，对于下一像素的取法只有三种可能的选择，即正右方像素、正下方像素和右下角像素，分别记作：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。

为了确定究竟应该选择哪一个像素，首先考察情形①，为此计算理想圆到像素m H的距离平方与理想圆到像素m D的距离平方之差，即：
=|(x i+1)2+(y i)2-R2|-| (x i+1)2+(y i-1)2-R2|
如果<0,那么圆到右下方像素(m D)的距离大于圆到正右方像素(m H)的距离。

反之，如果>0，圆到正右方像素(m H)的距离较大。

这样
当<0,取像素m H(x I+1,y i)
当>0,取像素m D(x I+1,y I-1)
当=0时，两者距离相等，规定取正右方像素(m H)。

对于情形①，右下方像素(m D)，总是位于圆内，而正右方像素(m H)总是位于圆外，即
(x i+1)2+(y i)2-R2>0
(x i+1)2+(y i-1)2-R2<0
因此的计算可简化为：
=(x i+1)2+(y i)2-R2-[ R2 -(x i+1)2-(y i-1)2]
=2[(x i+1)2+(y i-1)2- R2]+2y i-1
=2(Δi+y i)-1
其次，考虑情形②。

由于y是x的单调递减函数，所以只能选择右方像素(x i+1,y i)。

因为右方像素(x i+1,y i)和右下方像素(x i+1,y i-1)这时都位于圆内，故表达式中有如下关系：
(x i+1)2+(y i)2-R2<0
i i 因此，<0。

：根据与情形①相同的判别准则，这时应选像素
(x i +1,y i )。

如果Δi >0，右下角像素(x i +1,y i -1)位于圆外，(图中③、④)，显然这
时只能取像素(x i +1,y i -1)，即m D ；或像素(x i ,y i -1)，即m V 。

为了确定究竟应该选择哪一个像素，首先考察情形③，为此计算理想圆
到像素m D 的距离平方与理想圆到像素m V 的距离平方之差，即：
’=|(x i +1)2+(y i -1)2-R 2|-| (x i )2+(y i -1)2-R 2|
如果’<0,那么圆到下方像素(m V )的距离大于圆到右下方像素(m D )的距
离。

反之，如果’>0，圆到右下方像素(m D )的距离较大。

这样
当‘<0,取像素m D (x i +1,y i -1)
当‘>0,取像素m V (x i ,y i -1)
当’=0时，两者距离相等，规定取右下方像素(m D )。

由于右下角像素(x i +1,y i -1)位于圆外，而下方像素(x i ,y i -1)位于圆内，所
以对于情形③，作为’分量有如下关系：
(x i +1)2+(y i -1)2-R 2>0
(x i )2+(y i -1)2-R 2<0
因此’的计算可简化为：
’’=(x i +1)2+(y i -1)2-R 2-[ R 2 -(x i )2-(y i
-1)2] =2[(x i +1)2+(y i -1)2- R 2]-2x i -1
=2(Δi +x i )-1
对于情形④，再次注意到由于y 是x的单调递减函数，因此这时需选取下
方像素(x i ,y i -1)。

这时正下方和右下角两像素均位于圆外，即’的分量有如下关系：
i i
(x i)2+(y i-1)2-R2>0
因此，’>0,这时应取m V。

最后考虑情形⑤，这时右下角像素(x i+1,y i-1)恰好在圆上，即Δi=0。

由于
(x i+1)2+(y i)2-R2>0
(x i+1)2+(y i-1)2-R2=0
从而>0，这时应选取右下角像素。

类似地，’的分量有
(x i+1)2+(y i-1)2-R2=0
(x i)2+(y i-1)2-R2<0
因此’<0,这时应选取右下角的像素。

这样Δi=0时具有与Δi<0或Δi>0一样的判别准则。

上述结果可以归纳为：
当Δi<0时：
<=0,取像素(x i+1,y i) 即m H
>0，取像素(x i+1,y i-1) 即m D
当Δi>0时：
'<=0,取像素(x i+1,y i-1) 即m D
'>0,取像素(x i,y i-1) 即m V
当Δi=0时：取像素(x i+1,y i-1) 即m D
下面我们根据上述结论，导出简单增量法的递推关系。

首先考虑水平移动到m H，即像素(x i+1,y i),称此像素为第i+1个像素。

该像素的坐标及Δi的值为
x i+1=x i+1
y i+1=y i
Δi+1=(x i+1+1)2+(y i+1-1)2-R2
=(x i+1)2+2x i+1+1+(y i-1)2-R2
=(x i+1)2+(y i-1)2-R2+2x i+1+1
=Δi+2x i+1+1
类似地，对角移动到m D（x i+1,y i-1）时，新像素的坐标和Δi的值为
x i+1=x i+1
y i+1=y i-1
Δi+1=Δi+2x i+1-2y i+1+2
对于移动到m V（x i,y i-1）时，新像素的坐标和Δi的值为
x i+1=x i
y i+1=y i-1
Δi+1=Δi-2y i+1+1。