精确的亚像素画线算法（光栅化算法）

Question

我需要一种算法，它可以（有点）比Bresenham line drawing algorithm 慢，但必须更精确。我的意思是“精确”：每个触摸的像素都应该被打印出来。不多，但也不少！这意味着不能选择使用更粗的线或类似的线，因为会涉及太多像素。我也不需要像asked before 那样的图形框架或类似的东西，我需要算法！该应用程序实际上并不在“图形”中，而是在像素为“图块”的geography area 中。

对我来说主要的问题是我需要亚像素精度，这意味着一条线可以从 0.75/0.33 开始，而不仅仅是像整数值那样从 0/0 开始。在过去的几个小时里，我尝试创建一个可行的解决方案，但无法使其正常工作 - 边缘情况太多。

首先，我认为像 Wu 的算法这样的抗锯齿版本应该可以实现，但它打印的像素太多（尤其是起点和终点），在某些情况下它仍然会丢失一些像素，例如对于非常短的行。

然后我试图让 Bresenham 工作，我将第二个“if”替换为“else if”，正如 here 指出的那样，它更接近但仍然不存在。然后我尝试将 Bresenham 从整数精度移动到浮点精度，这导致了无限循环（因为 x,y 值跳过了结束条件if (y1 == y2 && x1 == x2)）。

我可以使用naive line drawing 解决方案，但我应该使用哪个delta？例如。如果我使用 0.1，我仍然会丢失一些像素，而使用较小的值可能会花费太长时间（并且仍然会丢失像素）。

C/Java/... 中的工作解决方案将不胜感激。至少它应该适用于 octant 1，但完整的解决方案会更好。

更新：我想出了以下想法：使用朴素的线光栅化，您可以为每个点计算 4 个像素候选。然后检查这 4 个像素，如果线真的穿过它们。但我不确定线/框相交是否足够快。

Answer 1

如果您只需要恒定的颜色（不通过使用的像素区域进行插值），请使用 DDA：

void line_DDA_subpixel(int x0,int y0,int x1,int y1,int col) // DDA subpixel -> thick
    {
    int kx,ky,c,i,xx,yy,dx,dy;
    x1-=x0; kx=0; if (x1>0) kx=+1; if (x1<0) { kx=-1; x1=-x1; } x1++;
    y1-=y0; ky=0; if (y1>0) ky=+1; if (y1<0) { ky=-1; y1=-y1; } y1++;
    if (x1>=y1)
     for (c=x1,i=0;i<x1;i++,x0+=kx)
        {
        pnt(x0,y0,col); // this is normal pixel the two below are subpixels 
        c-=y1; if (c<=0) { if (i!=x1-1) pnt(x0+kx,y0,col); c+=x1; y0+=ky; if (i!=x1-1) pnt(x0,y0,col); }
        }
    else
     for (c=y1,i=0;i<y1;i++,y0+=ky)
        {
        pnt(x0,y0,col); // this is normal pixel the two below are subpixels 
        c-=x1; if (c<=0) { if (i!=y1-1) pnt(x0,y0+ky,col); c+=y1; x0+=kx; if (i!=y1-1) pnt(x0,y0,col); }
        }
    }

地点：

void pnt(int x,int y,int col);

是用颜色 col 栅格化像素(x,y) 的例程源代码是 C++

我认为这是海峡前进，但无论如何

DDA 使用参数线方程 y=k*x+q 或 x=ky+q 取决于差异（如果更大 x 或 y 差异，则没有孔）。 k 是 dy/dx 或 dx/dy 并且整个除法减少为循环内的减法+加法（每个循环的最后一行）。这可以很容易地修改为任意数量的维度（我通常使用 7D 或更多）。在现代机器上，速度有时比 Bresenham 更好（取决于平台和使用情况）。

这就是它与简单的 DDA

相比的样子

[edit2]双坐标 //原来是[edit1]

好的，这是新代码：

void line_DDA_subpixel1(double x0,double y0,double x1,double y1,int col)    // DDA subpixel -> thick
    {
    int i,n,x,y,xx,yy;
    // prepare data n-pixels,x1,y1 is line dx,dy step per pixel
    x1-=x0; i=ceil(fabs(x1));
    y1-=y0; n=ceil(fabs(y1));
    if (n<i) n=i; if (!n) n=1;
    x1/=double(n);
    y1/=double(n); n++;
    // rasterize DDA line
    for (xx=x0,yy=y0,i=0;i<=n;i++,x0+=x1,y0+=y1)
        {
        // direct pixel
        pnt(x,y,col);
        // subpixels on change in both axises
        x=x0; y=y0;
        if ((i<n)&&(x!=xx)&&(y!=yy)) { pnt(xx,y,col); pnt(x,yy,col); }
        xx=x; yy=y;
        }
    }

这就是它的样子：

现在角度应该在 double 精度，但 pnt(x,y,col) 仍然是整数！！！

[edit3] 像素网格交叉

void DDAf_line_subpixel(float x0,float y0,float x1,float y1,int col)    // DDA subpixel -> thick
    {
    int i,n; float a,a0,a1,aa,b,d;
    // end-points
    pnt(x0,y0,col);
    pnt(x1,y1,col);
    // x-axis pixel cross
    a0=1; a1=0; n=0;
    if (x0<x1) { a0=ceil(x0); a1=floor(x1); d=(y1-y0)/(x1-x0); a=a0; b=y0+(a0-x0)*d; n=fabs(a1-a0); } else
    if (x0>x1) { a0=ceil(x1); a1=floor(x0); d=(y1-y0)/(x1-x0); a=a0; b=y1+(a0-x1)*d; n=fabs(a1-a0); }
    if (a0<=a1) for (aa=a,i=0;i<=n;i++,aa=a,a++,b+=d) { pnt(aa,b,col); pnt( a,b,col); }
    // y-axis pixel cross
    a0=1; a1=0; n=0;
    if (y0<y1) { a0=ceil(y0); a1=floor(y1); d=(x1-x0)/(y1-y0); a=a0; b=x0+(a0-y0)*d; n=fabs(a1-a0); } else
    if (y0>y1) { a0=ceil(y1); a1=floor(y0); d=(x1-x0)/(y1-y0); a=a0; b=x1+(a0-y1)*d; n=fabs(a1-a0); }
    if (a0<=a1) for (aa=a,i=0;i<=n;i++,aa=a,a++,b+=d) { pnt(b,aa,col); pnt(b, a,col); }
    }

终于有一些时间，所以我稍微调整了 DDA，但 id 导致了许多 ifs，所以我对光栅化进行了相当多的更改。现在计算所有像素网格交叉（交叉点），然后为每个正确的子像素添加。这是它的样子（没有错误的子像素）：

对于每个x 或y 网格线是计算(a,b) 和step 在一个轴上1 像素的第一个交叉点，其余根据dy/dx 或dx/dy 在第二个。在此之后 for 循环填充子像素 ...

Answer 2

如果你的线条很细并且像素是矩形（正方形）：

然后考虑使用体素网格遍历算法，例如，参见 Woo 和 Amanatides 的文章“Fast Voxel Traversal Algorithm...”。

Practical implementation（在网格遍历部分）

回复评论：
X坐标变量的正确初始化（Y相同）

  DX = X2 - X1
  tDeltaX = GridCellWidth / DX
  tMaxX = tDeltaX * (1.0 - Frac(X1 / GridCellWidth)) 
  //Frac if fractional part of float, for example, Frac(1.3) = 0.3

我的回答中的示例here