Introduction

We have been talking about geometric modeling.
On Monday, we described winged-edge representation
Then we talked about implicit surfaces and constructive solid geometry using the idea of regular sets.
We said in this approach we typically use half-spaces of algebraic function as primitives, and then build up trees where internal nodes are either regular set operations, like regular set union, difference, intersection, or complement, or are translation, scaling or rotation operations.
To render a CSG shape we could imagine using ray-tracing. For simple algebraic functions like spheres, planes, etc we already have intersection algorithms. So it suffices to come up with a way to say whether a ray hits the boundary of a CSG-tree inductively based on whether it hits one of the primitives in the tree. This might involve a traversal down the tree to fix the locations of the primitives, followed by a percolation back to the root checking in, out, or on.
We used CSGs to represent regular sets. We said another way to represent regular sets was to represent their boundary, typically as faces, edges, and vertices in some data structure representation like winged-edge. This might be more suitable for a traditional graphics pipeline.
We then started saying how to convert between CSG and b-rep's. We said as a first step we need to determine boundaries for each of the primitives. This might involve tessellation, if we are only approximating the boundary. We know the boundary of the CSG-tree `X`, `del X`, is contained in `cup del H_i`. We divide points in the latter into in, out, and on, setting `del X` to be those that are on.
The last step involved using a PMC (point membership classification function) which we briefly describe now...

Still More on Converting from CSG's to B-rep's

One computes PMC by using the CSG structure of `X`.
That is, we know the value of PMC for the CSG primitives (i.e., the halfspaces)
One then needs to know how the values combine for the various r-set operations.
For example, for `cap^star`, given the PMC for r-sets `X` and `Y`, we get the following table:

Y in Y on Y out

X in in on out

X on on on/out out

X out out out out
Notice the hard case is when it is on the boundary of both X and Y.
To handle this one uses an auxiliary neighborhood function `N(\vec p, X)` which evaluates to true or false and we set the value in the `on-on` case to `on` iff `N(\vec p, X)` evaluates to true.
In general, the N function can be complicated...
Nevertheless, as an example in 2D where the primitives are rectangles, one can use the neighborhood function consisting of four true or false values. One looks at a disc containing `\vec p` and breaks it into four quadrants and labels each quadrant true or false depending on whether X is in that quadrant.
Intersection of X and Y then amounts to ANDing the values of the four quadrants of X and Y and checking at least one quadrant remains true.
In 3D, one extends this notion to octants rather than quadrants.

	Y in	Y on	Y out
X in	in	on	out
X on	on	on/out	out
X out	out	out	out

Volume

Let's now look at some other geometric modeling techniques...
Volume representation is a kind of implicit representation that uses a regular 3D grid of discrete values called voxels.
Using trilinear interpolation over each grid cell, these voxels define a continuous function in 3D.
The zero-set of this function can then be thought of as an implicit surface.
Volume data might come from this likes MRI scans, etc.
To render the zero-set of a volume-based representation in OpenGL, one needs to extract a set of triangles that approximate the zero-set.

One approach to do this is the marching cube algorithm:

For each voxel
   Label the voxel vertices in some canonical way 0...7
   let total_in = 0
   For each vertex i of the determine if it is in/on or out of the surface
       if in/on let total_in += 2^i
   Look-up total_in in a table of 256 voxels surfaces output that shape for this voxel.

Using rotation, etc symmetry you can reduce the number of possibilities to 15.
The figure above (from Wikipedia) illustrates some of the possible voxel surface outputs.

Parametric patches

Parametric Patches represent a section of a surface called a patch using three coordinate functions `x(s,t)`, `y(s,t)`, and `z(s,t)`. I.e., this might map a unit square into some surface in `RR^3`.
These functions are defined over some square or triangular patch of the plane.
The most common parametric representation is the tensor-product spline surface: we start with a spline like a bezier curve for each of `s` and `t` and tensor product them.
In the cubic case this fields a Bezier surface patch as described earlier in the semester.
To render this, we use recursive subdivision until the patch in question is sufficiently close to a quad that we just draw the quad.
Parametric patches have issues like "cracking".
It is also in general hard to model closed surfaces like balls, because of the need to correctly stitch together some number of the patches.

Subdivision Surfaces

Example of one step of subdivision refinement

Often people use subdivision surfaces to get around some of the problems of parametric patches.
The basic idea of subdivision surfaces is to start with a single control mesh which need not be rectilinear.
We then use a set of refinement rules to map the starting simple mesh to a higher resolution control mesh.
This process is recursively applied some number of times until the result can be directly rendered.
No patching step is done in this case.
The rules chosen for refinement are designed so that the meshes that arise after more and more levels of subdivision converge to a smooth limit surface.
One drawback of subdivision surfaces is that the surface representation is not defined by a formula, but rather by a procedure and hence can be difficult to analyze mathematically.

Catmull-Clark

Let's look at a particular approach to subdivision representation due to Catmull and Clark.
One starts with some input mesh `M^0` which is assumed to be "watertight" and have connectivity info for vertices, edges, and faces.
Each vertex is assumed to also define some point in 3D.
To make `M^1`...
- We associate to each vertex `v` in `M^0` a new "vertex-vertex" `v_v` in `M^1`.
- We associate to each edge `e` in `M_0`, a new "edge-vertex" `v_e` in `M^1`.
- We associate to each edge `f` in `M_0`, a new "face-vertex" `v_f` in `M^1`.
- We connect these new vertices as shown on the previous slide. `v_v`'s are connected to `v_e`'s if `e` was incident to `v` in `M^0` and `v_e` is connected to `v_f`'s they were incident to.
One can verify the resulting mesh `M^1` will consist of quads.
We call vertices in the result with four incident edges "ordinary". All other vertices are called "extraordinary".
This process can also be used to generate `M^(i+1)` from `M^i`.
One can verify that when we iterate this process the number of extraordinary vertices always stays the same.

How do we position all these vertices?

We need rules to give coordinates for all these new vertices.
Let `F` be a face in `M^i` surrounded by the vertices `v_j` where `m_f` is the number of such vertices.
We set the geometry of the new face vertex `v_f` in `M^(i+1)` to be the centroid of the vertices in the `M^i` face. I.e.,
`v_f = 1/(m_f)sum_j v_j`.
For an edge `e` in `M^i` connecting `v_1` and `v_2` and separating the faces `f_1` and `f_2`, we set the geometry of `v_e` in `M^(i+1)` to be the average:
`v_e = 1/4(v_1 + v_2 + v_(f_1) + v_(f_2))`.
Finally, let `v` be a vertex in `M^i` connected to the `n_v` vertices `v_j` and surrounded by the `n_f` faces `f_j`. Then we set `v_v` in `M^(i+1)` to be
`v_v = (n_v - 2)/n_v v + 1/(n_v^2)sum_j v_j + 1/(n_f^2)sum_j v_(f_j)`
`n_f` and `n_v` will be typically be the same.
Catmull Clark and others such as Reif have looked at the convergence properties of rules like the above.

Finish Geometric Modeling

Outline

Introduction

Still More on Converting from CSG's to B-rep's

Volume

Parametric patches

Subdivision Surfaces

Catmull-Clark

How do we position all these vertices?