Line Algorithms

• We want to draw lines on the screen. (Frame buffer)
  • This is really the only place where we know what resolution we are dealing with.
  • Also we have color information here.
• In this case then, we know
  • Everything is in integer coordinates
  • And a very discrete world.
• Furthermore
  • Assume that we have a command that sets a pixel on or off, (or to a given r,g,b value if you wish) setPixel(x,y,c)
• We want to draw a line
  • We have (x₀, y₀) and (x₁, y₁), w.l.o.g. let x₀ ≤ x₁.
• We know, from algebra
  • y = mx + b
  • m = Δx/Δy = (y₁-y₀)/(x₁-x₀)
• If we add the restriction 0 ≤ m ≤ 1
  • We know that x is the axis of major change
  • or that x changes faster than y.
  • This is important, because we need to make sure that we don't put "gaps" into the line.
• The DDA algorithm
  • The algorithm:

    DDA(x0,y0,x1,y1)
    
     m = (y1-y0)/(x1-x0)
     j = y0
     for i <-x0 to x1 do
         setPixel(i,round(j),color)
         j <- j + m
         i <- i + 1
    
    

    • Notice, j is a float here, as is m
    • Try this with (1,1), (8,4)
    • We can calculate the color between 3 and 4 if we need to
    • This would be done by interpolating between two colors
    • We could also apply a stipple to the line, How?
  • Will this (DDA) set both end points?
  • Will it (DDA) allow gaps in the line?
  • What should we do when x₀ = x₁?
  • What happens if m > 1?
  • Try DDA with (1,1), (4,8)
  • How can we fix DDA in this case?
  • What do we do in the case of a negative slope?
• DDA is not as efficient as we could wish
  • It relies on floating point addition
  • Roundoff error could lead to the second endpoint not being plotted correctly
  • And floating point is expensive
  • Is this important?
    • We will want to draw many many lines per scene
• Bresenham's Algorithm
  • Jack E. Bresenham, 1962.
  • This algorithm "predicts" which y coordinate to use next.
  • Assume once again that 0 ≤ m ≤ 1
  • We will always begin at (x₀,y₀)
  • We next need to decide to plot either
    • (x₀+1,y₀+1)
    • (x₀+1,y₀)
  • let ε be an error term
    • This represents the fractional part of where the y point should be.
    • In the beginning, this will be 0
    • At step 1, this will be m
    • This will be bound by -.5 < ε ≤ .5
    • If ε > .5, plot (x_i+1,y_i+1) and let ε= ε+m-1 (or let y_i+1 = y_i+1
    • Otherwise plot (x_i+1,y_i) and let ε= ε+m (or let y_i+1 = y_i)
  • This is fine, but we are still dealing with a float. (ε);
  • Consider the test:
    • ε + m < 0.5
    • Remember, m = Δy/Δx;
    • so we can say that ε + Δy/Δx < 0.5
    • is the same as ε Δx +Δy < 0.5 Δx
    • Furthermore multiplying by 2 we get
    • 2ε Δx + 2Δy < Δx
    • If we could keep ε an integer, everything else in this test is an integer.
  • So how do we change ε?
    • ε= ε+m-1
    • ε= ε+m
    • Again, multiply by through by Δx
    • ε Δx = ε Δx + Δy - Δx
    • So make a change let ε' = ε Δx
    • ε' = ε' + Δy ( - Δx);