Bresenham中点画线算法.docx

Bresenham中点画线算法.docx

《Bresenham中点画线算法.docx》由会员分享，可在线阅读，更多相关《Bresenham中点画线算法.docx（19页珍藏版）》请在冰豆网上搜索。

Bresenham中点画线算法

Bresenham中点画线算法

先标明这转载自 

直线扫描算法之---bresenham改进算法（任何斜率，任何方向）

byzxx

图形学神马的全都是数学，看来以后我不能搞这个，伤脑筋，所以先把我现在懂得先记录下来吧。

不过呢，我的水平实在有限，对于算法这种东西实在难以说明白，请大家包涵。

书上讲的实在是太过简略，所以这里我把一些简单的推导过程都记录下来：

1.重温bresenham未改进算法（斜率在0-1之间的直线）

我想要记录的是bresenham改进算法，所以在讲解改进算法之前，我先用一个简单的例子说明一下未改进算法的思想：

这是一个斜率k在0-1之间的一条直线，我就用斜率为0-1之间的直线来重温：

首先，如图1所示，假设x列的像素已定，其坐标为（x，y），那么下一个坐标一定是：

（x+1，y+1）或者（x+1，y）。

而是哪一个取决于d的值，如果d>0.5那么就是（x+1，y+1），

如果d<0.5,那么就是（x+1，y），而d是什么呢？

当然是斜率了。

（原因如下：

y=kx+b

当x增加1时：

y=kx+k+b

所以当x增加1是，y方向的增量是d。

）

所以每次我们只需要让d=d+k（k是斜率）即可，当d>=1时，就让d减一，这样就保证了d在0-1之间。

当d>0.5,下一个点取（x+1，y+1）

当d<0.5,下一个点取（x+1，y）

然后呢，我们为了判断的方便，让e=d-0.5，这样就变成了：

当e>0，下一个点取（x+1，y+1）

当e<0，下一个点取（x+1，y）

2.过渡，重温之后，我们就想要改进，为什么要改进呢？

因为我们这里面有0.5，还有k，k里面有dx/dy，这些除法和小数都不是我们想要的，我们想要的是，只有整数，且只有加法的算法，下面就全面讨论一下改进算法。

3.改进算法篇（不同斜率，不同方向）

这里，我们主要分为4个角度来说明：

A.      斜率在0-1只间

B.      斜率在1-无穷之间

C.      斜率在0-（-1）之间

D.     斜率在（-1）-负无穷之间

E．两种特殊情况，两条直线。

A． 斜率在0-1只间

以往我们会产生除法和小数的地方主要是：

e=0.5

e=e+k

接下来我们一步一步实现我们的目标：

1.消除除法

e=e+dy/dx

e*dx=e*dx+dy

2.消除小数

2*e*dx=2e*dx+2dy

由于算法中只用到误差项的符号，所以可以使用如下替换：

e’=2*e*dx

注意：

为了让代换后符号不变，必须保证dx>0

使用这个替换以后，我们就可以消除除法和小数了，这里要注意一个问题，我们一定要保持e和e’的符号是相同的，那么就要保证dx大于0！

！

！

所以说，在这种情况下，我们的dx一定要大于0，如果小于0，可以交换起点和终点坐标，总之起点一定要从x坐标小的点开始。

而且我们要注意以前当e>0时，我们要e=e-1，现在：

e=e’/（2*dx）

所以e’/（2*dx）=e’/（2*dx）-1

展开e’=e’-2*dx。

具体的代码如下：

voidCMyDrawLineView:

:

DrawBresenham（intx1,intx2,inty1,inty2,COLORREFcolor,CDC*pDC）

{

       intx,y,dx,dy,e;

       dx=x2-x1;

       dy=y2-y1;

       x=x1;

       y=y1;

       CStrings;

//这里一定要注意，由于使用的是改进算法，所以dx一定是要大于0才能保证其符号不变

       if（（dx>=0&&dy>=0）||（dx<=0&&dy<=0））    //如果k大于0

       {    

                     if（dx<0）                       //dx小于0说明终点x

                     {

                            dx=-dx;

                            x=x2;

                            dy=-dy;

                            y=y2;                   

}

              if（dy

              {

                     e=-dx;

                     for（inti=0;i

                     {

                            pDC->SetPixel（x,y,color）;

                            x++;

                            e=e+dy+dy;

                            if（e>=0）

                            {

                                   y++;

                                   e=e-dx-dx;

                            }

                     }

              }

}

}

B． 斜率在1-无穷之间

如图二，在这种情况下，我们可以看到y的变化速度比x快，所以说，我们这里每次让y加1，而不是让x加1，所以我们每次让y加1时，x的增长是d，注意，此处的d不是斜率k，而是1/k，按照以往我们的目的，我们要消除除法和小数：

1.       消除除法

e=e+d;

e=e+dx/dy;

dy*e=dy*e+dx;

2．消除0.5

       2*dy*e=2*dy*e+2dx;

由于算法中只用到误差项的符号，所以可以使用如下替换：

e’=2*e*dy

注意：

为了让代换后符号不改变，必须保证dy>0,如果不满足，则可以按上述方法交换起点终点坐标。

代码如下：

voidCMyDrawLineView:

:

DrawBresenham（intx1,intx2,inty1,inty2,COLORREFcolor,CDC*pDC）

{

       intx,y,dx,dy,e;

       dx=x2-x1;

       dy=y2-y1;

       x=x1;

       y=y1;

       CStrings;

//这里一定要注意，由于使用的是改进算法，所以dx一定是要大于0才能保证其符号不变

       if（（dx>=0&&dy>=0）||（dx<=0&&dy<=0））    //如果k大于0

       {    

                     if（dx<0）                       //dx小于0说明终点x

                     {

                            dx=-dx;

                            x=x2;

                            dy=-dy;

                            y=y2;                   

}

              if（dy>=dx）                                  //第一种情况，k-（0,1）

              {

                     e=-dy;

                     for（inti=0;i

                     {

                            pDC->SetPixel（x,y,color）;

                            y++;

                            e=e+dx+dx;

                            if（e>=0）

                            {

                                   x++;

                                   e=e-dy-dy;

                            }

                     }

              }

}

}

C.斜率在0-（-1）之间

如图三，在这种情况下可以类比斜率在0-1之间的情况，不过呢，我们要注意一个问题，就是现在的斜率是负数，我们使用时，需要改变符号，下面直接看改进：

1.消除除法

e=e-dy/dx（注意是减号，因为现在的斜率是负数）

e*dx=e*dx-dy

2.消除小数

2*e*dx=2e*dx-2dy

由于算法中只用到误差项的符号，所以可以使用如下替换：

e’=2*e*dx

注意：

为了让代换后符号不变，必须保证dx>0

d

d

代码如下：

voidCMyDrawLineView:

:

DrawBresenham（intx1,intx2,inty1,inty2,COLORREFcolor,CDC*pDC）

{

       intx,y,dx,dy,e;

       dx=x2-x1;

       dy=y2-y1;

       x=x1;

       y=y1;

       CStrings;

//这里一定要注意，由于使用的是改进算法，所以dx一定是要大于0才能保证其符号不变

       if（（dx>=0&&dy>=0）||（dx<=0&&dy<=0））    //如果k大于0

       {    

              。

。

。

。

。

。

。

。

。

}

else

{

inttempx,tempy;    //保存x和y的绝对值

              if（dx<0）                //dx小于0说明终点x

              {

                     tempx=-dx;

                     tempy=dy;

              }

              if（dy<0）

              {

                     tempx=dx;

                     tempy=-dy;

              }

              if（tempx>tempy）                                //第三种情况，k-（-1,0）

              {

                     if（dx<0）                       //dx小于0说明终点x

                     {

                            dx=-dx;

                            x=x2;

                            dy=-dy;

                            y=y2;

                     }

                     e=-dx;

                     for（inti=0;i

                     {

                            pDC->SetPixel（x,y,color）;

                            x++;

                            e=e-dy-dy;

                            if（e>=0）

                            {

                                   y--;

                                   e=e-dx-dx;

                            }

                     }

              }

}

}

D．斜率在（-1）-负无穷之间

如图四，在这种情况下可以类比斜率在1到正无穷之间的情况，不过呢，我们要注意一个问题，就是现在的斜率是负数，我们使用时，需要改变符号，下面直接看改进：

1.消除除法

e=e-dx/dy（注意是减号，因为现在的斜率是负数）

e*dy=e*dy-dx

2.消除小数

2*e*dy=2*e*dy-2dx

由于算法中只用到误差项的符号，所以可以使用如下替换：

e’=2*e*dy

注意：

为了让代换后符号不变，必须保证dy>0

代码如下：

voidCMyDrawLineView:

:

DrawBresenham（intx1,intx2,inty1,inty2,COLORREFcolor,CDC*pDC）

{

       intx,y,dx,dy,e;

       dx=x2-x1;

       dy=y2-y1;

       x=x1;

       y=y1;

       CStrings;

//这里一定要注意，由于使用的是改进算法，所以dx一定是要大于0才能保证其符号不变

       if（（dx>=0&&dy>=0）||（dx<=0&&dy<=0））    //如果k大于0

       {    

              。

。

。

。

。

。

。

。

。

}

else

{

inttempx,tempy;    //保存x和y的绝对值

              if（dx<0）                //dx小于0说明终点x

              {

                     tempx=-dx;

                     tempy=dy;

              }

              if（dy<0）

              {

                     tempx=dx;

                     tempy=-dy;

              }

              if（tempx

              {

                     if（dy<0）//dx小于0说明终点x

                     {

                            dx=-dx;

                            x=x2;

                            dy=-dy;

                            y=y2;

                     }

                     e=-dy;

                     for（inti=0;i

                     {

                            pDC->SetPixel（x,y,color）;

                            y++;

                            e=e-dx-dx;

                            if（e>=0）

                            {

                                   x--;

                                   e=e-dy-dy;

                            }

                            //if（e>dy）

                            //{

                            //     e=e-dy-dy;

                            //}

                     }

              }

}

}

完整的程序如下：

/*

x1:

直线起点x

x2:

直线终点x

y1:

直线起点y

y2:

直线终点y

color:

直线颜色

*/

voidCMyDrawLineView:

:

DrawBresenham（intx1,intx2,inty1,inty2,COLORREFcolor,CDC*pDC）

{

       intx,y,dx,dy,e;

       dx=x2-x1;

       dy=y2-y1;

       x=x1;

       y=y1;

       CStrings;

       //这里一定要注意，由于使用的是改进算法，所以dx一定是要大于0才能保证其符号不变

       if（（dx>=0&&dy>=0）||（dx<=0&&dy<=0））    //如果k大于0

       {    

                     if（（dx<0）||（dx==0&&dy<0））                       //dx小于0说明终点x

                     {

                            dx=-dx;

                            x=x2;

                            dy=-dy;

                            y=y2;

                     }

              if（dy

              {

                     e=-dx;

                     for（inti=0;i

                     {

                            pDC->SetPixel（x,y,color）;

                            x++;

                            e=e+dy+dy;

                            if（e>=0）

                            {

                                   y++;

                                   e=e-dx-dx;

                            }

                     }

              }

              else                                     //第二种情况，k-（1,max）

              {

                     e=-dy;

                     for（inti=0;i

                     {

                            pDC->SetPixel（x,y,color）;

                            y++;

                            e=e+dx+dx;

                            if（e>=0）

                            {

                                   x++;

                                   e=e-dy-dy;

                            }

                     }

              }

       }

       else                                            //如果k小于0

       {

              inttempx,tempy;    //保存x和y的绝对值

              if（dx<0）                //dx小于0说明终点x

              {

                     tempx=-dx;

                     tempy=dy;

              }

              if（dy<0）

              {

                     tempx=dx;

                     tempy=-dy;

              }

boolinterchange=false;//默认不互换dx、dy

if（dy>dx）//当斜率大于1时，dx、dy互换

{

inttemp=dx;

dx=dy;

dy=temp;

interchange=true;

}

intp=2*dy