Como generalizo o algoritmo de linha de Bresenham para pontos finais de ponto flutuante?

Estou tentando combinar duas coisas. Estou escrevendo um jogo e preciso determinar os quadrados da grade em uma linha com os pontos finais de ponto flutuante.

Além disso, preciso incluir todos os quadrados da grade em que toca (ou seja, não apenas a linha de Bresenham, mas a linha azul):

Alguém pode me oferecer alguma idéia de como fazer isso? A solução óbvia é usar o algoritmo de linha ingênuo, mas há algo mais otimizado (mais rápido)?

Você está procurando um algoritmo de deslocamento de grade. Este artigo fornece uma boa implementação;

Aqui está a implementação básica em 2D encontrada no artigo:

loop {
    if(tMaxX < tMaxY) {
        tMaxX= tMaxX + tDeltaX;
        X= X + stepX;
    } else {
        tMaxY= tMaxY + tDeltaY;
        Y= Y + stepY;
    }
    NextVoxel(X,Y);
}

Há também uma versão 3D de projeção de raios no papel.

Caso o link apodreça , você poderá encontrar muitos espelhos com seu nome: Um algoritmo transversal voxel mais rápido para rastreamento de raios .

A ideia de Blue é boa, mas a implementação é um pouco desajeitada. De fato, você pode fazer isso facilmente sem o sqrt. Vamos supor que você exclua casos degenerados ( BeginX==EndX || BeginY==EndY) e se concentre apenas nas direções da linha no primeiro quadrante BeginX < EndX && BeginY < EndY. Você também precisará implementar uma versão para pelo menos outro quadrante, mas isso é muito semelhante à versão do primeiro quadrante - você só verifica outras arestas. No pseudo-código C'ish:

int cx = floor(BeginX); // Begin/current cell coords
int cy = floor(BeginY);
int ex = floor(EndX); // End cell coords
int ey = floor(EndY);

// Delta or direction
double dx = EndX-BeginX;
double dy = EndY-BeginY;

while (cx < ex && cy < ey)
{
  // find intersection "time" in x dir
  float t0 = (ceil(BeginX)-BeginX)/dx;
  float t1 = (ceil(BeginY)-BeginY)/dy;

  visit_cell(cx, cy);

  if (t0 < t1) // cross x boundary first=?
  {
    ++cx;
    BeginX += t0*dx;
    BeginY += t0*dy;
  }
  else
  {
    ++cy;
    BeginX += t1*dx;
    BeginY += t1*dy;
  }
}

Agora, para outros quadrantes, basta alterar a condição ++cxou ++cye do loop. Se você usar isso para colisão, provavelmente precisará implementar todas as 4 versões; caso contrário, poderá se safar de duas trocando adequadamente os pontos inicial e final.

Sua suposição não é necessariamente encontrar as células, mas as linhas que ela cruza nesta grade.

Por exemplo, tirando sua imagem, podemos destacar não as células, mas as linhas da grade que ela cruza:

Isso mostra que, se cruzar uma linha de grade, as células de ambos os lados dessa linha são aquelas preenchidas.

Você pode usar um algoritmo de interseção para descobrir se sua linha de ponto flutuante os cruzará escalando seus pontos em pixels. Se você tiver uma proporção de 1,0: 1 de coordenadas flutuantes: pixels, será classificada e poderá traduzi-la diretamente. Usando o algoritmo de interseção do segmento de linha, você pode verificar se a linha inferior esquerda (1,7) (2,7) cruza com a linha (1.3,6.2) (6.51,2.9).http://alienryderflex.com/intersect/

Alguma tradução de c para C # será necessária, mas você pode obter a ideia nesse documento. Colocarei o código abaixo, caso o link seja quebrado.

//  public domain function by Darel Rex Finley, 2006

//  Determines the intersection point of the line defined by points A and B with the
//  line defined by points C and D.
//
//  Returns YES if the intersection point was found, and stores that point in X,Y.
//  Returns NO if there is no determinable intersection point, in which case X,Y will
//  be unmodified.

bool lineIntersection(
double Ax, double Ay,
double Bx, double By,
double Cx, double Cy,
double Dx, double Dy,
double *X, double *Y) {

  double  distAB, theCos, theSin, newX, ABpos ;

  //  Fail if either line is undefined.
  if (Ax==Bx && Ay==By || Cx==Dx && Cy==Dy) return NO;

  //  (1) Translate the system so that point A is on the origin.
  Bx-=Ax; By-=Ay;
  Cx-=Ax; Cy-=Ay;
  Dx-=Ax; Dy-=Ay;

  //  Discover the length of segment A-B.
  distAB=sqrt(Bx*Bx+By*By);

  //  (2) Rotate the system so that point B is on the positive X axis.
  theCos=Bx/distAB;
  theSin=By/distAB;
  newX=Cx*theCos+Cy*theSin;
  Cy  =Cy*theCos-Cx*theSin; Cx=newX;
  newX=Dx*theCos+Dy*theSin;
  Dy  =Dy*theCos-Dx*theSin; Dx=newX;

  //  Fail if the lines are parallel.
  if (Cy==Dy) return NO;

  //  (3) Discover the position of the intersection point along line A-B.
  ABpos=Dx+(Cx-Dx)*Dy/(Dy-Cy);

  //  (4) Apply the discovered position to line A-B in the original coordinate system.
  *X=Ax+ABpos*theCos;
  *Y=Ay+ABpos*theSin;

  //  Success.
  return YES; }

Se você precisar descobrir apenas quando (e onde) os segmentos de linha se cruzam, você pode modificar a função da seguinte maneira:

//  public domain function by Darel Rex Finley, 2006  

//  Determines the intersection point of the line segment defined by points A and B
//  with the line segment defined by points C and D.
//
//  Returns YES if the intersection point was found, and stores that point in X,Y.
//  Returns NO if there is no determinable intersection point, in which case X,Y will
//  be unmodified.

bool lineSegmentIntersection(
double Ax, double Ay,
double Bx, double By,
double Cx, double Cy,
double Dx, double Dy,
double *X, double *Y) {

  double  distAB, theCos, theSin, newX, ABpos ;

  //  Fail if either line segment is zero-length.
  if (Ax==Bx && Ay==By || Cx==Dx && Cy==Dy) return NO;

  //  Fail if the segments share an end-point.
  if (Ax==Cx && Ay==Cy || Bx==Cx && By==Cy
  ||  Ax==Dx && Ay==Dy || Bx==Dx && By==Dy) {
    return NO; }

  //  (1) Translate the system so that point A is on the origin.
  Bx-=Ax; By-=Ay;
  Cx-=Ax; Cy-=Ay;
  Dx-=Ax; Dy-=Ay;

  //  Discover the length of segment A-B.
  distAB=sqrt(Bx*Bx+By*By);

  //  (2) Rotate the system so that point B is on the positive X axis.
  theCos=Bx/distAB;
  theSin=By/distAB;
  newX=Cx*theCos+Cy*theSin;
  Cy  =Cy*theCos-Cx*theSin; Cx=newX;
  newX=Dx*theCos+Dy*theSin;
  Dy  =Dy*theCos-Dx*theSin; Dx=newX;

  //  Fail if segment C-D doesn't cross line A-B.
  if (Cy<0. && Dy<0. || Cy>=0. && Dy>=0.) return NO;

  //  (3) Discover the position of the intersection point along line A-B.
  ABpos=Dx+(Cx-Dx)*Dy/(Dy-Cy);

  //  Fail if segment C-D crosses line A-B outside of segment A-B.
  if (ABpos<0. || ABpos>distAB) return NO;

  //  (4) Apply the discovered position to line A-B in the original coordinate system.
  *X=Ax+ABpos*theCos;
  *Y=Ay+ABpos*theSin;

  //  Success.
  return YES; }

float difX = end.x - start.x;
float difY = end.y - start.y;
float dist = abs(difX) + abs(difY);

float dx = difX / dist;
float dy = difY / dist;

for (int i = 0, int x, int y; i <= ceil(dist); i++) {
    x = floor(start.x + dx * i);
    y = floor(start.y + dy * i);
    draw(x,y);
}
return true;

Demonstração JS:

//C# stackoverflow

function verifyLoS(start, end) {
    var difX = end.x - start.x;
    var difY = end.y - start.y;
	var dist = Math.abs(difX) + Math.abs(difY);

    var dx = difX / dist;
    var dy = difY / dist;

    for (var i = 0, x, y; i <= Math.ceil(dist); i++) {
        x = Math.floor(start.x + dx * i);
        y = Math.floor(start.y + dy * i);
        draw(x,y);
    }
    return true;
}

var HEIGHT = 14,
    WIDTH = 14,
    PX = 32;

var canvas, ctx;

function main () {
  canvas = document.getElementById("canvas");
  ctx = canvas.getContext("2d");
  
  canvas.height = HEIGHT * PX;
  canvas.width = WIDTH * PX;

  loop();
}

function loop() {
  for (var x=0;x<HEIGHT; x++) {
    for (var y=0; y<WIDTH; y++) {
      ctx.fillStyle = ((x+y)%2===0)?"#AFA":"#AEA";
      ctx.fillRect(x*PX,y*PX,PX,PX);
    }
  }
  var a = {x:1.5, y:9.5},
      b = {x:12.5, y:1.5};
  verifyLoS(a, b);
  ctx.beginPath();
  ctx.moveTo(a.x*PX,a.y*PX);
  ctx.lineTo(b.x*PX,b.y*PX);
  ctx.stroke();
  //window.requestAnimationFrame(loop);
}

function draw(x, y) {
    ctx.fillStyle = "rgba(255,0,0,0.2)";
    ctx.fillRect(x*PX,y*PX,PX,PX);
}

main();

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>JS Bin</title>
</head>
<body>
  <canvas id="canvas"></canvas>
</body>
</html>

Encontrei o mesmo problema hoje e fiz uma grande montanha de espaguete de uma colina, mas acabei com algo que funciona: https://github.com/SnpM/Pan-Line-Algorithm .

No Leiame:

O conceito central desse algoritmo é semelhante ao de Bresenham, na medida em que ele aumenta em 1 unidade em um eixo e testa o aumento no outro eixo. As frações tornam o incremento consideravelmente mais difícil, no entanto, e muitas pizzas precisam ser adicionadas. Por exemplo, incrementar de X = 0,21 a X = 1,21 com uma inclinação de 5 cria um problema complexo (padrões de coordenadas entre esses números desagradáveis é difícil de prever), mas aumentar de 1 para 2 com uma inclinação de 5 facilita o problema. O padrão de coordenadas entre números inteiros é muito fácil de resolver (apenas uma linha perpendicular ao eixo de incremento). Para obter o problema mais fácil, o incremento é deslocado para um número inteiro com todos os cálculos feitos separadamente para a peça fracionária. Então, em vez de iniciar o incremento em 0,21,

O Leia-me explica a solução muito melhor que o código. Estou pensando em revisá-lo para ser menos indutor de dor de cabeça.

Sei que estou com um ano de atraso para essa pergunta, mas espero que isso chegue a outras pessoas que estão procurando uma solução para esse problema.