理解Bresenham算法

Bresenham算法

• 算法用途：高效的进行直线或圆的栅格化

问题建模

1. 给定起始点$(x_0,y_0)$和终点$(x_1,y_1)$，且满足$x_1 > x_0$，斜率为$k=\frac{\Delta{y}}{\Delta{x}}$

2. 使选择的像素，满足到直线$y=mx+b$的垂直误差最小。

3. 设当前的像素点为$(x_k,y_k)$，下一个候选点为：

   • 右邻居$H(x_k+1, y_k)$
   • 右上邻居$V(x_k+1, y_k+1)$

4. 定义垂直距离偏差：

   • $d_{lower}=y_{real} - y_k = m(x_k + 1) + b - y_k$
   • $d_{upper}=(y_k + 1)-y_{real} = y_k + 1 - m(x_k + 1) - b$

5. 选择依据：比较$d_{lower}与$d_{upper}，选择较小一方为对应的点。

6. 设定用于决策的变量:

   $$p_k=\Delta{x}(d_{lower}-d_{upper}) \\ = 2y_{real} - 2y_k - 1 \\ = 2\Delta{y}(x_k+1) - 2\Delta{x}b - 2\Delta{x}y_k - \Delta{x} \\ = 2\Delta{y}x_k - 2\Delta{x}y_k + (2\Delta{y}-2\Delta{x}b-\Delta{x})$$

   后面括号括起来的部分为常量。

7. 为了消除浮点预算，构建递推关系，构建过程如下：

   $$p_{k+1}-p_{k} = 2\Delta{y}x_{k+1}-2\Delta{x}y_{k+1}-2\Delta{y}x_k+2\Delta{x}y_k \\ = 2\Delta{y}(x_k + 1)- 2\Delta{y}x_k + 2\Delta{x}y_k-2\Delta{x}y_{k+1} \\ = 2\Delta{y} - 2\Delta{x}(y_{k+1}-y_{k})$$

   递推的关系长这样：$p_{k+1} = p_{k} + 2\Delta{y} - 2\Delta{x}(y_{k+1}-y_{k})$

   • 当$p_{k} > 0$时，$y_{k+1} = y_{k} + 1$，则$p_{k+1}=p_{k}+2\Delta{y}-2\Delta{x}$
   • 当$p_{k} < 0$时，$y_{k+1} = y_{k}$，则$p_{k+1}=p_{k}+2\Delta{y}$

8. 递推的初始值： $p_0 = 2\Delta{y}-\Delta{x}$

算法流程

根据上述建模过程，有如下流程：

1. 计算$\Delta{x},\Delta{y}$
2. 比较$|\Delta{x}|,|\Delta{y}|$，取大的那个为增长方向。以$x$为增长方向为例。
3. 从$p_0$出发，初始误差设为$e=-\Delta{x}$。
   每当$x = x+1$, $e=e+2\Delta{y}$。若$e>0$，则$y=y+1$，$e=e-2\Delta{x}$。
4. 重复1，2，3，直到到达$p_1$

代码实现

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;

struct Point
{
    int x;
    int y;
};

vector<Point> BresenhamFilling(const Point& p1, const Point&p2)
{
    vector<Point> points;
    int dx = p2.x - p1.x;
    int dy = p2.y - p1.y;
    int ux = dx > 0 ? 1 : -1;
    int uy = dy > 0 ? 1 : -1;
    dx = abs(dx);
    dy = abs(dy);
    int x = p1.x;
    int y = p1.y;
    if (dx > dy) // 以x为增量
    {
        int e = -dx; 
        for (int i = 0; i < dx; ++i)
        {
            x += ux;
            e += 2 * dy;
            if (e >= 0)
            {
                y += uy;
                e -= 2 * dx;
            }
            if (x != p2.x && y != p2.y)
            {
                points.push_back({x, y});
            }
        }
    }
    else // 以y为增量
    {
        int e = -dy;
        for (int i = 0; i < dy; i++)
        {
            y += uy;
            e += 2 * dx;
            if (e >= 0)
            {
                x += ux;
                e -= 2 * dy;
            }
            if (x != p2.x || y != p2.y)
            {
                points.push_back({x, y});
            }
        }
    }
    return points;
}