1. Semiautomatic Simplification “semisimp” by Benjamin Watson and Gong Li Presented by John Cihocki

2. Simplification?! But I like my model the way it is.

3. Too Bad  Rendering highly complex models at low resolutions is too expensive. Forget about interactively rendering a detailed space ship if it only makes up a small portion of the scene.  The eye can only perceive detail at a certain depth, so if the eye can’t make it out, why render it?  When rendered polygons get smaller than pixels, aliasing occurs, just like when details on a bump map become near pixel-sized.

4. Placeholder for model and simplified model example.

5. Raytracing is especially compounded by undersimplification  Without using space heuristics, EACH RAY we shoot has to be checked against EACH polygon of EACH model.  If only 500 rays intersect the model, and the scene is 300x300 pixels, we have 0.56 percent of the scene accounting for what can be a very large percent of the render time, depending on the number of models in the scene

6. OK, I’m sold, now how are we going to do it?  For each model we created, we could make a high and low detail object, or even several in between.  Invent an algorithm to automatically simplify a complex model a specified amount.  Problem: Modelers, like programmers, are lazy, and this is a very large amount of frustrating, difficult work.  *Now* we’re getting somewhere.

7. Great! There are existing ways to automatically simplify models. Here’s the ten cent tour from 30,000 feet.  Identify possible simplifications. Maybe one vertex at a time. Maybe one vertex at a time. Maybe one polygon at a time. Maybe one polygon at a time. Maybe one “cluster” of vertices at a time. Maybe one “cluster” of vertices at a time.  Sort these simplifications Calculate “simplification error” that would be introduced by applying each. Calculate “simplification error” that would be introduced by applying each. Sort simplifications into a queue using this factor, smaller error first. Sort simplifications into a queue using this factor, smaller error first. Apply the simplification from the front of the queue, then adjust the queue to reflect the further simplifications on the new primitive. Apply the simplification from the front of the queue, then adjust the queue to reflect the further simplifications on the new primitive.

8. But there are some problems.  Semantic Blurring Noticeably removing or modifying a part of the model very important to its structure. Noticeably removing or modifying a part of the model very important to its structure.  Functional Blurring Removing or “smoothing over” of some things that need to move or function independently of one another. (ie making a robot’s thigh and calf part of one polygonal unit, then wanting it to bend at the knee. Removing or “smoothing over” of some things that need to move or function independently of one another. (ie making a robot’s thigh and calf part of one polygonal unit, then wanting it to bend at the knee.  Inadequate control of simplification In the model definition, it can be possible to avoid the “blurring” effects, but we want to have control at the user level, not the creative level. In the model definition, it can be possible to avoid the “blurring” effects, but we want to have control at the user level, not the creative level.

9. This is where semisimp comes in. Again: Semiautomatic simplification tool implemented on linux using OpenGL and motif libs Giving us user level control of automatic simplification hierachies. (Simplify THIS, but not so much of THAT)

10. Simplification hierarchies  Leaves are elements of the original, detailed model.  Parent of leaves - simplified version of its children (faces, vertices, whatever).  Dotted lasso represents the “cut” of the hierarchy, the model in a partially simplified state. The “cut”

11. Building the simplification hierarchy from the queue  For the graph on the previous page, imagine all leaf nodes are ordered from left to right, 1 - 10. <---Front--Back--->  Queue: S1 = SIMP(3,4),S2 = SIMP(6,7),S3 = SIMP(1,2),S4 = SIMP(9.10)

12. Building the simplification hierarchy from the queue  For the graph on the previous page, imagine all leaf nodes are ordered from left to right, 1 - 10. <---Front--Back--->  Queue: S2 = SIMP(6,7),S3 = SIMP(1,2),S4 = SIMP(9.10),S5 = SIMP(S1, 5)  Apply S1 = SIMP(3,4) … Notice we can now recurse with our simplification!

13. Building the simplification hierarchy from the queue  For the graph on the previous page, imagine all leaf nodes are ordered from left to right, 1 - 10. <---Front--Back--->  Queue: S3 = SIMP(1,2),S4 = SIMP(9,10),S5 = SIMP(S1,5),S6 = SIMP(S2,8)  Apply S2 = SIMP(6,7)

14. Building the simplification hierarchy from the queue  For the graph on the previous page, imagine all leaf nodes are ordered from left to right, 1 - 10. <---Front--Back--->  Queue: S4 = SIMP(9,10),S5 = SIMP(S1,5),S6 = SIMP(S2,8)  Apply S3 = SIMP(1,2)

15. Building the simplification hierarchy from the queue  For the graph on the previous page, imagine all leaf nodes are ordered from left to right, 1 - 10. <---Front--Back--->  Queue: S5 = SIMP(S1,5),S6 = SIMP(S2,8)  Apply S4 = SIMP(9,10)

16. Building the simplification hierarchy from the queue  For the graph on the previous page, imagine all leaf nodes are ordered from left to right, 1 - 10. <---Front--Back--->  Queue: S6 = SIMP(S2,8), S7 = SIMP(S3,S5)  Apply S5 = SIMP(S1,5) … Note that we can now further simplify what we simplified in S3 and S5.

17. This tree is what semisimp helps us with. 1: semisimp takes a detailed model as input. 2: It runs the qslim automatic edge collapsing algorithm on it, and thus generates the simplification hierarchy. 3: It keeps track of the order in which we simplified each node of the hierarchy.

18. Now what can we do with it?  If we traverse the hierarchy in the order we saved, we get the fully automatic qslip simplification of the model. But, now we can do -- 1: Order manipulation 2: Geometric manipulation 3: Hierarchy manipulation

19. Order manipulation  Remember our list, which was the order in which nodes in the hierarchy are obtained (each node represents a simplification, so the list represents the order we simplified in)  We can take a node and tell semisimp to do a “refining reordering,” which means don’t simplify to get this node until later in the list.  Conversely, we can also take a later simplification and cause it to be completed earlier by lowering its number.  Does not modify hierarchy, just modifies order we traverse.  Forces other simplifications to be done first if we stay at same “Level of detail,” or position in the ordering list.  If we pass our parent in the ordering, it and its recursive parents are moved to directly after the new position of our node, one after another.

20. Order manipulation example  The beginning of our ordering list in our previous example was S1, S2, S3, S4, S5, S6, S7 …  If we don’t want to do S1 until after we’ve done S6, we reorder as S2, S3, S4, S6, S1, S5  This is because S5 simplifies the node we got by doing the S1 simplification, so we put it at k+1, k being the new position of S1.  Thankfully, semisimp allows us to do this graphically by clicking a node representing a “patch” in the model, and using an “Level of Detail” slider to indicate when we would like this feature to be simplified/visible.

21. Local Simplification Blue edges define a patch, or subtree of the hierarchy. By moving the root of the subtree to the beginning of the simplification ordering, and therefore all of its children to the beginning, we can simplify this patch without simplifying anything else by adjusting the Level of Detail to only iterate over this patch. Blue edges define a patch, or subtree of the hierarchy. By moving the root of the subtree to the beginning of the simplification ordering, and therefore all of its children to the beginning, we can simplify this patch without simplifying anything else by adjusting the Level of Detail to only iterate over this patch.

22. Geometric Manipulation  In any simplified state of the model, we can graphically reposition vertices to give us more artistic control over the shape of the simplified version.  This forces changes in 2 dimensions in the hierarchy. The nodes remain the same, while topological neighbors (patches close to our changes) as well as simplifications that precede and result from the altered node reflect the changes. The nodes remain the same, while topological neighbors (patches close to our changes) as well as simplifications that precede and result from the altered node reflect the changes.

23. Geometric Manipulation We “arch” the back on our bunny “cut” -> <-- Our more detailed bunny reflects the changes So does our more --> simplified bunny. We kept his back from getting collapsed too far

24. Hierarchy Manipulation  Allows us to define sections of the model which should be contained in their own subtree, thus allowing us to segment simplification.  Then we redo the automatic simplification algorithm to construct the subtree, which only simplifies the specified elements, then at the subtrees root rejoins it with the recalculated remainder or the model.

25. Tree Restructuring Imagine lower line is a “cut” across a greater hierarchy. What if we wanted the patches represented by A, B, and C to be considered a semantic unit? Imagine lower line is a “cut” across a greater hierarchy. What if we wanted the patches represented by A, B, and C to be considered a semantic unit?

26.  Restructure the tree! The algorithm recalculates simplification of the A, B, and C subtrees as an independent unit. Inserts edges reattaching our new subtree. The subtree rooted at D is now the simplification of our semantic unit. …

27. What it looks like Our detailed model Automatic semisimp We kept the head (an important sematic feature) from being overly simplified! Both models: 588 polygons