CS 551/651-2: Advanced Computer Graphics

Goal: Experiment with different techniques to simplify polygonal objects

Assigned: Tuesday, March 27, 2001

Due: Thursday, April 5, 2001

Relevant reading /software:

• A few papers describing algorithms you may wish to use:
  • Low, Kok-Lim, and T.S. Tan. "Model Simplification Using Vertex Clustering". In 1997 Symposium on Interactive 3D Graphics (1995), ACM SIGGRAPH, pp. 75-82.
  • Schroeder, William, J. Zarge and W. Lorenson, "Decimation of Triangle Meshes", Computer Graphics, Vol. 26 (SIGGRAPH 92).
  • Hoppe, Hughes. "Progressive Meshes", Computer Graphics, Vol. 30 (SIGGRAPH 96).
  • Garland, Michael, and P. Heckbert, "Simplification Using Quadric Error Metrics", Computer Graphics, Vol. 31 (SIGGRAPH 97).
• The fidelity of your results will be evaluated with the METRO tool, available at http://vcg.iei.pi.cnr.it/metro.html.  Unfortunately, METRO is only provided for SGIs.
• METRO reads files in the PLY format:
• Here are some models; more are on the web (notably at Stanford and Georgia Tech).
• Here is a library for reading and writing ply files (however, you may just want to read and write ASCII ply models, the structure of which should be obvious from the above models).
• Here are some pre-simplified models to which you can compare your results.  You should be able to produce models with at least this degree of fidelity.

Synopsis: You will write a filter to read in an object file in the .ply format (described on the web page) and write out a simplified version with fewer polygons. Your program should be named simplify and should take an argument –t <num>, where num is the number of polygons desired. You can use any algorithm you like to simplify the model, but be aware that some algorithms make it easier to choose the degree of reduction than others do. Your program will be graded on fidelity and speed; doing very well in either category can get you a good grade. Accuracy in degree of reduction (i.e., how closely the number of polygons in the simplification matches the specified number of polygons) matters—within 10% of the simplified model size is close enough for full credit).  Your assignment must compile and run on an SGI.  I will compile all assignments on sgi-01.unixlab.virginia.edu.

Example usage: Your program should be a filter, reading from stdin and writing to stdout:

% simplify –t 1000 < object.poly > simplification.poly

Note that this also allows cascading simplifications by piping the output of one simplify process into the input of another:

You can be sure that I will try this.

Grading: The usual 10-point scale.  I will publish a few sample simplifications that you can look at in METRO to evaluate the quality of your own work.  You can get a good grade (8 or 9) by achieving high fidelity, or extreme speed (while still producing an actual LOD!).  The fastest and highest fidelity simplifications, as measured by METRO at some set number of polygons, get automatic 10s.  If your program ever crashes on my examples, that will hurt your grade, so write robust code.

Turning in the assignment: The usual.  Send me a zipped directory containing your code, a readme, and a couple of sample simplifications.  

Advice:

• It will make your task easier if you triangulate the object as you read it in. You may assume that all polygons specified in the input file are convex.
• You will want some sort of internal data structure to represent the polygonal model. One useful structure is to have a list of faces (triangles), each of which points to the vertices it contains, and a list of vertices, each of which points to all the faces (triangles) that contain it. You may need a more sophisticated structure depending on the algorithm. One good structure is the winged-edge data structure, described in Foley and van Dam.
• Vertex clustering and decimation are probably the easiest simplification algorithms to code up. Of these, vertex clustering is probably simpler, but decimation allows better control over the degree of simplification. The Quadric Error Metrics algorithm is probably the best combination of speed, fidelity, and robustness, but is more complex to code. Extra credit will be given for inventing a new algorithm, or implementing a difficult algorithm, provided of course that it works.

Honor Code: The usual rules.  Public-domain code is available on the web for many simplification algorithms. You are specifically forbidden to use code from an external source for this assignment. While I encourage you to read the papers, study the presentations, and generally use the resources of the web, I want all code you write to be your own. See me if you have any questions about how this applies.