Ez az algoritmus egy vonal letapogatására szolgál. Bresenham fejlesztette ki. Ez egy hatékony módszer, mert csak egész számok összeadását, kivonását és szorzási műveleteit tartalmazza. Ezek a műveletek nagyon gyorsan végrehajthatók, így a vonalak gyorsan generálhatók.

Ennél a módszernél a következő képpont az lesz, amelyiknek a legkisebb távolsága van a valódi vonaltól.

A módszer a következőképpen működik:

Tételezzünk fel egy P pixelt₁'(x₁',és₁'), majd válasszuk ki a következő képpontokat, ahogy májustól éjszakáig dolgozunk, egy-egy pixel pozícióban vízszintes irányban P felé₂'(x₂',és₂').

Ha egy pixel van, bármelyik lépésben választhat

ipconfig ubuntuhoz

A következő pixel az

1. Vagy a tőle jobbra eső (a vonal alsó korlátja)
2. Az egyik jobbra fent és felfelé (a vonal felső határa)

A vonalat azokkal a képpontokkal lehet a legjobban közelíteni, amelyek a legkisebb távolságra esnek a P közötti útvonaltól₁', P₂'.

A To kiválasztja a következőt az alsó S pixel és a felső T pixel között.
Ha S-t választjuk
Nekünk x van_i+1=x_én+1 és y_i+1=y_én
Ha T választja
Nekünk x van_i+1=x_én+1 és y_i+1=y_én+1

Az x = x pontban lévő egyenes tényleges y koordinátái_i+1van
y=mx_i+1+b

Az S-től a tényleges egyenesig mért távolság y irányban
s = y-y_én

A távolság T-től a tényleges egyenesig y irányban
t = (y_én+1)-y

Most nézzük meg a különbséget a két távolságérték között
utca

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

A legközelebbi pixel az S

Amikor (s-t) ≧0 ⟹ s

A legközelebbi pixel a T

Ez a különbség az
s-t = (y-yi)-[(yi+1)-y]
= 2y - 2yi -1

m-t helyettesítve és döntési változó bevezetése
d_én=△x (s-t)
d_én=△x (2 (x_én+1)+2b-2y_én-1)
=2△xy_én-2△y-1△x.2b-2y_én△x-△x
d_én=2△y.x_én-2△x.y_én+c

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

java end for ciklus

Felírhatjuk a d döntési változót_i+1a következő csúszáshoz
d_i+1=2△y.x_i+1-2△x.y_i+1+c
d_i+1-d_én=2△y.(x_i+1-x_én)- 2△x(y_i+1-és_én)

Mivel x_(i+1)=x_én+1, megvan
d_i+1+d_én=2△y.(x_én+1-x_én)- 2△x(y_i+1-és_én)

Különleges esetek

Ha a kiválasztott pixel a felső T pixelnél van (azaz d_én≧0)⟹ és_i+1=y_én+1
d_i+1=d_én+2△y-2△x

Ha a kiválasztott pixel az alsó T pixelben van (azaz d_én<0)⟹ y_{i+1=yén
di+1=dén+2△y}

Végül kiszámoljuk d₁
d₁=△x[2m(x₁+1)+2b-2y₁-1]
d₁=△x[2(mx₁+b-y₁)+2m-1]

Mivel mx₁+b-y_én=0 és m = , nekünk van
d₁=2△y-△x

Előny:

1. Csak egész számot tartalmaz, tehát egyszerű.

c program string tömb

2. Elkerüli az ismétlődő pontok generálását.

3. Hardverrel megvalósítható, mert nem használ szorzást és osztást.

4. Gyorsabb a DDA-hoz (Digital Differential Analyzer) képest, mivel nem tartalmaz olyan lebegőpontos számításokat, mint a DDA algoritmus.

Hátrány:

1. Ez az algoritmus csak alapvető vonalvezetésre szolgál. Az inicializálás nem része a Bresenham-féle vonalalgoritmusnak. Tehát a sima vonalak rajzolásához érdemes egy másik algoritmust megvizsgálni.

rendfa bejárás

Bresenham vonal algoritmusa:

1. lépés: Algoritmus indítása

2. lépés: Az x változó deklarálása₁,x₂,és₁,és₂,d,i₁,én₂,dx,dy

3. lépés: Adja meg x értékét₁,és₁,x₂,és₂
Ahol x₁,és₁a kezdőpont koordinátái
És x₂,és₂a végpont koordinátái

4. lépés: Számítsd ki dx = x₂-x₁
Számítsa ki dy = y₂-és₁
Számítsa ki az i₁=2*te
Számítsa ki az i₂=2*(dy-dx)
Számítsd ki d=i₁-dx

5. lépés: Tekintsük (x, y) kezdőpontnak és x-nek_végemint lehetséges x maximális értéke.
Ha dx<0
Ekkor x = x₂
y = y₂
x_vége=x₁
Ha dx > 0
Ekkor x = x₁
y = y₁
x_vége=x₂

6. lépés: Pont generálása (x,y) koordinátákon.

7. lépés: Ellenőrizze, hogy létrejött-e a teljes sor.
Ha x > = x_vége
Állj meg.

8. lépés: Számítsa ki a következő pixel koordinátáit
Ha d<0
Ekkor d = d + i₁
Ha d ≧ 0
Ekkor d = d + i₂
Növekedés y = y + 1

9. lépés: Növekedés x = x + 1

10. lépés: Rajzolj egy pontot a legújabb (x, y) koordinátákkal

11. lépés: Folytassa a 7. lépéssel

12. lépés: Algoritmus vége

Példa: A sor kezdő és végpontja (1, 1) és (8, 5). Keresse meg a közbenső pontokat.

Megoldás: x₁=1
és₁=1
x₂=8
és₂=5
dx= x₂-x₁=8-1=7
te=y₂-és₁=5-1=4
én₁=2* ∆y=2*4=8
én₂=2*(∆y-∆x)=2*(4-7)=-6
d = I₁-∆x=8-7=1

java karakterlánc formátum

Program a Bresenham-féle vonalrajzolási algoritmus megvalósításához:

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

Kimenet:

Tegyen különbséget a DDA algoritmus és a Bresenham-féle vonalalgoritmus között: