Outline

• R-sets
• Representation Schemes

Introduction

• Last day, we finished our discussion of B-splines.
• We showed how to go from Bezier curves to B-splines using repeated knots
• We showed how knot insertion could be used to go from B-spline back to Bezier curves.
• We then talked about degree elevation and how to deal with B-splines in homogeneous coordinates (NURBS).
• Finally, we gave the glu, OpenGL calls for both B-spline curves and B-spline surfaces.
• All of the material on Bezier splines and Bezier curves and surfaces allow us to specify objects in 3D by saying what their surfaces look like.
• These are so-called "boundary" representations. Today, we are going to look at different representation schemes for 3D objects.

Geometric Modeling

• Geometric Modeling is the part of computer graphics that deals with the methods and algorithms needed to represent shapes usually in either 2D or 3D.
• One of the first projects that dealt with representing 3D objects was the Production Automation Project at the University of Rochester.
• Their modeler was called PADL-1 and took a Constructive Solid Geometry (CSG) approach to modeling.
• In Constructive Solid Geometry approach, one starts with a certain set of primitive objects and combines them using set-like operations.
• PADL-1 used as its notion of object something called an r-set.
• More recently, CSG approaches have been incorporated into games engines such as Torque and Unreal.

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_n}_(i=0)^\infty` be a sequence of points from `X` which converges to some limit value. 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.
• Their 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

Theorem.
(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 givens 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`.

Representation Schemes

• So we have now looked at one way of representing 3D objects in addition to the boundary representation that B-spline surfaces give us.
• But what is a representation scheme for a geometric object?
  Definition. A representation scheme, or simply a representation, of a set of "objects" `O` using a set `L` is a relation `r` between `O` and `L`. If `(x, y) \in r`, then we shall say that `y` represents `x`. A representation scheme `r` is unambiguous if `r` is one-to-one. A representation scheme is unique if `r` is a function. The elements of `L` are called representations or syntactically correct representations and those in the range of `r` are called semantically correct or valid representations.
• As an example, let `O` be the set of polygons in the plane that have positive area but no holes; let `L` be the set of finite sequences of points. Define `r` to be the representation scheme that associates each object in `O` the set of its vertices listed in some order.
• It is not hard to see this scheme is ambiguous. Furthermore, not all sequences of points are semantically correct as a sequence of collinear points does not correspond to a polygon in `O`.
• So in coming up with representation schemes we want to somehow insure unambiguousness and uniqueness.

Validity of a Representation Scheme

Another problem we would like to know how to solve about representations schemes is whether they are valid:

The Basic Validity Problem for a Representation Scheme: When does a representation correspond to a "real" object, that is, when is a syntactically correct representation semantically correct or valid?

We will look at several more specific representation schemes next day and consider these problems for each of them.