Algorytm ten służy do skanowania konwertującego linię. Został opracowany przez Bresenhama. Jest to skuteczna metoda, ponieważ obejmuje tylko dodawanie, odejmowanie i mnożenie liczb całkowitych. Operacje te można wykonać bardzo szybko, dzięki czemu można szybko wygenerować linie.

W tej metodzie kolejnym wybranym pikselem jest ten, który ma najmniejszą odległość od linii prawdziwej.

Metoda działa w następujący sposób:

urodził się Freddie Mercury

Załóżmy, że piksel P₁'(X₁',I₁'), następnie zaznaczaj kolejne piksele w miarę jak pracujemy do nocy, po jednym pikselu na raz w kierunku poziomym w stronę P₂'(X₂',I₂').

Po wybraniu piksela w dowolnym kroku

Następny piksel to

1. Albo ten po prawej stronie (dolna granica linii)
2. Jeden u góry w prawo i w górę (górna granica linii)

Linię najlepiej przybliżają te piksele, które znajdują się w najmniejszej odległości od ścieżki pomiędzy P₁',P₂'.

Aby wybrać następny pomiędzy dolnym pikselem S i górnym pikselem T.
Jeśli wybrano S
Mamy x_ja+1=x_I+1 i y_ja+1= y_I
Jeśli wybrano T
Mamy x_ja+1=x_I+1 i y_ja+1= y_I+1

Rzeczywiste współrzędne y linii w punkcie x = x_ja+1Jest
y=mx_ja+1+b

Odległość od S do rzeczywistej linii w kierunku y
s = y-y_I

Odległość od T do rzeczywistej linii w kierunku y
t = (y_I+1) -y

Rozważmy teraz różnicę między tymi dwiema wartościami odległości
s - t

Kiedy (s-t)<0 ⟹ s < t< p>

Najbliższy piksel to S

Kiedy (s-t) ≧0 ⟹ s

Najbliższy piksel to T

Ta różnica jest
s-t = (y-yi)-[(yi+1)-y]
= 2 lata - 2 lata -1

Zastępując m przez i wprowadzenie zmiennej decyzyjnej
D_I=△x (s-t)
D_I=△x (2 (X_I+1)+2b-2y_I-1)
=2△xy_I-2△y-1△x.2b-2y_I△x-△x
D_I=2△y.x_I-2△x.y_I+c

Gdzie c= 2△y+△x (2b-1)

Możemy zapisać zmienną decyzyjną d_ja+1na następną wpadkę
D_ja+1=2△y.x_ja+1-2△x.y_ja+1+c
D_ja+1-D_I=2△y.(x_ja+1-X_I)- 2△x(y_ja+1-I_I)

Ponieważ x_(i+1)=x_I+1, mamy
D_ja+1+d_I=2△y.(x_I+1-x_I)- 2△x(y_ja+1-I_I)

Specjalne przypadki

Jeśli wybrany piksel znajduje się na górnym pikselu T (tzn_I≧0)⟹ i_ja+1= y_I+1
D_ja+1=d_I+2△y-2△x

Jeśli wybrany piksel znajduje się na dolnym pikselu T (tzn_I<0)⟹ y_{i+1=yI
Dja+1=dI+2△y}

Na koniec obliczamy d₁
D₁=△x[2m(x₁+1)+2b-2y₁-1]
D₁=△x[2(mx₁+b-y₁)+2m-1]

Od mx₁+b-y_I=0 i m = , mamy
D₁=2△y-△x

Korzyść:

1. Dotyczy tylko arytmetyki liczb całkowitych, więc jest proste.

2. Pozwala uniknąć generowania duplikatów punktów.

3. Można go zaimplementować przy użyciu sprzętu, ponieważ nie używa mnożenia i dzielenia.

4. Jest szybszy w porównaniu do DDA (Digital Differential Analyzer), ponieważ nie obejmuje obliczeń zmiennoprzecinkowych, takich jak algorytm DDA.

Niekorzyść:

1. Algorytm ten jest przeznaczony wyłącznie do podstawowego rysowania linii. Inicjowanie nie jest częścią algorytmu linii Bresenhama. Aby więc rysować gładkie linie, powinieneś przyjrzeć się innemu algorytmowi.

Algorytm liniowy Bresenhama:

Krok 1: Uruchom algorytm

samouczek javafx

Krok 2: Zadeklaruj zmienną x₁,X₂,I₁,I₂,d,tj₁,I₂,dx,dy

gimp zapisuje jako JPEG

Krok 3: Wprowadź wartość x₁,I₁,X₂,I₂
Gdzie x₁,I₁są współrzędnymi punktu początkowego
I x₂,I₂są współrzędnymi punktu końcowego

Krok 4: Oblicz dx = x₂-X₁
Oblicz dy = y₂-I₁
Oblicz I₁=2*ty
Oblicz I₂=2*(dy-dx)
Oblicz d=i₁-dx

Krok 5: Rozważ (x, y) jako punkt wyjścia i x_koniecjako maksymalna możliwa wartość x.
Jeśli dx<0
Wtedy x = x₂
y = y₂
X_koniec=x₁
Jeśli dx > 0
Wtedy x = x₁
y = y₁
X_koniec=x₂

Krok 6: Generuj punkt we współrzędnych (x, y).

Krok 7: Sprawdź, czy została wygenerowana cała linia.
Jeśli x > = x_koniec
Zatrzymywać się.

Krok 8: Oblicz współrzędne następnego piksela
Jeśli d<0
Wtedy d = d + ja₁
Jeśli d ≧ 0
Wtedy d = d + ja₂
Przyrost y = y + 1

Krok 9: Przyrost x = x + 1

Krok 10: Narysuj punkt o ostatnich współrzędnych (x, y).

Krok 11: Przejdź do kroku 7

Krok 12: Koniec algorytmu

Przykład: Pozycje początkowe i końcowe linii to (1, 1) i (8, 5). Znajdź punkty pośrednie.

Rozwiązanie: X₁=1
I₁=1
X₂=8
I₂=5
dx=x₂-X₁=8-1=7
ty=y₂-I₁=5-1=4
I₁=2* ∆y=2*4=8
I₂=2*(∆y-∆x)=2*(4-7)=-6
d = ja₁-∆x=8-7=1

Program implementujący algorytm rysowania linii Bresenhama:

 #include #include void drawline(int x0, int y0, int x1, int y1) { int dx, dy, p, x, y; dx=x1-x0; dy=y1-y0; x=x0; y=y0; p=2*dy-dx; while(x=0) { putpixel(x,y,7); y=y+1; p=p+2*dy-2*dx; } else { putpixel(x,y,7); p=p+2*dy;} x=x+1; } } int main() { int gdriver=DETECT, gmode, error, x0, y0, x1, y1; initgraph(&gdriver, &gmode, 'c:\turboc3\bgi'); printf('Enter co-ordinates of first point: '); scanf('%d%d', &x0, &y0); printf('Enter co-ordinates of second point: '); scanf('%d%d', &x1, &y1); drawline(x0, y0, x1, y1); return 0; } 

Wyjście:

Rozróżnij algorytm DDA od algorytmu liniowego Bresenhama: