如何为Bresenham画线算法添加颜色渐变功能？求将StackOverflow相关实现转译为C语言

别担心，基础问题完全没什么不好意思的——咱们一步步来改造你的代码，给它加上平滑的颜色渐变，完美适配你用的0xttrrggbb整数颜色格式。

核心思路 #

渐变的本质是逐像素插值颜色通道：从起点颜色start_color到终点颜色end_color，每画一个像素，就计算当前位置对应的红、绿、蓝、透明度通道值，再合并成你需要的整数格式。

因为你的算法用的是整数运算（Bresenham的核心就是避免浮点），咱们也用整数累加的方式做插值，避免浮点误差。

改造后的完整代码 #

#define sign(x) ((x > 0)? 1 : ((x < 0)? -1: 0))

void draw_gradient_line(int x1, int y1, int x2, int y2, int start_color, int end_color) {
    int x = x1;
    int y = y1;
    int dx = abs(x2 - x1);
    int dy = abs(y2 - y1);
    int s1 = sign(x2 - x1);
    int s2 = sign(y2 - y1);
    int swap = 0;
    int i;

    // 拆分颜色通道：0xttrrggbb → 提取tt, rr, gg, bb
    int tt1 = (start_color >> 24) & 0xFF;
    int rr1 = (start_color >> 16) & 0xFF;
    int gg1 = (start_color >> 8) & 0xFF;
    int bb1 = start_color & 0xFF;

    int tt2 = (end_color >> 24) & 0xFF;
    int rr2 = (end_color >> 16) & 0xFF;
    int gg2 = (end_color >> 8) & 0xFF;
    int bb2 = end_color & 0xFF;

    // 计算每个通道的总差值
    int dtt = tt2 - tt1;
    int drr = rr2 - rr1;
    int dgg = gg2 - gg1;
    int dbb = bb2 - bb1;

    // 颜色插值的误差项（类似Bresenham的D），用整数累加避免浮点
    int err_tt = dx / 2;
    int err_rr = dx / 2;
    int err_gg = dx / 2;
    int err_bb = dx / 2;

    // 当前像素的颜色通道值
    int curr_tt = tt1;
    int curr_rr = rr1;
    int curr_gg = gg1;
    int curr_bb = bb1;

    if (dy > dx) {
        int temp = dx;
        dx = dy;
        dy = temp;
        swap = 1;
    }
    int D = 2*dy - dx;

    for (i = 0; i < dx; i++) {
        // 合并当前通道值为0xttrrggbb格式，绘制像素
        int curr_color = (curr_tt << 24) | (curr_rr << 16) | (curr_gg << 8) | curr_bb;
        display_pixel(x, y, curr_color); // 注意这里修改display_pixel，传入颜色参数

        // 更新颜色通道（插值逻辑）
        err_tt += dtt;
        if (err_tt >= dx) {
            curr_tt += sign(dtt);
            err_tt -= dx;
        }

        err_rr += drr;
        if (err_rr >= dx) {
            curr_rr += sign(drr);
            err_rr -= dx;
        }

        err_gg += dgg;
        if (err_gg >= dx) {
            curr_gg += sign(dgg);
            err_gg -= dx;
        }

        err_bb += dbb;
        if (err_bb >= dx) {
            curr_bb += sign(dbb);
            err_bb -= dx;
        }

        // 原Bresenham的坐标更新逻辑
        while (D >= 0) {
            D = D - 2*dx;
            if (swap) x += s1;
            else y += s2;
        }
        D = D + 2*dy;
        if (swap) y += s2;
        else x += s1;
    }
    // 别忘了画最后一个像素（如果循环没覆盖到的话）
    int final_color = (tt2 << 24) | (rr2 << 16) | (gg2 << 8) | bb2;
    display_pixel(x2, y2, final_color);
}

关键部分解释 #

1. 颜色通道拆分与合并：

   • 用移位和位掩码把0xttrrggbb格式的整数拆成四个8位通道：透明度(tt)、红(rr)、绿(gg)、蓝(bb)。
   • 绘制时再把四个通道移位合并回整数格式，传给display_pixel（这里假设你需要修改display_pixel函数，让它接受颜色参数）。

2. 整数颜色插值：

   • 每个通道用一个误差项err_*来跟踪累计偏移，每一步把通道差值加到误差项里。
   • 当误差项超过总步数dx时，就把当前通道值调整1（加或减，根据差值的正负），同时把误差项减去dx——这和Bresenham算法处理坐标的逻辑完全一致，保证插值平滑且无浮点运算。

3. 最后一个像素：因为循环只执行dx次，可能会漏掉终点像素，所以最后单独画一次终点颜色，确保渐变完整。

使用示例 #

比如你想从红色(0xFFff0000)渐变到蓝色(0xFF0000ff)，调用方式就是：

draw_gradient_line(10, 10, 100, 100, 0xFFff0000, 0xFF0000ff);

内容的提问来源于stack exchange，提问作者MiguelP