定点数的DDA快赶上bresenham算法了，正常吗？

weiweishuo

用定点数实现的dda直线算法速度都快赶上bresenham算法了，先看dda算法：

1. void drawLine_dda_fixed(int x0,int y0,int x1,int y1){
   
2.     int x0_x1=x1-x0;
   
3.     int y0_y1=y1-y0;
   
4.     if((x0_x1>0?x0_x1:-x0_x1)>(y0_y1>0?y0_y1:-y0_y1)){
   
5.         //直线趋于水平，故沿x轴逐点描画
   
6.         //保证x0_x1指向x轴正方向
   
7.         if(x0_x1<0){
   
8.             int temp=x0;
   
9.             x0=x1;
   
10.             x1=temp;
    
11.             temp=y0;
    
12.             y0=y1;
    
13.             y1=temp;
    
14.         }
    
15.         fixed k=(INT_TO_FIXED(y1)-INT_TO_FIXED(y0))/(x1-x0);//使用顶点数来代替浮点数，是为了在下面的for循环里避开类型转换
    
16.         fixed y=INT_TO_FIXED(y0);
    
17.         for(int x=x0;x<=x1;x++){
    
18.             *(pt_memBuffer+(x<<2)+(FIXED_TO_INT(y+32768)*5504))=0xff;
    
19.             y+=k;
    
20.         }
    
21.     }
    
22.     else{
    
23.         //直线趋于竖直，故沿y轴逐点描画
    
24.         //确保y0_y1沿y正方向
    
25.         if(y0_y1<0){
    
26.             int temp=x0;
    
27.             x0=x1;
    
28.             x1=temp;
    
29.             temp=y0;
    
30.             y0=y1;
    
31.             y1=temp;
    
32.         }
    
33.         fixed dxdy=(INT_TO_FIXED(x1)-INT_TO_FIXED(x0))/(y1-y0);//使用顶点数来代替浮点数，是为了在下面的for循环里避开类型转换
    
34.         fixed x=INT_TO_FIXED(x0);
    
35.         for(int y=y0;y<=y1;y++){
    
36.             *(pt_memBuffer+(FIXED_TO_INT(x+32768)<<2)+y*5504)=0xff;
    
37.             x+=dxdy;
    
38.         }
    
39.     }
    
40. }

复制代码

再看bresenham算法的一个一部分，对应-1<k<0

1. oid drawLine_brshm(int x0,int y0,int x1,int y1){
   
2.     int x0_x1_int=x1-x0;
   
3.     int y0_y1_int=y1-y0;
   
4.      
   
5.     if((x0_x1_int>0?x0_x1_int:-x0_x1_int)>(y0_y1_int>0?y0_y1_int:-y0_y1_int)){
   
6.         if(x0>x1){
   
7.             EXCHANGE_INT(x0,x1);
   
8.             EXCHANGE_INT(y0,y1);
   
9.         }
   
10.         int _2dx=x0_x1_int<<1;
    
11.         int _2dy=y0_y1_int+y0_y1_int;//may be negative
    
12.         int _2ddx=-x0_x1_int;
    
13.         char*pt_write=pt_memBuffer+(x0<<2)+y0*bytes_w;
    
14.         if(y0>y1){
    
15.             _2dy=-_2dy;//k=-k
    
16.             for(int x=x0;x<=x1;x++){
    
17.                 if(_2ddx>0){
    
18.                     *(pt_write-bytes_w)=0xff;
    
19.                     if(_2ddx>x0_x1_int){
    
20.                         _2ddx-=_2dx;
    
21.                         pt_write-=bytes_w;//affected by y--
    
22.                     }
    
23.                 }
    
24.                 else{
    
25.                     *pt_write=0xff;
    
26.                 }
    
27.                 _2ddx+=_2dy;
    
28.                 pt_write+=4;
    
29.             }
    
30.         }
    
31.     }
    
32. }

复制代码

执行5000*100次，两种算法的开销都在60~70ms，这正常吗？
是不是我的bresenham算法实现的有问题？
欢迎高手指教，如果我交代的信息不够，指出后会第一时间补充！