一文理解Bresenham‘s line algorithm

Bresenham’s line algorithm

Task：给定两点，在位图中绘制线条。

思路起点(二维线段参数方程)

线段的参数方程
$$\begin{gathered} 设线段两端点为A(x_1,y_1)和B(x_2,y_2)，则该线段的参数方程可以写为 \\ \{\begin{array}{l}x=x_1+t(x_2-x_1),\\ y=y_1+t(y_2-y_1),\end{array}t\in [0,1]. \\ 其中，当t=0时，点在A；当t=1时，点在B； \\ 而t取[0,1]内的值时，表示A到B之间的所有点。 \\ 对于三维空间中的线段，若端点为A(x_1,y_1,z_1)和B(x_2,y_2,z_2)，参数方程扩展为 \\ \{\begin{array}{l}x=x_1+t(x_2-x_1),\\ y=y_1+t(y_2-y_1),\\ z=z_1+t(z_2-z_1),\end{array}t\in [0,1]. \end{gathered}$$
这种参数方程表示方法简洁直观，常用于几何、物理和计算机图形学等领域。

自定义绘制精度

代码实现

void DrawLine(const int ax, const int ay, const int bx, const int by, const Vec3 &color)
{
    for (float t = 0.; t < 1.; t += .002)
    {
        int x = std::round(ax + (bx - ax) * t);
        int y = std::round(ay + (by - ay) * t);
        SetColor(x, y, color);
    }
}

存在问题

当t定义的精度不满足绘制线段长度时(采样率不够)，线段会出现”间隙“。固定的精度没法适应多样的绘制情况，如果t值精度根据屏幕分辨率设置为最大情况会浪费性能。

尝试优化：线段长度适应性精度(欧氏距离)

由于前述问题，下面是根据两点长度调整精度的思路实现。

代码实现

void DrawLine(const int ax, const int ay, const int bx, const int by, const Vec3 &color)
{   
    // 基于线段距离采样的画线算法
    const float d = sqrtf((bx - ax) * (bx - ax) + (by - ay) * (by - ay));
    const float h = 1.0f / d;
    const int cnt = (int)(d + 0.5f);

    const float stepX = (bx - ax) * h;
    const float stepY = (by - ay) * h;
    for (int t = 0; t < cnt; t++)
    {
        int x = (int)(ax + t * stepX + 0.5f);
        int y = (int)(ay + t * stepY + 0.5f);
        SetColor(x, y, color);
    }
}

存在问题

效果勉强，性能欠佳。一是最长的线段由于浮点乘法运算累积的误查导致”锯齿“明显。二是循环中存在浮点乘法运算。

尝试消除浮点乘法运算，以细粒度控制局部误差。

直接来看Bresenham's line algorithm是怎么做的。

Bresenham画线算法

基于整数增量误差原理消除浮点运算。Bresenham 算法的核心是通过整数运算和误差累积，选择最接近理想直线的像素点。

数学推导

以直线斜率 ( 0 ≤ m ≤ 1 )为例 。

问题定义
$$\begin{gathered} 给定起点(x_0,y_0)和终点(x_1,y_1)，其中(x_0,y_0,x_1,y_1\in Z_{\ast }) \\ 绘制一条直线，满足\Delta x=x_1-x_0>0，且斜率m=\frac{\Delta y}{\Delta x}，其中(0\le m\le 1)。 \end{gathered}$$
定义理想直线方程
$$\begin{gathered} y=m(x-x_0)+y_0 \\ 当x=x_k+1时，理想y坐标为： \\ {y}_{\text{ideal}}=m(x_k+1-x_0)+y_0 \end{gathered}$$
定义当前像素与候选像素

$$\begin{gathered} 假设当前绘制的像素为(x_k,y_k)，下一步可能的候选像素为： \\ \text{候选像素}A：(x_k+1,y_k)(不增加y) \\ \text{候选像素}B：(x_k+1,y_k+1)(增加y) \end{gathered}$$

任务决策转化

这样，我们的问题变成:从起点开始，每次沿 x 方向步进 1 单位，确定是否需要沿 y 方向步进 1 单位。
那么如何做决策呢，谁离理想直线更近就选谁，引入误差量化二者分别的接近程度。

定义误差项
$$\begin{gathered} 利用二分思想定义候选像素A和B的中点为C(x_k+1,y_k+0.5)。 \\ 定义误差项e_k=y_{\text{ideal}}-(y_k+0.5)，表示理想点与C的垂直距离关系。 \\ 根据e_k的符号，我们可以判断理想点离A，B中的谁更近。 \\ 不妨乘以2\Delta x消除浮点运算及分母，整理后可以得到： \\ {e}_k=2\Delta x\cdot \left(y_{\text{ideal}}-y_k-0.5\right) \\ 根据误差项e_k，决定选择候选像素A或B： \\ 若e_k<0：选择像素A(不增加y)。 \\ 若e_k\ge 0：选择像素B(增加y)。 \end{gathered}$$

误差项递推公式
$$\begin{gathered} 根据第k次选择不同得到误差递推关系: \\ 若选择像素A(不增加y)：e_{k+1}=2\Delta x\cdot \left(y_{\text{ideal}(k+1)}-y_k-0.5\right) \\ 由于y_{\text{ideal}(k+1)}=y_{\text{ideal}(k)}+m，代入后化简得：e_{k+1}=e_k+2\Delta y \\ 若选择像素B(增加y)：e_{k+1}=2\Delta x\cdot \left(y_{\text{ideal}(k+1)}-(y_k+1)-0.5\right) \\ 化简后得：e_{k+1}=e_k+2\Delta y-2\Delta x \end{gathered}$$

误差项迭代规则

• 选择像素A（不增加 y ）：
  $$e_{k+1}=e_k+2\Delta y$$

• 选择像素B（增加 y ）：
  $$e_{k+1}=e_k+2\Delta y-2\Delta x$$

初始误差项
$$\begin{gathered} 初始时x=x_0，理想直线在y=y_0，此时： \\ \{\begin{array}{c}{e}_1=2\Delta x\cdot \left(y_{\text{ideal}(1)}-y_0-0.5\right),\\ y_{\text{ideal}(1)}=y_{\text{ideal}(0)}+m,\\ y_{\text{ideal}(0)}=y_0\end{array}\Rightarrow e_1=2\Delta y-\Delta x \end{gathered}$$

扩展到所有八分圆

$$上述推导假设0\le m\le 1且\Delta x>0。对于其他情况：$$

$$\begin{gathered} \text{斜率}m>1：交换x和y的角色，沿y方向步进。 \\ \text{负斜率}：调整步进方向为-1。 \\ \text{反向绘制}(\Delta x<0)：交换起点和终点。 \end{gathered}$$

思路要点总结

• 误差项 ( e )：二分思想量化理想直线与候选像素的位置关系。
• 整数运算：通过乘以常数2△x消除分母，全程无浮点运算。
• 动态调整：误差项累积和修正确保路径始终最接近理想直线。

代码实现

// Bresenham's line algorithm
void DrawLine(int ax, int ay, int bx, int by, const Vec3 &color)
{
    int dx = std::abs(bx - ax);
    int dy = std::abs(by - ay);
    bool steep = false;
    // 斜率绝对值是否大于1
    if (dx < dy)
    {
        std::swap(ax, ay);
        std::swap(bx, by);
        std::swap(dx, dy);
        steep = true;
    }
    // deltaX符号
    if (bx - ax < 0)
    {
        std::swap(ax, bx);
        std::swap(ay, by);
    }

    const int stepY = (ay < by) ? 1 : -1;
    int e = 2 * dy - dx;
    if (steep)
    {
        for (int x = ax, y = ay; x <= bx; x++)
        {
            SetColor(y, x, color);
            if (e >= 0)
            {
                y += stepY;
                e -= 2 * dx;
            }
            e += 2 * dy;
        }
    }
    else
    {
        for (int x = ax, y = ay; x <= bx; x++)
        {
            SetColor(x, y, color);
            if (e >= 0)
            {
                y += stepY;
                e -= 2 * dx;
            }
            e += 2 * dy;
        }
    }
}

Reference

Bresenham’s line Algorithm wikipedia