Outline

• Recalling Geometric Modeling
• Winged-edge Representation
• Quiz
• Implicit Surfaces

Introduction

• Last week, we began talking about geometric modeling.
• As we said, geometric modeling is the topic of how to come up with such data structures that also us to represent, create, and modify shapes.
• Early examples of such modeling might be engineering drawings and wire-frame representations. As both of these to be some kind of projections, they are somewhat ambiguous (for wireframe think Necker cube).
• We discussed triangle and quad soup representations. i.e., Just represent the item as a sequence of triangles or quads.
• We said these representations had the drawback of not letting one easily "walk along" the geometry to figure out things like which face is adjacent to which, etc.
• We then talked about mesh data structures, which allows us to answer these kind of adjacency questions quickly, and I showed a picture of winged-edge representation, but I didn't really go into too much details.

Winged-Edge Representation

• This data-structure is due to Baumgart (1972, 1975).
• Each face is assume to be bounded by a set of disjoint edge cycles/polygons. One of these is the outside boundary, and the others are the holes in the faces.
• To implement this, one uses a face table that consists of the edges where one takes one edge from each face cycle.
• Each vertex has a circularly ordered set of edges that use it.
• Each edge has:
  • The incident vertices
  • The left face and right face
  • The preceding and succeeding edge in clockwise order with respect to the exterior of the solid
  • The preceding and succeeding edge in counter-clockwise order with respect to the exterior of the solid.

Winged Edge Representation Data Structures from

We only need one circular list for the edges of a face because we can do tricks like in the above picture (from Wikipedia).

Here are some example data structures for Winged-edge representation from Wikipedia:

class WE_Edge {
  WE_Vertex vert1, vert2;
  WE_Face aFace, bFace;
  WE_Edge aPrev, aNext, bPrev, bNext; // clockwise ordering
  WE_EdgeDataObject data;
}
class WE_Vertex {
  List<WE_Edge> edges;
  WE_VertexDataObject data;
}
class WE_Face {
  List<WE_Edge> edges;
  WE_FaceDataObject data;
}

Quiz

Implicit Surfaces

• One way to represent a smooth surface is as set points that evaluate to zero under some given trivariate function `f(x, y, z)`.
• This is called an implicit representation.
• Earlier this semester, we gave the implicit representation for planes and quadrics. For quadrics, we discussed spheres, ellipsoids, and toruses.
• Given a set of implicit functions `f_i(x, y, z)`, we can build a more complicated surface by using various kinds of sums `f(x, y, z) = sum_i f_i(x,y,z)`.
• Doing so with a set of sphere functions creates a smoothly blended union of individual spheres.
• This techniques is known as blobby modeling and is good for organic shapes like sea animals.

Interior/Exterior

• If we define a surface as the zero set of `f`, then we can think of the points where `f` evaluates to a positive value as the volumetric interior of the surface.
• We can then apply volumetric set operations such as union, intersection, negation, and difference, to these interior volumes.
• Above we see courtesy of Wikipedia some examples of differences, intersections, and unions of a sphere and a cube.
• This is one of the ideas behind constructive solid geometry (CSG).
• One of the first projects that used CSG for representing 3D objects was the Production Automation Project at the University of Rochester (1972).
• Modern examples of this approach are used in the Quake and Unreal game engines.
• We give over the next few slides an extended example of building up this approach based on r-sets.

R-sets

• R-set is short for regular set.
• R-sets attempt to capture what it means for a set of points in 3D to define a solid objects.
• For instance, consider the set a box with a line sticking out from it. The box might be solid, but the line, as a one-dimensional object, is not something one would consider solid in 3D.
• We need to introduce a little terminology before we can define an r-set.
• Given a set `X` we say that a point `x` is in its interior, `\text{int}(X)` if we can find a ball of points of some radius centered at `x` such that each point in the ball is also in `X`.
• Given a set `X`, let `{x_i}_(i=0)^\infty` be a sequence of points from `X` which converges to some limit value (a Cauchy sequence). The closure of `X`, `\text{cl}(X)`, is the set `X` together with all such limit points (aka acumulation points) of `X`. A set is closed if `X=\text{cl}(X)`.
• R-sets are defined using the notion of a regularization operator `r`, which we define as follows:
  Definition. Let `X \subseteq \mathbb{R}^d`. The regularization operator r is the operation:
  `rX = \text{cl}(\text{int}(X))`.
  The set `rX` is called the regularization of `X`. A set is an `r`-set if `X=rX`.
• So a closed unit box with a line sticking out of it would not be a regular set but the closed unit box by itself would be.

More on R-sets

• In order to make a modeling system out of r-sets, we need to start with some basic r-sets and say which operations our system will support on such r-sets.
• One simple choice of starting r-sets are the half-spaces.
• A half-space in `\mathbb{R}^n` is any set of the form:
  `H_+(f) = {\vec p | f(\vec p) \geq 0}` or of the form `H_(-) (f) = {\vec p | f(\vec p) \leq 0}`
  for some function `f:\mathbb{R}^n \rightarrow \mathbb{R}`.
• If `H` is a halfspace, then we call `rH` a generic halfspace.
• A finite combination of generic halfspaces using the operations of union, intersection, difference, and complement is called a semi-algebraic or semianalytic set if the functions `f` are all polynomials or analytic functions, respectively.
• As an example the infinite (solid) cylinder of radius `R` about the z-axis:
  `{(x, y, z) | x^2 + y^2 -R^2 \leq 0}`
  is a generic halfspace and a semi-algebraic set.
• By intersecting it with planar halfspaces we could make a finite cylinder.

R-set operations

• So to make a CSG system, you could start off with the generic polynomial half-spaces and start allowing set operations like intersection.
• There are good algorithms for intersecting polynomials, so we can actually draw the results.
• The main problem with allowing the usual operations of union, intersection, difference is that the result may no longer be an r-set. For example, `[0,1]\times[0,1]\times[0,1] \cap [1,2]\times[0,1]\times[0,1]` is a square.
• Since r-sets were our current notion of solid, this is a problem.
• To get around this we define regularized set operations:
  `X \cup^\star Y := r(X\cup Y)`,
  `X \cap^\star Y := r(X\cap Y)`,
  `X -^\star Y = r(X - Y)`,
  `c^\starY = r(cY)` (here c is complement),
  `X\Delta^\star Y = (X -^\star Y)\cap^\star(Y -^\star X)`.

Results about R-set Operations

Facts (we won't prove).
(1) The regularized set operations take r-sets to r-sets. Furthermore, there are algorithms to perform these operations.
(2) The class of regular semialgebraic or semianalytic sets is closed under the regularized set operations.

Agoston (a common book for CS216) gives references into the literature for the proofs of these statements. Of the two statements, (1) is the most useful from a computer graphics point of view. The algorithms mentioned above probably need some caveats. These algorithms assume that for each of the input r-sets `X` and `Y` we have a procedure which can decide given a point `x` whether `x` is inside, outside or on the boundary of `X` (resp. Y). This is for instance certainly doable for polynomially defined generic half-spaces. Given such input procedures for `X` and `Y` we build a procedure for the given r-set operation. i.e., for `X \cup^\star Y` we would combine the procedure of `X` and `Y` to be able to say when something is `x` is inside, outside or on the boundary of `X \cup^\star Y`.

Boundary Representations

• Given our basic r-set set-up how can we try to represent it in a computer?
• A boundary representation is the idea of describing a solid in 3D using just its boundary. Let's consider what this would mean in terms of r-sets...
  Definition. The boundary representation or b-rep of r-sets in `\mathbb{R}^n` is the representation that associates to each r-set `X` its boundary `bX`.
• For a solid object, we can often decompose it as:
  `bX = \cup_(\text{"face"} F \text{of} X) F`.
  
• If we want to make a data structure for such a solid, we could store it as a list of faces, where each face is made up of a face index together with a list of indices of edges from a list of edges. Each edge in the list of edges consists of an edge index, together with vertex numbers from a list of vertices. Each vertex in the list of vertices consists of a vertex number together with the coordinates of its two end points. I.e., this could be stored with a winged-edge like representation.
• This data structure allows one to re-use vertices, edges, and faces.

The CSG Representation

• We would like to be a little bit more precise in what kind of data structure would be needed to model in a CSG way.
• Let `P` be our primitive r-sets in `\mathbb{R}^n`. Let `O` be our regularized set operations. Let `M` be a set of pairs of `(m, x)` or more briefly `mx` where `m` is an operation type like translation, rotation, scaling, etc and `x` is additional data need to specify the given operation. Then a CSG-tree for the tuple `(P, O, M)` is a finite expression of one of the following forms: `p` where `p\in P`, `T_1oT_2` or `T_1o` where `T_1` and `T_2` are CSG-trees and `o\in O`, or `Tmx` where T is a CSG-tree and `mx` is in `M`.
• The realization of a CSG-tree `T` is the space `|T|` build-up recursively from the primitive objects at its leaves and applying the given operations at its internal nodes.
• One important problem for CSG-representations is how to convert between such a representation and a boundary representation, we will consider this problem in more detail next.

Converting from CSG's to B-rep's

• Basic algorithms for converting between CSG and B-rep's were developed in the 1980's (Requicha and Voelcker 1985, Laidlaw, et al 1986, Rossignac and Voelcker 1989).
• Let `X` be a CSG object. Suppose we want to find its boundary. We can perform the following steps:
  1. Determine the boundary of every CSG primitive halfspace `H_i` used in the definition of `X`. In the above diagram we have four lines and a circle.
  2. We know that `\del X \subseteq \cup \del H_i`. We trim the `\del H_i` boundaries against each other (more on this in a moment) to get `\del X`.
  3. To get a more compact representation one finally tries to merge adjacent faces into larger one.

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

• The hard part of the last slide is how to do Step 2.
• We can first subdivide this into two steps:
  1. The points of each `\del H_i` are divided into three subsets which consists of those points that are either in, on, out with respect to `X`.
  2. Then `\del X` consists of all those points which are on.
• In order to do these computations, we make use of a point membership classification functions, `PMC(\vec p, X)` which has value in if `\vec p` is in the interior of `X`, value out if `\vec p` lies in the complement of `X` and on if `\vec p` is on the boundary of `X`.

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.
• 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.