在两点之间画一条线

Question

这是我到目前为止所得到的。我重写了代码以简化一些事情。以前的代码实际上并不是真正的基本算法。它有我不需要的绒毛。我回答了关于音高的问题，下面你会看到我测试结果的一些图像。

local function Line (buf, x1, y1, x2, y2, color, pitch)

    -- identify the first pixel
    local n = x1 + y1 * pitch

    -- // difference between starting and ending points
    local dx = x2 - x1;
    local dy = y2 - y1;

    local m = dy / dx
    local err = m - 1

    if (dx > dy) then   -- // dx is the major axis
        local j = y1
        local i = x1
        while i < x2 do
            buf.buffer[j * pitch + i] = color
            if (err >= 0) then
                i = i + 1
                err = err - 1
            end
            j = j + 1
            err = err + m
        end
    else        -- // dy is the major axis
        local j = x1
        local i = y1
        while i < y2 do
            buf.buffer[i * pitch + j] = color
            if (err >= 0) then
                i = i + 1
                err = err - 1
            end
            j = j + 1
            err = err + m
        end
    end
end


-- (visdata[2][1][576], int isBeat, int *framebuffer, int *fbout, int w, int h
function LibAVSSuperScope:Render(visdata, isBeat, framebuffer, fbout, w, h)
    local size = 5

    Line (self.buffer, 0, 0, 24, 24, 0xffff00, 24)
    do return end
end

编辑：哦，我刚刚意识到了什么。 0,0位于左下角。所以函数的工作类型，但它是重叠和倾斜的。

Edit2：

是的，整件事都破了。我将数字插入Line（）并得到所有类型的结果。让我告诉你一些。

这是Line (self.buffer, 0, 0, 23, 23, 0x00ffff, 24 * 2)

这里是Line (self.buffer, 0, 1, 23, 23, 0x00ffff, 24 * 2)

编辑：哇，做Line (self.buffer, 0, 24, 24, 24, 0x00ffff, 24 * 2)会占用太多的CPU时间。

编辑：这是使用此算法的另一个图像。黄点是起点。

Line (self.buffer, 0, 0, 24, 24, 0xff0000, 24)
Line (self.buffer, 0, 12, 23, 23, 0x00ff00, 24)
Line (self.buffer, 12, 0, 23, 23, 0x0000ff, 24)

编辑：是的，那条蓝线包裹着。

Answer 1

这个有效。

Line (self.buffer, 0, 0, 23, 23, 0xff0000, 24 * 2)
Line (self.buffer, 0, 5, 23, 23, 0x00ff00, 24)
Line (self.buffer, 12, 0, 23, 23, 0x0000ff, 24)

-

local function Line (buf, x0, y0, x1, y1, color, pitch)
    local dx = x1 - x0;
    local dy = y1 - y0;

    buf.buffer[x0 + y0 * pitch] = color
    if (dx ~= 0) then
        local m = dy / dx;
        local b = y0 - m*x0;
        if x1 > x0 then
            dx = 1
        else
            dx = -1
        end
        while x0 ~= x1 do
            x0 = x0 + dx
            y0 = math.floor(m*x0 + b + 0.5);
            buf.buffer[x0 + y0 * pitch] = color
        end

    end
end

这是螺旋式的。

下面的一个像音乐可视化一样跳舞，但我们只是随意提供数据。我认为线路质量可能更好。

Answer 2

这就是我所确定的。我只需要找到关于Bresenham算法的有效信息。感谢information about various line algorithms, from simple to complex的cs-unc。

function LibBuffer:Line4(x0, y0, x1, y1, color, pitch)
    local dx = x1 - x0;
    local dy = y1 - y0;
    local stepx, stepy

    if dy < 0 then
        dy = -dy
        stepy = -1
    else
        stepy = 1
    end

    if dx < 0 then
        dx = -dx
        stepx = -1
    else
        stepx = 1
    end

    self.buffer[x0 + y0 * pitch] = color
    if dx > dy then
        local fraction = dy - bit.rshift(dx, 1)
        while x0 ~= x1 do
            if fraction >= 0 then
                y0 = y0 + stepy
                fraction = fraction - dx
            end
            x0 = x0 + stepx
            fraction = fraction + dy
            self.buffer[floor(y0) * pitch + floor(x0)] = color
        end
    else
        local fraction = dx - bit.rshift(dy, 1)
        while y0 ~= y1 do
            if fraction >= 0 then
                x0 = x0 + stepx
                fraction = fraction - dy
            end
            y0 = y0 + stepy
            fraction = fraction + dx
            self.buffer[floor(y0) * pitch + floor(x0)] = color
        end
    end
end

这就是这个看起来的样子。