Outline

• Area Subdivision
• Quiz
• Z-Buffer Algorithms
• Scan Line Algorithms
• Convex Sets

Introduction

• Last week, we continued to develop algorithms which are useful for geometric modeling
• We looked at several surrounding tests, convexity, and intersection tests.
• We then began to look at visible surface algorithms.
• We looked at Back-face elimination, List Priority Algorithms, Depth Sorting, and BSP algorithms.
• Today, we are going to continue to look at some more visible surface algorithms, and then look at some more algorithms for convex sets.

Area Subdivision

• Last Thursday, we said there are three main kinds of visible surface algorithms: object precision, image precision, and list priority.
• We next look at the Warnock visible surface determination algorithm (1969) which is an image precision algorithm.
• It attempt to find rectangular regions of the screen (called windows) of the same intensity on the screen.
• The basic outline of the algorithm is:

  Initialize a list L of windows to consist of a 
  single window that is the entire screen.
  
  For each window W in the current list L look for 
  one of the following cases:
  
  (1) All polygons are disjoint from W. In this case,
   draw W in the background color.
  (2) Only one polygon P intersects W. In this case,
   draw the intersection of P and W in the color of P 
   and draw W in the background color.
  (3) At least one surrounding polygon was found and 
   it is in front of all other polygons that intersect 
   the window. In that case, draw the window in the color 
   of the polygon.
  
  If none of these cases apply to W, split W into four equal 
  sized smaller windows, and add them to L. Repeat this process 
  until one gets down to a window the size of a pixel. At that point
  one checks directly which polygon is in front of all others at 
  that pixel.
  

• A common variation on this algorithm (Weiler Atherton 1977) is to split into smaller windows which are the shaped based on one of the polygons that one needs to draw.

Z-Buffer Algorithms

• z-buffer algorithms are image precision algorithms.
• A z-buffer is a two-dimensional array of real numbers of the same size as the frame buffer.
• This array records depth information about the pixel.
• To draw a scene a typical z-buffer algorithm might operate as follows:

  Let Depth(p) denote the z-coordinate of p in the 
  camera coordinate system. We assume the array DEPTH holds 
  these z-values for the object closest to the camera.
  
  color array FRAMEBUF[XMIN..XMAX, YMIN .. YMAX];
  real array DEPTH[XMIN..XMAX, YMIN .. YMAX];
  
  begin
    Initialize FRAMEBUF to the background color;
    Initialize DEPTH to ∞
  
      for all faces F in the world do
         for each point p in F do
            if p projects to FRAMEBUF[i,j] for some i,j then
               if Depth(p) < DEPTH[i,j] then
                  begin 
                     FRAMEBUF[i,j] := color of F at p
                     DEPTH[i,j] := Depth(p);
                  end
  end
  

Scan Line Algorithms

• One drawback of the z-buffer algorithm as presented is that you need an array of depth values for the whole screen.
• It turns out you can get away with a z-buffer for just a horizontal line called a scan-line.
• Call the intersection of a face with the scan-line a segment.
• You can determine which segments are visible by checking their depths using plane equations restricted to spans of the scan-line.

Quiz

Which of the following statements is true?

1. The algorithms we learned for convexity testing were O(log n) in the number of vertices.
2. Newell-Newell-Sancha depth sorting sorts objects with respect to a viewpoint.
3. The BSP traversal part of the BSP depth sorting algorithm we gave does not depend of the viewpoint.

More Geometric Modeling Tools

• We are now going to consider material from Chapter 17 in the book.
• This material consists of additional tools which are useful in geometric modeling.
• First, we are going to look at how to tell if two convex linear polyhedra intersect.

Separability

• Let `H(vec p, vec n)` and `iH(vec p, vec n)` denote respectively the closed and open halfspace given by the plane containing `vec p` and normal to `vec n`. We will denote this plane `P(vec p, vec n)`.
• We say two subsets `X`, `Y` of `\mathbb{R}^n` are linearly separable if there is a hyperplane `P(vec p, vec n)` so that `X \subset H(vec p, -vec n)` and `Y \subset H(vec p,vec n)`.
• If we have `iH` rather than `H` in the above, the two sets are said to be strictly linearly separable.
• Given points `vec n`, `vec p`, define `vec n(\vec p) := vec n\cdot vec p` and for a set `S` let `\vec n(S)` to be `\{\vec n(\vec p) | \vec p \in S\}`

Theorem. Let `vec p_1, vec p_2, \ldots, \vec p_s` and `vec q_1, vec q_2, \ldots, \vec q_t` be points in `mathbb{R}^n`. Let `X` and `Y` be the convex hulls respectively of the first and set set of points. Assume the hull of `S = \{ vec p_1, vec p_2, \ldots, \vec p_s, vec q_1, vec q_2, \ldots, \vec q_t \}`has dimension `n`. Then the following two statements are equivalent:

1. The convex hull of `X` and `Y` are linearly separable.
2. There are linearly independent vectors `vec r_1, vec r_2, \ldots, vec r_n` in S so that if `vec n` is any nonzero normal to the hyperplane `\{ \vec x| \vec x = \vec r_1 + a_2\vec r_2 +\cdots + a_n\vec r_n\}` they generate, then the intervals `vec n(X)` and `vec n(Y)` intersect in at most one point.

Proof of the Theorem

• To see (2) implies (1) assume that `\vec n(X) = [a,b]` and `\vec n(Y) = [c,d]` intersect at most one point for some vector `vec n`. WLOG, we can also assume `b ≤ c`.
• Let `vec p` be a vertex of `X` so that `vec n(vec p) = b`.
• Then `P(\vec p, vec n)` is a separating plane for `X` and `Y`.
• To see that (1) implies (2) we first look at the special cases where `n=1` and `n=2`.
• When `n=1`, `X` and `Y` are just intervals `[a, b]` and `[c, d]`. Suppose these two intervals are separated by a hyperplane `P(\vec p, vec n)` (a point in this case). A normal in this case is just a real number, say `k` and `\vec n(X) = [ka, kb]` and `vec n(Y) = [kc, kd]` which if `[a, b]` and `[c, d]` where separated by `\vec p` will also be separated by `k\vec p` and so meet in a most 1 point.
• For `n=2`, suppose `X` and `Y` are separated by the line `L=P(\vec p, vec n)`. Let `e = \vec n(\vec p)`. So `vec n(X) \subseteq (-infty , e]` and `vec n(Y) \subseteq [e,infty)` and so these two sets share at most `e`. If `L` contains two distinct vertices from `X` and `Y` we are done. Suppose not, let `r_1` be the closest point in `S` to the line L. Let `L'` be the line parallel to `L` through `r_1`. Rotate `L'` through the smallest angle possible until it bumps into another point of `S`. Let this other point be `r_2`.
• In the general case `n> 2`, we start with a hyperplane and do the same kind of rotate through smallest angles until we get `n` points.

Convex Hulls

• The previous theorem in the case where `Y` is a point can be improved to:

Theorem. Let `vec p_1, vec p_2, \ldots, \vec p_s` and `vec q` be points in `mathbb{R}^n`. Assume that the convex hull of `X` of `vec p_1, vec p_2, \ldots, \vec p_s` has dimension `n`. Then `vec q` is disjoint from `X` iff there is a subset `vec r_1, vec r_2, \ldots, vec r_n` of linearly independent points of `vec p_1, vec p_2, \ldots, \vec p_s` so that the hyperplane with these points separates `X` and `vec q`.

Definition. A point `vec v` is said to be a vertex or an extreme point of a convex set `C` if `vec v` does not belong to the interior of any segment whose endpoints lie in `C`.

Corollary Let `vec p_1, vec p_2, \ldots, \vec p_s` and `vec q` be points in `mathbb{R}^n`. Assume that the convex hull of `X` of `vec p_1, vec p_2, \ldots, \vec p_s` has dimension `n`. Let `Y` be the convex hull of `vec p_1, vec p_2, \ldots, \vec p_(s-1)`. Then `\vec p_s` is a vertex of `X` iff either:

1. `Y` is (n-1)-dimensional, or
2. there is a set of n linearly independent points in `vec p_1, vec p_2, \ldots, \vec p_s` whose hyperplane strictly separates `Y` and `vec p_s`.

Let `m=s+t`. The proofs of the theorems above give `O(m^(n+1))` algorithms for whether the intersection of convex hulls of `s` and `t` points intersect. i.e., choose a subset of size `n` and try to verify the condition of the theorem for that subset. One also gets an order `O(s^(n+1))` algorithm for deciding if a point is a vertex of a convex hull.