Rasterization

• The bulk of this work is done with line drawing algorithms.
  • Remember, this is filling an width by height array.
  • Integer indexes please
  • We have two endpoints
  • And an operation WritePixel(ix,iy,value)
• WebGL assumes that pixels are centered 1/2 way between the coordinates.
  • A pixel at (0,0) is actually drawn at (1/2,1/2)
• There are implications for edges, and especially for antialiasing.
  • But for now, just go with square pixels, integer indexes.
• The DDA algorithm

  • m = (y2-y1)/(x2-x1)
    
    for (x = x1; x <= x2; x++) {
        y += m;
        WritePixel(round(x),round(y), color)
    } 

  • Good? Bad? Problems?
    • Will it include the end points?
    • Will there be holes in the lines?
    • How about m=0?
    • How about undefined m?
  • Here is an improved DDA

  • dx = (x2 - x1);
    dy = (y2 - y1);
    if(abs(dx) >= abs(dy))
       step = abs(dx);
    else
       step = abs(dy);
    dx = dx / step;
    dy = dy / step;
    x = x1;
    y = y1;
    i = 1;
    while(i <= step) {
        WritePixel(round(ix),round(iy), color)
        x = x + dx;
        y = y + dy;
        i = i + 1;
     }
    	

  • What problems does this fix?
• DDA is good, but Bresenham's line algorithm is better
  • This is the algorithm graphics cards use
  • Invented in 1962 by Jack Bressenham
  • Published in 63
  • Big Ideas
    • Do all integer calculations
    • "predict" an integer error for the axis of minor change
    • Move when this error becomes too large.
  • WLOG assume 0 ≤ m ≤ 1
    • You can flip the role of x and y if this is not the case.
  • Given (x1,y1) and (x2, y2)

    y    = mx + b
         =  Δy/Δx·x + b
    Δx·y = Δy·x + Δx·b
    0    = Δy·x  - Δx·y + Δx·b
    
        Let A = Δy, B = -Δx, C = bΔx
    
    F(x,y) = Ax+By+C = 0
    

  • Note, this is entirely an integer computation.
    • And tells us if a point is on a line or not.
    • y = 1/2 x + 2 Becomes x-2y+4 = 0
      • (0,2) is on the line since 0-4+4 = 0
      • (2,3) is on the line since 2-2*3+4 = 0
    • And also, if a point is not on the line if it is above or below the line.
      • (2,4) is above the line 2-2*4+4 = -2 < 0
      • (2,1) is below the line 2-2*1+4 = 4 > 0
    • 
  • We also know that F(x1,y1) is on the line.
  • The next point will be F(x1+1, y1) or F(x1+1, y1+1), we just need to decide which.
  • Determine this by evaluating F(x1+1, y1+1/2)
    • If F(x1+1, y1+1/2) is positive, the line is above it, select (x1+1, y1+1)
    • 
    • If F(x1+1, y1+1/2) is negative, the line is below it, select (x1+1, y1)
    • 
  • Notice, this involves one point computation, and one difference computation, not two.
  • Define D= F(x1+1, y1+1/2) - F(x1,y1)
    • This tells us how much the error changes from the current point to the predictor for the next point.

      D = F(x1+1, y1+1/2) -F(x1,y1)
        = A(x1+1) + B(y1+1/2) + C  - (Ax1 +By1+C)
        = Ax1 - Ax1 +A +By1 -By1 + 1/2B +C-C
        = A + 1/2 B 

    • D will give us the same indication as before.
      • Since (x0,y0) is on the line, F(x0, y0) = 0;
    • So we initialize D to be 0
      • The starting point has no error
      • The first point will be off by A + 1/2 B or (Δy-1/2Δx)
    • The next difference will be either

      If D was negative in the previous step
          D = F(x0+2, y0+1/2) - F(x0+1,y0+1/2) = A = Δy
      If D was positive in the previous step
          D = F(x0+2, y0+3/2) - F(x0+1,y0+1/2) = A+B = Δy - Δx 

    • So we need to change D by adding Δy or by adding Δy-Δx
    • But we really don't care about the value of D, just the sign.
      • So we can multiply everything by 2, and deal with d = 2D
      • d₀ = 2Δy - Δx
      • d_n = d_n-1+2Δy or d_n-1+2Δy-2Δx
    • So the algorithm is

      dx = x2 - x1
      dy = y2 - y1
      d = 2*dy - dx
      
      y = y1
      x = x1
      
      while x <= x2
        WritePixel(x,y,c) 
        if d > 0
           y = y + 1
           d = d - 2*dx
        end if
        d = d + 2*dy
        x++ 

  • Nice, all integer, fast, few computations, ....
  • Can be derived for m > 1
  • Don't need to derive for m =0 or m undefined. Why?
• Latif's Demo of Bresenham's.