1. Last Time B-splines Project 3 was made available
Recall a property of B-spline surfaces – the control point grid must be rectangular
Project 3 was made available

2. Today
Subdivision schemes
Homework 6 available

3. B-splines as Approximation
B-splines were developed as approximation functions
Given a set of points – the control points – the B-spline approximates them with a smooth curve or surface
Ideally, we would like to be able to provide a polygonal mesh, and then smooth it out with a B-spline surface
The 3D equivalent of smoothing a 2D poly-line with a B-spline
But we can’t do this in general, because B-spline control meshes must be rectangular
Can’t even to simple cases like a sphere

4. Subdivision Schemes
Basic idea: Start with something coarse, and refine it into smaller pieces, smoothing along the way
We have seen how subdivision may be used to render parametric curves and Bezier surfaces
We will see how it can be used for modeling specific objects, and as a modeling scheme in itself
In this lecture:
Subdivision for tessellating a sphere, and implementation details
Subdivision for fractal surfaces
Subdivision for B-spline patches
General subdivision surfaces

5. Tessellating a Sphere
Spheres are best parameterized in polar coordinates:
Note the singularity at the poles
Tessellation: The process of approximating a surface with a polygon mesh
One option for tessellating a sphere:
Step around and up the sphere in constant steps of  and 
Problem: Polygons are of wildly different sizes, and some vertices have very high degree

6. Subdivision Method
Begin with a course approximation to the sphere, that uses only triangles
Two good candidates are platonic solids with triangular faces: Octahedron, Isosahedron
They have uniformly sized faces and uniform vertex degree
Repeat the following process:
Insert a new vertex in the middle of each edge
Push the vertices out to the surface of the sphere
Break each triangular face into 4 triangles using the new vertices
Octahedron
Isosahedron

7. The First Stage
Each new vertex is degree 6, original vertices are degree 4
Each face gets split into 4:

8. Sphere Subdivision Advantages
All the triangles at any given level are the same size
Relies on the initial mesh having equal sized faces, and properties of the sphere
The new vertices all have the same degree
Mesh is uniform in newly generated areas
This is a property we will see later in subdivision surfaces
Makes it easier to analyze what happens to the surface
The location and degree of existing vertices does not change
The only extraordinary points lie on the initial mesh
Extraordinary points are those with degree different to the uniform areas

9. Fractal Surfaces Fractals are objects that show self similarity
The word is overloaded – it can also mean other things
Landscapes and coastlines are considered fractal in nature
Mountains have hills on them that have rocks on them and so on
Continents have gulfs that have harbors that have bays and so on
Subdivision is the natural way of building fractal surfaces
Start with coarse features, Subdivide to finer features
Different types of fractals come from different subdivision schemes and different parameters to those schemes

10. Fractal Terrain (1) Start with a coarse mesh
Vertices on this mesh won’t move, so they can be used to set mountain peaks and valleys
Also defines the boundary
Mesh must not have dangling edges or vertices
Every edge and every vertex must be part of a face
Also define an “up” direction
Then repeatedly:
Add new vertices at the midpoint of each edge, and randomly push them up or down
Split each face into four, as for the sphere

11. Fractal Terrain Example
A mountainside

12. Fractal Terrain Details
There are options for choosing where to move the new vertices
Uniform random offset
Normally distributed offset – small motions more likely
Procedural rule – eg Perlin noise
Scaling the offset of new points according to the subdivision level is essential
For the subdivision to converge to a smooth surface, the offset must be reduced for each level
Colors are frequently chosen based on “altitude”

13. Fractal Terrains

14. Terrain, clouds generated using procedural textures and Perlin noise
tool is called Terragen

15. Terrain, clouds generated using procedural textures and Perlin noise
tool is called Terragen

16. Fractal Terrain Algorithm
The hard part is keeping track of all the indices and other data
Same algorithm works for subdividing sphere
Split_One_Level(struct Mesh terrain)
Copy old vertices
for all edges
Create and store new vertex
Create and store new edges
for all faces
Create new edges interior to face
Create new faces
Replace old vertices, edges and faces

17. Subdivision Operations
Split an edge, create a new vertex and two new edges
Each edge must be split exactly once
Need to know endpoints of edge to create new vertex
Split a face, creating new edges and new faces based on the old edges and the old and new vertices
Require knowledge of which new edges to use
Require knowledge of new vertex locations

18. Data Structure Issues
We must represent a polygon mesh so that the subdivision operations are easy to perform
Questions influencing the data structures:
What information about faces, edges and vertices must we have, and how do we get at it?
Should we store edges explicitly?
Should faces know about their edges?

19. Edge Data (iteration 1)
The mesh must store all the edges, because we need to loop over them to split them
The edge must store its endpoints, because we need them to split the edge
A flag to turn off vertex perturbation is useful for boundary edges
struct Edge {
int v_start; // Index of start vertex
int v_end; // Index of end vertex
bool no_perturb; }

20. Face Data Faces are triangles
To split, a face must know its vertices or edges. Which?
To split, the face needs to know where the new vertices and new edges are stored
They were created when each edge was split
Where do we store them so that the face can find them?

21. Face Data (iteration 1)
When an edge is split, it makes sense to store the new vertex and new edges as part of the existing edge
Faces can then store their edges, and access the information for splitting from the edges
Each edge is stored once, so neighboring faces see the same information
Edges may point “forwards” or “backwards” around a face, and we must store this
struct Face {
int edges[3];
bool forward[3]; }

22. Face Data
When an edge is split, it makes sense to store the new vertex and new edges as part of the existing edge
Faces can then store their edges, and access the information for splitting from the edges
Each edge is stored once, so neighboring faces see the same information
Edges may point “forwards” or “backwards” around a face, and we must store this
struct Face {
int edges[3];
bool forward[3];
float n[3]; }

23. Edge Data (iteration 2)
Need to know endpoints, new vertex when split, and new edges when split
Store as indexes into a list
struct Edge {
int v_start; // Index of start vertex
int v_end; // Index of end vertex
int v_new; // Index of new vertex
int e_start; // Index of one sub-edge
int e_end; // Index of other sub-edge
bool boundary; }

24. Rendering
To render, we must be able to find the vertices around a face
We have these, as part of the edges around the face
We also require vertex normals for smooth shading
These can be computed by first computing face normals, then averaging to find vertex normals
And we might require texture coordinates
When an edge is split to create a new vertex, average the endpoint texture coordinates to get the coordinates for the new vertex

25. Computing Normals
Can be done in two passes through the vertices, and one pass through the face
Loop over vertices: Set the vertex normal to the zero vector and set a counter to zero
Loop over faces: Compute the face normal, and add it to each vertex normal around the face, and increment the counter at each vertex
Face normal comes from taking cross product of two edge directions and normalizing
Loop over vertices: Divide the normal by the counter, and normalize

26. Vertex Data struct Vertex { float x[3]; float tex[2]; float norm[3];
int num_faces; }

27. Mesh Data Structure Mesh stores: Vertices, edges and faces
The up direction for offsetting vertices
struct Mesh {
int num_vertices;
struct Vertex *vertices;
int num_edges;
struct Edge *edges;
int num_faces;
struct Face *faces;
float up[3]; }

28. General Subdivision Schemes
Subdivision schemes can also be used where there is no “target” surface
They aim to replace a polygonal mesh with a smooth surface that approximates the coarse mesh
There are many schemes:
Butterfly scheme (for triangular meshes)
Catmull-Clark subdivision (for mostly rectangular meshes, converges to B-splines in uniform regions)
Loop’s scheme (for triangular meshes)
Modified butterfly scheme (for triangular meshes)
Many more…

29. Butterfly Scheme Subdivides the same way we have been discussing
Each edge is split
Each face is split into four
Rules are defined for computing the splitting vertex of each edge
Basic rule for a uniform region
Splitting an edge with endpoints that have degree 6
As before, all new interior vertices will have degree 6
Take a weighted sum of the neighboring vertices
Weights define rules

30. Butterfly Scheme (1) c b c a a d d c b c
Multiply each vertex by its weight and sum them up
w is a control parameter – determines how closely the shape conforms to the original mesh

31. Modified Butterfly Scheme
The butterfly scheme must be modified to deal with edges with an endpoint of degree  6
In that case, compute new vertex based only the neighbors of the extraordinary vertex
If an edge has two extraordinary endpoints, average the results from each endpoint to get the new endpoint
The modified butterfly scheme is provably continuous about extraordinary vertices
Proof formulates subdivision as a matrix operator and does eigen-analysis of subdivision matrix

32. Modified Butterfly Schemev
eN-1
eN-3
eN-2

33. Modified Butterfly Example
Notes:
The mesh is uniform everywhere except the original vertices
It interpolates the original vertices
It has smoothed out the underlying mesh