¿Cómo generalizo el algoritmo de línea de Bresenham a puntos finales de punto flotante?

Estoy tratando de combinar dos cosas. Estoy escribiendo un juego y necesito determinar los cuadrados de la cuadrícula que se encuentran en una línea con los puntos finales de punto flotante.

Además, necesito que incluya todos los cuadrados de cuadrícula que toca (es decir, no solo la línea de Bresenham sino la azul):

¿Alguien puede ofrecerme alguna idea sobre cómo hacerlo? La solución obvia es usar un algoritmo de línea ingenuo, pero ¿hay algo más optimizado (más rápido)?

Está buscando un algoritmo transversal de cuadrícula. Este documento ofrece una buena implementación;

Aquí está la implementación básica en 2D que se encuentra en el documento:

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

También hay una versión de proyección de rayos 3D en el papel.

En caso de que el enlace se pudra , puede encontrar muchos espejos con su nombre: un algoritmo de recorrido de voxel más rápido para el trazado de rayos .

La idea de Blue es buena, pero la implementación es un poco torpe. De hecho, puede hacerlo fácilmente sin sqrt. Supongamos por el momento que excluye casos degenerados ( BeginX==EndX || BeginY==EndY) y nos enfocamos solo en las direcciones de línea en el primer cuadrante, entonces BeginX < EndX && BeginY < EndY. También tendrá que implementar una versión para al menos otro cuadrante, pero es muy similar a la versión para el primer cuadrante: solo verifica otros bordes. En el pseudocó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;
  }
}

Ahora, para otros cuadrantes, que acaba de cambiar la ++cxo ++cyy la condición del bucle. Si usa esto para colisión, es probable que tenga que implementar las 4 versiones, de lo contrario, puede salirse con dos intercambiando adecuadamente los puntos de inicio y finalización.

Su suposición no es necesariamente encontrar las celdas sino las líneas que cruza en esta cuadrícula.

Por ejemplo, al tomar su imagen, podemos resaltar no las celdas, sino las líneas de la cuadrícula que cruza:

Esto muestra que si cruza una línea de cuadrícula, las celdas a cada lado de esta línea son las que están rellenas.

Puede usar un algoritmo de intersección para encontrar si su línea de coma flotante los cruzará escalando sus puntos a píxeles. Si tiene una relación de 1.0: 1 de coordenadas flotantes: píxeles, entonces está ordenado y puede traducirlo directamente. Usando el algoritmo de intersección de segmento de línea puede verificar si su línea inferior izquierda (1,7) (2,7) se cruza con su línea (1.3,6.2) (6.51,2.9). http://alienryderflex.com/intersect/

Se necesitará alguna traducción de c a C #, pero puede obtener la idea de ese documento. Pondré el código a continuación en caso de que el enlace se rompa.

//  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; }

Si necesita averiguar solo cuándo (y dónde) se intersecan los segmentos de línea, puede modificar la función de la siguiente manera:

//  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;

Demo de 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>

Me encontré con el mismo problema hoy e hice una gran montaña de espagueti con una colina de mole, pero terminé con algo que funciona: https://github.com/SnpM/Pan-Line-Algorithm .

Desde el archivo Léame:

El concepto central de este algoritmo es similar al de Bresenham en que se incrementa en 1 unidad en un eje y prueba el aumento en el otro eje. Sin embargo, las fracciones hacen que el incremento sea considerablemente más difícil, y se tuvieron que agregar muchas pizzas. Por ejemplo, el incremento de X = .21 a X = 1.21 con una pendiente de 5 crea un problema complejo (patrones de coordenadas entre esos números desagradables son difíciles de predecir), pero aumentar de 1 a 2 con una pendiente de 5 hace que sea un problema fácil. El patrón de coordenadas entre enteros es muy fácil de resolver (solo una línea perpendicular al eje de incremento). Para obtener el problema fácil, el incremento se compensa con un número entero con todos los cálculos realizados por separado para la pieza fraccional. Entonces, en lugar de comenzar el incremento en .21,

ReadMe explica la solución mucho mejor que el código. Estoy planeando revisarlo para que sea menos dolor de cabeza.

Sé que llegué un año tarde a esta pregunta, pero espero que esto llegue a otros que buscan una solución a este problema.