Converting between reps, intersection testing

CS216

Chris Pollett

Apr 6, 2010

Outline

Welcome back from Spring Break!
Before the break we were talking about different kinds of representations of 3D objects.
We talked about the medial axis representation, winged edge representation, BSPs, quadtrees, and octrees
Today, we are going to look at algorithms for converting between representations, and various kinds of intersection testing.

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.

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

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^*`, 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.

Which of the following statements is true?

The medial axis skeleton of a 3D object is always a set of line segments.
Using a winged edge representation we can tell which edges are adjacent to a given face.
A octree is a kind of binary tree.

To convert from a B-rep to a CSG we want to associate half-spaces with each face of the B-rep.
One immediate question is when can a face be represented using halfspaces `H_1, \ldots, H_k`?
For example, the two halfspaces above cannot be used to represent the shaded region.
Adding a diagonal half-plane (separating halfspace) that intersects the ellipses can allow us to represent this shape.
Let a halfspace literal be either a halfspace or its complement. In general, `H_1, \ldots, H_k` can be used to represent only finitely many regular spaces `X`, and any space that can be represented in such a way can be represented as a finite union of intersections of `k` halfspaces literals (one literal for each `H_i`).
Call a canonical intersection term any such intersection involving `k` halfspaces literals.
The next result characterises when we can get a CSG representation of `X`:
Theorem. Let `H = \{H_1, \ldots, H_k\}` be a collection of halfspaces. A solid with the property that `del X \subset (\del H_1 \cup \cdots \cup \del H_k)` admits a CSG representation based on H iff the interior of every canonical intersection term based on `H` is either entirely contained in `X` or entirely outside of `X`.

We now break the process of converting between B-rep's and CSG's into steps.

Use the b-rep of our solid `X` to specify half spaces associated with each face in the boundary.
Since the halfspaces from 1 might not suffice to describe `X` in a CSG way, we then add additional separating halfspaces. We compute each of the possible canonical intersections of the halfspaces derived in 1. For each cell we classify it as in or out.
We then take the union of the in cells.
This decomposition might have redundant cells so we might run an optimization routine on it to reduce the number of cells.

In order to do the CSG to B-rep conversion needed for the homework we need to be able to compute different kinds of intersections for basic objects.
We next look at some basic algorithms all related to this problem.
These algorithms are useful for other things in computer graphics such as clipping, visible surface determination, and collision detection.

To start for Homework 3 what we would like is to be able to figure when a line intersects with a plane.
This would allow us to figure out where a plane halfspace intersects with the bounding edges of our bounding cube.
Given two points of an edge, `\vec P_1`, `\vec P_2`, we can associate a line through by the equation `\vec L(t) = \vec P_1 + t(\vec P_2 - \vec P_1)`. Let `\vec v = (\vec P_2 - \vec P_1)`.
Given the equation of the plane `Ax + By + Cz = D`. The vector `\vec n = (A,B,C)` will be normal to the plane.
Let `\vec V_1` be any point on the plane (for instance, set `x`, `y` to 0, and let `z = D/C`). Then `\vec L(t)` intersects the plane when `\vec n\cdot(\vec L(t)- \vec V_1) = 0`.
Solving this for `t` gives `\frac{\vec n\cdot ( \vec V_1 - \vec P_1)}{\vec n\cdot ( \vec P_2 - \vec P_1)}`.
One then checks that this value of `t` is within an edge.