Xiaolin Wu's line algorithm: Difference between revisions

Revision as of 13:48, 20 April 2024

Latest revision as of 17:26, 25 June 2025

(5 intermediate revisions by 2 users not shown)

Line 17:

==Algorithm==

Like [[Bresenham's line algorithm|Bresenham’s line algorithm]], this method steps

along one axis and considers the two nearest pixels to the ideal line. Instead of

choosing the nearest, it draws both, with intensities proportional to their vertical

distance from the true line. This produces smoother, anti-aliased lines.

[[File:Wu-line-animation.gif|thumb|Animation showing symmetry of Wu's line algorithm ]]

The pseudocode below assumes a line where <math>x_0 < x_1</math>, <math>y_0 < y_1</math>,

and the slope <math>k = \frac{dy}{dx}</math> satisfies <math>0 \le k \le 1</math>. This

is a standard simplification — the algorithm can be extended to all directions using symmetry.

The algorithm is well-suited to older CPUs and microcontrollers because:

* It avoids floating point arithmetic in the main loop (only used to initialize d)

* It renders symmetrically from both ends, halving the number of iterations

* The main loop uses only addition and bit shifts — no multiplication or division

<syntaxhighlight lang="python" line="1">

function draw_line(x0, y0, x1, y1)

N := 8 # brightness resolution (bits)

M := 15 # fixed-point fractional bits

I := maximum brightness value

# Compute gradient and convert to fixed-point step

k := float(y1 - y0) / (x1 - x0)

d := floor((k << M) + 0.5)

# Start with fully covered pixels at each end

img[x0, y0] := img[x1, y1] := I

D := 0 # Fixed-point accumulator

while true:

x0 := x0 + 1

x1 := x1 - 1

if x0 > x1:

break

D := D + d

if D overflows:

y0 := y0 + 1

y1 := y1 - 1

# Brightness = upper N bits of fractional part of D

v := D >> (M - N)

img[x0, y0] := img[x1, y1] := I - v

img[x0, y0 + 1] := img[x1, y1 -1] := v

</syntaxhighlight>

===Floating Point Implementation===

<syntaxhighlight lang="pascal" line="1">

function plot(x, y, c) is

plot the pixel at (x, y) with brightness c (where 0 ≤ c ≤ 1)

// integer part of x

function ipart(x) is

return floor(x)

function round(x) is

return ipart(x + 0.5)

// fractional part of x

function fpart(x) is

return x - ipartfloor(x)

function rfpart(x) is

Line 58 ⟶ 104:

// handle first endpoint

xend := roundfloor(x0)

yend := y0 + gradient * (xend - x0)

xgap := rfpart1 - (x0 +- 0.5xend)

xpxl1 := xend // this will be used in the main loop

ypxl1 := ipartfloor(yend)

if steep then

plot(ypxl1, xpxl1, rfpart(yend) * xgap)

Line 73 ⟶ 119:

// handle second endpoint

xend := roundceil(x1)

yend := y1 + gradient * (xend - x1)

xgap := fpart1 - (x1xend +- 0.5x1)

xpxl2 := xend //this will be used in the main loop

ypxl2 := ipartfloor(yend)

if steep then

plot(ypxl2 , xpxl2, rfpart(yend) * xgap)

Line 90 ⟶ 136:

for x from xpxl1 + 1 to xpxl2 - 1 do

begin

plot(ipartfloor(intery) , x, rfpart(intery))

plot(ipartfloor(intery)+1, x, fpart(intery))

intery := intery + gradient

end

Line 97 ⟶ 143:

for x from xpxl1 + 1 to xpxl2 - 1 do

begin

plot(x, ipartfloor(intery), rfpart(intery))

plot(x, ipartfloor(intery)+1, fpart(intery))

intery := intery + gradient

end

Line 121 ⟶ 167:

| doi = 10.1145/127719.122734

| isbn=0-89791-436-8

| url-access=subscription

}}

* {{cite book