Tutti i casi di cui Bresenham line-algoritmo

Ho bisogno di controllare tutti i pixel in una linea, quindi sto usando l’algoritmo di Bresenham per l’accesso a ciascun pixel. In particolare ho bisogno di controllare se tutti i pixel che si trovano sulla valida di pixel di un’immagine bitmap. Questo è il codice:

private void Bresenham(Point p1, Point p2, ref List<Point> track) {
  int dx = p2.X - p1.X;
  int dy = p2.Y - p1.Y;

  int swaps = 0;
  if (dy > dx) {
    Swap(ref dx, ref dy);
    swaps = 1;
  }

  int a = Math.Abs(dy);
  int b = -Math.Abs(dx);

  double d = 2*a + b;
  int x = p1.X;
  int y = p1.Y;
  color_track = Color.Blue;
  Check_Pixel(ref area, new Point(x,y));
  track.Clear();
  track.Add(new Point(x, y));

  int s = 1;
  int q = 1;
  if (p1.X > p2.X) q = -1;
  if (p1.Y > p2.Y) s = -1;

  for(int k = 0; k < dx; k++) {
    if (d >= 0) {
      d = 2*(a+b) + d;
      y = y + s;
      x = x + q;
    }
    else {
      if (swaps == 1) y = y + s;
      else x = x + q;
      d = 2 * a + d;
    }
    Check_Pixel(ref area, new Point(x, y));
    track.Add(new Point(x, y));
  }
}

private void Swap(ref int x, ref int y) {
  int temp = x;
  x = y;
  y = temp;
}

Check_Pixel è utilizzato per verificare se la linea di pixel in un’immagine bitmap valida. Aggiungo il pixel fondata a un List<Point> per il rendering, punto per punto, il suo elemento e assicurarsi Bresenham controlla il corretto pixel (che non fa). Il problema è che il mio algoritmo non riesce a coprire tutti i casi, ma circa il 50% di loro.

P. S: la mia origine del sistema di coordinate è sull’angolo superiore sinistro (x cresce da sinistra a destra, y fino a giù)

OriginaleL’autore Frank Lioty | 2012-07-26

2 Replies
  1. 30

    Trovare la versione completa:

    public void line(int x,int y,int x2, int y2, int color) {
        int w = x2 - x ;
        int h = y2 - y ;
        int dx1 = 0, dy1 = 0, dx2 = 0, dy2 = 0 ;
        if (w<0) dx1 = -1 ; else if (w>0) dx1 = 1 ;
        if (h<0) dy1 = -1 ; else if (h>0) dy1 = 1 ;
        if (w<0) dx2 = -1 ; else if (w>0) dx2 = 1 ;
        int longest = Math.Abs(w) ;
        int shortest = Math.Abs(h) ;
        if (!(longest>shortest)) {
            longest = Math.Abs(h) ;
            shortest = Math.Abs(w) ;
            if (h<0) dy2 = -1 ; else if (h>0) dy2 = 1 ;
            dx2 = 0 ;            
        }
        int numerator = longest >> 1 ;
        for (int i=0;i<=longest;i++) {
            putpixel(x,y,color) ;
            numerator += shortest ;
            if (!(numerator<longest)) {
                numerator -= longest ;
                x += dx1 ;
                y += dy1 ;
            } else {
                x += dx2 ;
                y += dy2 ;
            }
        }
    }
    Infine, un lavoro in C# versione di Bresenham che in realtà copre tutti i byte e non invertire il punto di metà del tempo!

    OriginaleL’autore Frank Lioty

  2. 0

    Disegno di linee di pentecoste pixel non è deterministica.

    ***
       **

    o

    **
      ***

    Se il tuo pinte sono stati disegnati utilizzando Bresenham provare ad andare in entrambe le direzioni.

    che è quello che sto chiedendo. Come coprire tutti i casi possibili?
    Devi provare diverse versioni di Bresenham per capire che uno l’hanno utilizzato. Perché non basta controllare se, come si sta verificando è vicino alla linea che si genera con Bresenham.

    OriginaleL’autore Luka Rahne

Lascia un commento