CS 184: COMPUTER GRAPHICS

QUESTION OF THE DAY:

Given a complex polygon that we want to shade based on the non-zero winding number paradigm. Let's assume that we have already clipped that polygon properly to the bounds of the viewport. Now we need an efficient way to rasterize this polygon, i.e., to turn on all the pixels in the viewport that fall inside the polygon. Think of a good algorithm and estimate its complexity.

Lecture #4 -- Mon 2/2/2009.

Polygon Rasterization

Crucial Concepts from Last Lecture:

The Various Coordinate Systems in the Classical Rendering Pipeline:
World to screen transforms - Overview   (This is valid in some form for all rendering environments).

Algorithm for Polygon Rasterization

Let's asume we have done a suitable transformation to bring our polygon into a normalized viewing volume where we just have to do a simple parallel projection along the z-axis (equal to setting z equal to zero) to get the desired display of the polygon.
Now -- how can we determine in an efficient manner WHICH PIXELS should be turned on ?

refer to:  DISCUSSION OF THE QUESTION OF THE DAY.

We "turn on" all the pixels that have a sampling point that falls inside the polygon contour.

Now we want to implement a rasterization algorithm in an efficient manner:

Sweeping Scan-line Approach

First we do this one polygon at a time.   (not explained well enough in [Shirley]).

Gouraud Shading (= linear interpolation between vertices)

In addition to the above, let's now assume that the polygon to be shaded is just a simple triangle. It is normally a good idea to break complicated polygons into triangles, then you know what you have got; different renderers may do different (and sometimes strange) things to a concave, non-planar polygon.
However, it is still important to understand the winding number paradigm and to use it where appropriate, e.g. in layered manufacturing. There the machine needs to calculate for each layer of material deposited the exact polygon to be "painted in."

But now we want to give this triangle a smoothly changing color; where three different colors have been specified for its three vertices.
To determine the color of any point inside the triangle, we will use barycentric coordinates. (The influence of a vertex diminishes proportional to the distance from the opposite side.) This can easily be calulated with linear interpolation. A practical way to do this is to interpolate first along the edges of the triangle and then along the scan line between the previously calculated values on the edges.

Z-buffer Algorithm (to find the "top" visible polygon)

Now, in addition to the above, we assume that we have several triangles which partially overlap in the projection into our viewport (and perhaps even intersect in 3D).
How do we determine efficiently which triangle a particular pixel should represent?

The z-buffer is a 2D array of storage elements that stores for each pixel (R,G,B)color and a z-depth.
    -- Paint all triangles (one at a time) into the z-buffer (using scan-line-based raster filling);
    -- the front-most pixel and its depth and color will be retained -- and finally displayed.
    -- The z-depth of each pixel can be efficiently calculated by linear interpolation,
        i.e., by fixed incrementation in y and in x (since we assume all polyhedron faces to be planar).

Linear Interpolation in Scan-Line Algorithm

Alternative Scan-line Approach: Processing all polygons simultaneously

The devil is in the details !

Reading Assignments:

Programming Assignments 1 and 2:

Both must be done individually.
Assignment #1 is due (electronically submitted) before Thursday 2/5, 11:00pm.
Assignment #2 is due (electronically submitted) before Thursday 2/12, 11:00pm.