Xiaolin Wu's line algorithm: Difference between revisions

Revision as of 00:27, 1 March 2015

Latest revision as of 17:26, 25 June 2025

(36 intermediate revisions by 30 users not shown)

Line 1:

{{Short description|Line algorithm with antialiasing}}

{{multiple|

{{third-party|date=April 2018}}

{{no footnotes|date=January 2013}}

{{Cleanup|reason=Implementation does not provide explanation|date=November 2023}}

[[Image:XiaolinWuLine.png|right|thumb|Antialiased line drawn with Xiaolin Wu's algorithm]]

}}

[[ImageFile:XiaolinWuLineLineXiaolinWu.png|rightgif|thumb|Antialiased line drawn336px|Demonstration withof Xiaolin Wu's algorithm]]

'''Xiaolin Wu's line algorithm''' is an [[algorithm]] for line [[spatial anti-aliasing|antialiasing]].

[[File:Xiaolin anti-aliased line comparison.png|thumb|Anti-Aliased Lines (blue) generated with Xiaolin Wu's line algorithm alongside standard lines (red) generated with Bresenham's line algorithm]]

==Antialiasing technique==

'''Xiaolin Wu's line algorithm''' is an [[algorithm]] for line [[Spatial anti-aliasing|antialiasing]], which was presented in the article ''"An Efficient Antialiasing Technique''" in the July 1991 issue of ''[[Computer Graphics (publicationnewsletter)|Computer Graphics]]'', as well as in the article ''"Fast Antialiasing''" in the June 1992 issue of ''[[Dr. Dobb's Journal]]''.

[[Bresenham's line algorithm|Bresenham's algorithm]] draws lines extremely quickly, but it does not perform anti-aliasing. In addition, it cannot handle any cases where the line endpoints do not lie exactly on integer points of the pixel grid. A naive approach to anti-aliasing the line would take an extremely long time. Wu's algorithm is comparatively fast, but is still slower than [[Bresenham's line algorithm|Bresenham's algorithm]]. The algorithm consists of drawing pairs of pixels straddling the line, each coloured according to its distance from the line. Pixels at the line ends are handled separately. Lines less than one pixel long are handled as a special case.

An extension to the algorithm for circle drawing was presented by Xiaolin Wu in the book ''[[Graphics Gems]] II''. Just likeas the line drawing algorithm is a replacement for Bresenham's line drawing algorithm, the circle drawing algorithm is a replacement for Bresenham's circle drawing algorithm.

==Algorithm==

<syntaxhighlight lang="pascal">

function plot(x, y, c) is

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

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

// integer part of x

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

function ipart(x) is

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

return int(x)

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 ]]

function round(x) is

return ipart(x + 0.5)

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:

gradient x0 := dyx0 /+ dx1

x1 := x1 - 1

if xx0 <> 0x1:

end break

D := D + d

if D overflows:

y0 := y0 + 1

y1 := y1 - 1

# Brightness = upper N bits of fractional part of D

returnv 1:= -D >> (xM - floor(x)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)

// fractional part of x

function fpart(x) is

if x < 0

return 1 - (x - floor(x))

return x - floor(x)

Line 42 ⟶ 96:

dx := x1 - x0

dy := y1 - y0

gradient := dy / dx

if dx == 0.0 then

gradient := 1.0

else

gradient := dy / dx

end if

// 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 60 ⟶ 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 74 ⟶ 133:

// main loop

if steep then
for x from xpxl1 + 1 to xpxl2 - 1 do

begin

if steep then plot(floor(intery) , x, rfpart(intery))

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

plot(ipart(intery)+1, x,:= fpart(intery)) + gradient

end
else

for x from xpxl1 + 1 to xpxl2 plot(x, ipart (intery),- 1 rfpart(intery))do

begin

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

end if plot(x, floor(intery), rfpart(intery))

intery := intery plot(x, floor(intery)+1, gradientfpart(intery))

plot(x,intery ipart:= (intery) +1, fpart(intery))gradient

end

end

end if

end function

</syntaxhighlight>

Line 100 ⟶ 163:

| url = http://portal.acm.org/citation.cfm?id=122734

| title = An efficient antialiasing technique

| journal=[[ACM SIGGRAPH Computer Graphics]]

| date=July 1991 | volume=25 | issue=4 | pages=143–152

| doi = 10.1145/127719.122734

| isbn=0-89791-436-8

| url-access=subscription

}}

* {{cite book

Line 109 ⟶ 173:

| year = 1991

| chapter = Fast Anti-Aliased Circle Generation

| editor = James Arvo (Ed.)

| title = Graphics Gems II

| pages = 446–450

Line 119 ⟶ 183:

==External links==

* [http://www.ece.mcmaster.ca/~xwu/ Xiaolin Wu's homepage]

* [https://www.eng.mcmaster.ca/ece/faculty/dr-xiaolin-wu Xiaolin Wu's homepage at McMaster University]

* [https://github.com/sachinruk/xiaolinwu Matlab algorithm]

{{DEFAULTSORT:Xiaolin Wu's Line Algorithm}}

[[Category:Computer graphicsAnti-aliasing algorithms]]

[[Category:Articles with example pseudocode]]