Outline

• Some more remarks about the Voronoi Diagram Algorithm
• Quiz
• Curvature

Introduction

• Last week, we finished talking about visible surface algorithms and looked at algorithms to compute convex hulls.
• Then we considered the problem of constructing a triangulation for a polygon.
• Finally, we talked about Voronoi Diagrams and Delauney Triangulation.
• Today, I am going to begin by elaborating on some of the details of the Voronoi Diagram algorithm we talked about last week.
• Then we will talk about curvature.

More on Voronoi Diagram Algorithm

• Let's try to be a little more explicit about the Voronoi Diagram algorithm of last day.
• To start let's assume that we have a data structure consisting of a list `P` of points `vec p_i`.
• We first read point `vec p_0`.
• Our basic winged-edge structure for a face looks like:

  class Face {
    List<Edge> edges;
    FaceDataObject data;
  }
  
  

• The FaceDataObject should be a class that can be used to contain the point `vec p_0` or in general a point from the list `P`.
• Initially, we create a face list consisting of one Face containing `vec p_0`. This face's edge list is empty.

VD Algorithm (cont'd)

foreach remaining point p from P {
  foreach face F {
    do the normal test on p with respect to F's edge list 
       to determine if p is surrounded by F.
       (for an empty edge list this test trivially succeeds)
    if `yes` break;
  }
  Initialize faceList to be empty list
  Initialize edgeList to be empty list
  Initialize vertList to be empty list
  Initialize lineList to be empty list 
  set currentFace = F
  do {
     let p(currentFace) be the point from our initial set P that was stored
        in the FaceDataObject of currentFace.
     compute the equation of the line L which perpendicularly bisects
        p and p(currentFace) 
     Put L in a list lineList
  
     foreach edge e of currentFace {
        if L intersects e {
           let p(L) be the intersection of L and e
           add p(L) to vertList;
           add e to edgeList
           let e(currentFace) be the other Face for this edge
           add currentFace to faceList
           set currentFace = e(currentFace);
           break;
        }
     }
  } while (currentFace != F)
  build a new face using the vertices in vertList
  To make the necessary edges note that the other face adjacent to the edge 
     corresponding to vertices v_i, v_(i+1) in vertList is face F_i
     from faceList 
  Edges from F_i which don't intersect v_i, v_(i+1) and are on the p side
     of line L_i from lineList should be deleted and F_i should be modified
     to now have the edge v_i, v_(i+1) (winged-structure appropriately set-up).
  After doing the above we have a new Voronoi diagram which incorporates p
     and we are ready to loop to the next point.
}

Quiz

Which of the following statements is true?

1. The Warnock area subdivision algorithm as presented in class would draw a scene from the top of the screen to the bottom, a scan line at a time.
2. There are examples of convex polygons which cannot be triangulated using a triangle fan.
3. We used linear separability to develop an algorithm for convex hulls.

Introduction Curvature

• Suppose we have a parametric surface, one way to represent it is using an elevation grid where points on this grid are uniformly spaced.
• If the surface is relatively flat, then we are storing a lot of points unnecessarily.
• The notion of "flatness" of a surface is connected to its curvature.
• We are next going to talk about what is curvature in both curve and surface setting.
• This is material from Ch15 in the book.

Curvature

• Let `\vec \gamma: [0,1] \rightarrow \mathbb{R}^n` be a curve.
• Its derivative is then `\vec \gamma'(s) = \frac{d \vec\gamma(s)}{ds} = \lim_(h \rightarrow 0) \frac{\vec\gamma(s+h) - \vec\gamma(s)}{h}`
• Curvature is a measure of how quickly this derivative is changing.
• We write `vec T(s)` for `\frac{\vec \gamma'(s)}{||\vec \gamma'(s)||}`, the unit tangent vector.
• The derivative `vec T'(s)` of `vec T(s)` will be perpendicular to T and measures how quickly `\vec \gamma` is turning with respect to `\vec T(s)`.
• We define the curvature, `\kappa(s)`, of `\vec \gamma(s)` just to be `||vec T'(s)||`.
• From our observation above `\vec N(s) = \frac{vec T'(s)}{||vec T'(s)||}` will be a unit vector normal to `\vec T(s).
• We sometimes call `R = 1/(\kappa(s)` is called the radius of curvature of `\vec \gamma(s)`.
• In three dimension, we can get a basis for a particle moving along `\vec \gamma` using the three vectors `vec T(s)`, `vec N(s)`, and `vec B(s) = vec T(s) \times vec N(s)`.

Curvature of Surfaces

• Suppose one now has a surface given by `vec S:[0,1] times [0,1] \rightarrow \mathbb{R}^3`.
• Then using the gradient `grad S = \langle \frac {del S} {del u}, \frac {del S} {del u} \rangle`, we can define a tangent plane at a point `vec p`.
• Given a curve `\vec gamma(s)` that lies on `vec S`, we could project this curve onto this tangent plane and compute its curvature in this plane.
• This is called the geodesic curvature of `\vec gamma(s)`.
• Another way to get a curvature is to look at the plane given by the tangent `vec T(s)` of `\vec gamma(s)` and the unit normal vector `vec N` to the tangent plane of S.
• We project `\vec gamma(s)` into this plane and compute the curvature. This is called the normal curvature of `\vec gamma(s)` with respect to `vec S`.
• All curves in S with the same tangent vector will have the same normal curvature.
• The principal curvatures `k_1, k_2` of `vec S` at a point `vec p` are maximum and minimum respectively of the normal curvatures with respect to all possible tangent vectors to `vec S`.
• The Gaussian curvature of `vec S` is defined to be the product `k_1\cdot k_2`.
• Next day we will look at some uses of these notions of curvature and how to approximate curvature from a discrete set of points.