Outline

• Visible Surface Algorithms
• Back Face Elimination
• List Priority Algorithm
• Depth Sorting
• BSP Algorithm

Introduction

• On Tuesday, we continued to develop our toolkit for geometric modeling.
• We looked at some more surrounding tests and intersection algorithms.
• We are going to skip distance formulas and areas and volumes, and develop them if needed as we go.
• Today, we are going to start looking at visible surface algorithms.

Visible Surface Algorithms

• After modeling the geometry of a scene, the next step in rendering it from a given viewpoint is to determine those surface patches that will be visible. This is the visible surface determination problem aka the The hidden surface removal problem.
• Visible Surface Algorithms are used to solve this problem. They can be classified into three broad approaches: object precision, image precision, and list precision.
• Rather than the word precision sometimes the word space is used. i.e., object space rather than object precision.

High-Level Object Precision

for each object O in the world do
  begin
    Find the part A of O that is visible
    Display A appropriately
  end;

High-Level Image Precision

for each pixel on the screen do
  begin
    Determine the visible object O that is pierced
      by the ray from the viewer determined by the pixel
    if there is such an O
      then display the pixel appropriately
      else display the pixel in the background color
  end;

• Ray tracing is an example of a image precision algorithm.

High-Level List Priority Algorithms

Precompute for each object a visibility ordering
Scan convert objects to image space in a back-to-front order

• The Schumaker, Newell-Newll-Sancha, and BSP tree algorithms are examples of list priority algorithms.

Back Face Elimination

• Before going into specific algorithms of each of the three types we have just mentioned, we are first going to describe a preprocessing step known as Bace-Face elimination.
• A back face of an object is a face that is "facing away" from the camera. More formally...
  Definition. An oriented face is called a back face with respect to a vector `vec v` (usually the camera) if the angle between it normal vector `vec n` and `vec v` is between 0 and 90 degrees. i.e., `vec n cdot vec v ge 0`. If `vec n cdot vec v le 0`, we say the face is a front face.
• Removing edges of the back faces in wireframe mode can often make for more realistic wireframes.
• For some objects one flags certain faces as two-sided to make things like the bottom of an open tin can viewable from the top.
• Suppose one had an object in winged-edge representation. To eliminate the back faces we could go through our face list, for each face, pick two edges in CCW order and cross them to get a normal, then dot this with `vec v` to perform the above check on whether the face should be eliminated.

Schumacker List Priority Algorithm (1969 - used in Flight Simulators)

• In this algorithm each face is assigned a priority.
• A lower priority face can never obscure a higher priority face.
• In the above, a lower number picture means higher priority.
• For this to work a scene might need to be split into clusters, and priorities assigned within each cluster and to the clusters themselves.
• After the priorities are assigned, back face elimination is done. Then for the remaining faces, one draw them with the painter's algorithms
• That is, we draw the scene by drawing the lowest priority items to the frame buffer first.
• The main problem with this algorithm is assignment priorities often needs to be done by hand.

Newell-Newell-Sancha Depth Sorting (1972)

• This is another list priority algorithm.
• It sorts objects by depth from the given viewpoint. Then it draws the scene using the painter's algorithm.
• Unlike Schumacker, it does not rely on a priori priorities.
• In this algorithm we first do an initial sort based on the z-value of the vertex of a given face that is furthest from the viewpoint.
• Let `P` and `Q` be the last and next to last polygon in our sorted list. Starting from the last polygon `P`, one checks if it can be safely written to the frame buffer by checking
  (minimum z-value of a vertex of `P`) > (maximum z-value of a vertex in `Q`)
• If yes, then `P` can never obscure part of `Q` and we can write `P` to the frame buffer.

More on Newell-Newell-Sancha Depth Sorting

• If no, then a series of additional tests are done. Yes, to any of these allows us to draw `P`:
  
  1. Can one separate `P` and `Q` in the `x` direction?
  2. Can one separate `P` and `Q` in the `y` direction?
  3. Is `P` on the farther side of the `Q`'s vertices (case (a) above )?
  4. Is `Q` on the nearer side of the `P`'s vertices (case (B) above )?
  5. Do `P` and `Q` project to disjoint sets.
• If the answer is no to all of these questions we swap `P` and `Q` in the order. We mark `Q` as having been swapped so that we can avoid cyclical swapping that might occur by figures like (c) above.
• Sometimes situations like (c) can be fixed by cutting on of the `Q` into two polygons like we did above.

The BSP Algorithm

• This algorithm was developed in the early 1980s.
• It improves on Schumacker's algorithm by trying to automate the division of the object into clusters.
• The basic outline of the algorithm is two steps:
  1. Convert the input polygonlist into a BSP tree
  2. Traverse this tree and output the polygons to the frame buffer in a back-to-from order.
• To build the BSP tree one successively splits the scene using separating planes.
• These planes have the property that no polygon on the viewport side of the plane can be obstructed by a polygon on the other side of the plane.

Constructing the BSP Tree

The steps to construct the BSP tree are as follows:

1. Select any polygon `P` from the current list and place it at the root of the tree.
2. Each remaining polygon in the list is then tested to see which side of `P` it lies. This is done by comparing signs of the dot products of the normal of `P` with the normals with the plane of defined given by the vector between a vertex of the other polygon and the plane given by `P`. If a polygon lies on the same side as `P` we put it in the left subtree list, otherwise, we put it in the right subtree list. If a polygon straddles `P`s plane, divide it along that plane and put each the pieces in the appropriate subtree list.
3. We then repeat this procedure recursively on the two subtrees.

To make this algorithm faster one often takes in Step (1) the polygon that cuts the fewest other polygons. In fact, it often suffices for efficiency just to pick five polygons at random and choose amongst these the one that cuts the fewest polygons.

BSP Traversal

• Once the BSP tree is generated, we want to generate the view by traversing the tree in in-order fashion.
• To do this, at each node of the tree we determine whether the eye is in front or in back of the current root polygon.
• We traverse first the opposite side of the tree, then output the root polygon to the frame buffer, and then traverse the remaining side.