Outline

• Early Representation Schemes
• Quiz
• Many More Representation Schemes

Introduction

• Last Thursday, we began looking at representation schemes in Geometric Modeling.
• We said we had already been looking at boundary representation schemes, so were going to look at a different approach based on constructive solid geometry (CSG).
• We defined r-sets, generic halfspaces, and regular operations and said how they could be used in the CSG approach.
• We then discussed a little bit about what makes a good representation.
• Today, we are going to look at several other representation schemes and see how valid, unambiguous, unique each is, as well as, other criteria for "goodness" a representation scheme might have.

Other Criteria of Goodness of a Representation

• Robustness and numeric precision
• Compactness
• Computational ease and applicability
• Ability to convert between representation
• Good as user representation
• Good as a machine representation

Early Representation Schemes

• Engineering Drawings -- Created by humans. Often involved planar projects of the 3D object. As such, such representations were often ambiguous.
• Wireframe Representations -- represent a polyhedra as a collection of its points and edges. This scheme is ambiguous as well. For instance, take two nested cubes, one big, one small. Connect the corners of the outer cube to the inner cube's corner in the natural way. This wireframe might represent more than one 3D object with a beveled hole through it. This representation is quick though and most modeling tools do support a wireframe display.
• Faceted Representations -- represents a polyhedra as a collection of points, edges, and faces. This should be a contrasted with the faceted display of an object on the screen such as a sphere even though it is represented internally as a base point and a radius.
• Primitive Instancing Schemes -- represents an object using a finite number of tuples of the form
  `(type code, parameter 1, \ldots, parameter k)`
  where the type code is of some generic primitives such as sphere, etc.

Quiz

Which of the following statements is true?

1. Knot insertion is used to convert from a B-spline to a piecewise Bezier curve.
2. gluNurbsCurve only works with NURBs and not usual B-splines.
3. A cone can be represented as an intersection of analytic halfspaces but can't be represented by an intersection of finitely many polynomial halfspaces.

Boundary Representations

• We have talked about how we can define a surface in 3D using things like Bezier patches or B-spline patches.
• 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.
• This data structure allows one to re-use vertices, edges, and faces.

The CSG Representation

• We already said last Thursday we could represent objects starting from a set of primitive halfspaces and using regularized union, intersections, differences and complements.
• Now though 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 later.

Euler Operations

• The Euler Characteristic is an important invariant of an object in `\mathbb{R}^n`. For a polyhedra in 3D it can be defined as `\chi = F - E +V` where F is the number of faces, E is the number of edges, and V is the number vertices. It can be defined for other objects and for higher dimension.
• Euler operations are kinds of operations on solids that change an object but leave its Euler characteristic either unchanged or changed in some well-defined way. These operations consist of cutting or pasting faces, edges, collapsing edges or vertices to a point, or expanding points or edges into edges or faces.
• For example, you can cut a torus twice and get a rectangle.
• Elementary collapsing/expansion does not change the Euler characteristic, but cutting and pasting does.
• Any surface, hence any solid in 3D can be obtained from a point by a sequence of elementary expansions, cuts, and pastes. This suggests the following way to represent polydra:
  Definition. The Euler operation representation of polyhedra is defined by the collection of pairs `(X, (\sigma_1, \sigma_2, \ldots, \sigma_k))` where `X` is a polyhedra and `(\sigma_1, \sigma_2, \ldots, \sigma_k)` is a sequence of Euler operations that produce `\partial X` starting with the empty set.
• The early computer vision program GEOMED, the system BUILD, DESIGNBASE, and GWB used the Euler operation representation.
• Basically, this is a b-rep approach where we constrain how we build up our surfaces.

Sweep Representations and Generative Modeling

• In these representations we have a set of base generator shapes and we allow either translational, rotational sweeps, or more "general" sweeps of these shapes.
• For instance, one can make a cylinder by starting with a circle and sweeping it along a line
• A more general sweep would be something of the form:
  `S(u,v) = f(\gamma(u), v)`
  where `\gamma:[a,b] \rightarrow \mathbb{R}^3` is a curve and `f:\mathbb{R}^3\times\mathbb{R}\rightarrow \mathbb{R}^3`.

Parametric Representations

• We have already seen how to parameterize some surfaces such as Bezier patches as functions `\vec f(u,v)` of the unit square.
• One can extend this idea to higher dimensions to parameterize some solids (volumes) as functions of the unit cube.
• For example, a cylinder might be parameterized as
  `p(r, \theta, z) = (r \cos \theta, r \sin \theta, z )` for `r\in [0,1]`, `\theta \in [0, 2\pi]`, and `z\in[0,2]`.

Decomposition Schemes

• Decomposition representation schemes represent objects as a union of quasi-disjoint pieces.
• There are two main types: object-based or space-based.
• The former present a subdivision of the object itself into smaller parts.
• The latter are used to split up and organize a whole scene into smaller objects.
• If a decomposition scheme, splits space up in a regular way, say into voxels, it is called a uniform schemes; it how it splits up space depends on the location of subobjects it is called adaptive.
• An example of an adaptive rep would be a cell decomposition scheme. This takes an object and splits it into cells in the topology sense much like the data structure we gave back on the b-rep slide.
• An example of a uniform rep would be a spatial occuppancy enumeration scheme. Such a scheme might represent space in terms of volume elements (voxels) and for each such element store information about its characteristics.