比使用 Bresenham 算法更好的线路选择？

Question

我在 HTML canvas 上画线，并使用不太精确的二维数组（表示 10x10 像素的块），其中我 'draw' 使用 Bresenham 算法画线存储 line-ids，这样我就可以使用该数组来查看选择了哪一行。

这行得通，但我希望它更准确 - 不是我使用的 10x10 大小（我喜欢这样，我不必完全点击该行），但是当我绘制一个表示时该数组覆盖我的实际 canvas，我看到有很多 10x10 块未填充，即使线穿过它们：

有更好的解决办法吗？我想要的是捕获实际线穿过的所有网格块。

Answer 1

您最好的选择是将鼠标光标位置视为一个小圆圈（f.e。半径为 5 像素）并检查该线是否与该圆圈相交。

使用此 Q&A

中解释的数学

JavaScript

检测交叉点的简单函数是：

function lineCircleIntersects(x1, y1, x2, y2, cx, cy, cr) {
    var dx = x2 - x1,
        dy = y2 - y1,
        a = dx * dx + dy * dy,
        b = 2 * (dx * (x1 - cx) + dy * (y1 - cy)),
        c = cx * cx + cy * cy,
        bb4ac;

    c += x1 * x1 + y1 * y1;
    c -= 2 * (cx * x1 + cy * y1);
    c -= cr * cr;
    bb4ac = b * b - 4 * a * c;

    return bb4ac >= 0;  // true: collision, false: no collision
}

看到它在这个 jsFiddle 中起作用，但请注意，如果光标位于 [x1, y1] 之外的直线的斜率上，此函数也会 return true， [x2, y2]。我会把这个留给你:)

您也可以尝试 line-circle-collision library on github，这应该能满足您的需求。

Answer 2

没有看到您的代码，我认为您在使用 Bresenham 算法填充查找 table 时出现了舍入错误，或者您在运行算法之前缩放了坐标。

这个 jsFiddle 显示了我的想法，并且正方形完全对齐。

HTML

<canvas id="myCanvas"></canvas>

CSS

#myCanvas {
    width: 250px;
    height: 250px;
}

JavaScript

var $canvas = $("#myCanvas"),
    ctx = $canvas[0].getContext("2d");

ctx.canvas.width = $canvas.width();
ctx.canvas.height = $canvas.height();

function Grid(ctx) {
    this._ctx = ctx;
    this._lines = [];
    this._table = [];
    this._tableScale = 10;
    this._createLookupTable();
}
Grid.prototype._createLookupTable = function() {
    this._table = [];
    for (var y = 0; y < Math.ceil(ctx.canvas.height / this._tableScale); y++) {
        this._table[y] = [];
        for (var x = 0; x < Math.ceil(ctx.canvas.width / this._tableScale); x++)
            this._table[y][x] = null;
    }
};
Grid.prototype._updateLookupTable = function(line) {
    var x0 = line.from[0],
        y0 = line.from[1],
        x1 = line.to[0],
        y1 = line.to[1],
        dx = Math.abs(x1 - x0),
        dy = Math.abs(y1 - y0),
        sx = (x0 < x1) ? 1 : -1,
        sy = (y0 < y1) ? 1 : -1,
        err = dx - dy;
    while(true) {
        this._table[Math.floor(y0 / 10)][Math.floor(x0 / 10)] = line;
        if ((x0 == x1) && (y0 == y1)) break;
        var e2 = 2 * err;
        if (e2 >- dy) { err -= dy; x0 += sx; }
        if (e2 < dx) { err += dx; y0 += sy; }
    }    
};
Grid.prototype.hitTest = function(x, y) {
    var ctx = this._ctx,
        hoverLine = this._table[Math.floor(y / 10)][Math.floor(x / 10)];
    ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
    this._lines.forEach(function(line) {
        line.draw(ctx, line === hoverLine ? "red" : "black");
    });
};
Grid.prototype.drawLookupTable = function() {
    ctx.beginPath();
    for (var y = 0; y < this._table.length; y++)
        for (var x = 0; x < this._table[y].length; x++) {
            if (this._table[y][x])
                ctx.rect(x * 10, y * 10, 10, 10);
        }
    ctx.strokeStyle = "rgba(0, 0, 0, 0.2)";
    ctx.stroke();
};
Grid.prototype.addLine = function(line) {
    this._lines.push(line);
    this._updateLookupTable(line);
};
Grid.prototype.draw = function() {
    var ctx = this._ctx;
    ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
    this._lines.forEach(function(line) {
        line.draw(ctx);
    });
};

function Line(x0, y0, x1, y1) {
    this.from = [ x0, y0 ];
    this.to = [ x1, y1];
}
Line.prototype.draw = function(ctx, style) {
    ctx.beginPath();
    ctx.moveTo(this.from[0], this.from[1]);
    ctx.lineTo(this.to[0], this.to[1]);
    ctx.strokeStyle = style || "black";
    ctx.stroke();
};

var grid = new Grid(ctx);
grid.addLine(new Line(80, 10, 240, 75));
grid.addLine(new Line(150, 200, 50, 45));
grid.addLine(new Line(240, 10, 20, 150));
grid.draw();
grid.drawLookupTable();

$canvas.on("mousemove", function(e) {
    grid.hitTest(e.offsetX, e.offsetY);
    grid.drawLookupTable();
});

比使用 Bresenham 算法更好的线路选择？

Better line selection than using Bresenham algorithm?

javascript

canvas

bresenham