Rasterization

• We are ready for the next stage of the pipeline, rasterization.
• This is useful as we may want to do this in other places.
• And we need to understand what is happening here (who knows when they will change things again?)
• Assume
  • We are only drawing points, line segments and polygons
  • That these have been clipped to the view volume.
  • write_pixel(int x, int y, int value)
    • Value specifies the color,
    • Directly
    • Or as an index into a color table.
• We will not worry about
  • Depth at this time (but it is easy just pass along z value)
  • Transparency (same deal, but α)
  • Anti-aliasing (but that is to come)
• Line Drawing Algorithms:
  • Take two endpoints and produce all the pixel values between.
  • Must determine the nearest pixel position along the path at any time.
  • This is really just an approximation to the line (duh)
• Just a little algebra
  • y = mx + b
  • m = (y_end - y_start)/(x_end - x_start)
  • y-y_end = m(x-x_end), *** or _start
  • so b = y_end - mx_end, *** or _start
  • Also note: δy = mδx, small δ means instantaneous change in x.
• Dan's Line Algorithm
  • Assumes x0 ≤ x1

  • DANS_LINE(x0,y0,x1,y1)
    
     dx = x1-x0
     dy = y1-y0
     m = dy/dx
     y = y0
     x = x0
     while (x < x1) do 
        write_pixel(i,y)
        x++;
        y += m  // δx = 1
    
    	

  • Test this for (0,0) to (20,5)
  • Test this for (0,0) to (5,20)
  • Thest this for (0,0) to (0,20)
• DDA : Digital Difference Analyzer
  • Take the slope into account.
    • x=x+1; y = y + m if |m| ≤ 1
    • x = x + 1/m; y = y + m otherwise.
  • These amounts can be adjusted if we don't want to sort the endpoints.
    • either add 1 or -1 depending on slope.
    • or add or subtract m or 1/m.

  • DDA(x0, y0, x1, y1)
    
     dx = x1-x0
     dy = y1-y0
     x = x0; y = y0
     if (fabs(dx) > fabs(dy) ) 
          steps = fabs(dx)
     else
          steps = fabs(dy)
     xIncrement = float(dx)/float(steps)
     yIncrement = float(dy)/float(steps)
     setPixel(round(x),round(y))
     for (k=0;k< steps; k++) {
        x += xIncrement
        y += yIncrement
        setPixel(round(x),round(y))
     }
    
    	 

  • Notice only one floating point divide.
  • And it is not in the loop!
  • But all major operations are float.
• Bressenham's
  • Derivation on board.

  • // assume 0 ≤ m < 1
    BRESSENHAMS(x0,y0, x1,y1)
    
     dx = fabs(x1-x0)
     dy = fabs(y1-y0)
     p = 2 * dy - dx
     twoDY = 2*dy
     twoDyMinusDx = twoDy - 2*dx
     x = x0
     y = y0;
     setPixel(x,y)
     while (x < xEnd) {
        x++
        if p < 0
            p += twoDy
        else
            y++;
            p+= twoDyMinusDx
        setPixel(x,y)
     }
    
    	

• Horizontal, vertical and diagional lines (|m| - 1) can be done more efficiently and checked very quickly.
• Note everything is integer addition/subtraction.
• It is reasonably easy to extend this to circles and other shapes.