ONE of the most fundamental tasks in computer graphics

Transcription

1 EDIC RESEARCH PROPOSAL 1 Structure-aware Procedural Editing Stefan Lienhard LGG, I&C, EPFL Abstract This research proposal summarizes and reviews three important papers on procedural modelling of buildings, on intuitive interfaces for procedural content, and on structureaware editing based on pattern detection. Manual 3D content creation is very time consuming, grammar based procedural modelling accelerates the process but can be difficult and tedious for non-programmers. Another approach for fast creation or manipulation of shapes is to start with an existing model and to adapt it for new purposes while maintaining prevalent characteristics. This, however, requires the model to undergo an analysis to extract semantic and structural information that should be preserved during editing. In this proposal we seek to establish a link between procedural content creation and pattern or symmetry detection for structure-aware editing. Index Terms shape analysis, symmetry and pattern detection, procedural modelling, shape grammars, interactive shape editing, structural regularity, structure-aware editing I. INTRODUCTION ONE of the most fundamental tasks in computer graphics is the creation of 3D content. Designing and modelling 3D objects is non-trivial, especially for high complexity models, and it is a time-consuming and error-prone process when done manually. Several approaches have been developed with the aim to facilitate or automate this task. One way is to start with an already existing model and to modify it to meet certain Proposal submitted to committee: August 22nd, 2012; Candidacy exam date: August 29th, 2012; Candidacy exam committee: Sabine Süsstrunk, Mark Pauly, Pascal Fua. This research plan has been approved: Date: Doctoral candidate: (S. Lienhard) (name and signature) Thesis director: (M. Pauly) (name and signature) Thesis co-director: (if applicable) (name and signature) Doct. prog. director: (R. Urbanke) (signature) EDIC-ru/ requirements, e.g, as in [1], [2]. These existing models, particularly such man-made objects as buildings and furniture, often exhibit dominant structural relations which provide editing guidelines. During a manipulation, one might desire to change a shape while preserving these structures or one might want to explicitly modify the relations. Thus, a key step is to explore such structural information. Symmetry and regularity, being prevalent in the vast majority of objects, provide high-level information about the models which is important to investigate the underlying structure. Sophisticated methods have been established for finding dominant symmetries and repetitive patterns in 3D models [3], [4], [5]. On the other hand, one can attack the problem from the opposite side and build new models from scratch. With the aid of procedural modelling techniques this process can be automated to a large extent. A big advantage of the procedural approach is that information about structure and patterns is available a priori, it is implicitly given by the production rules. Procedural grammars, such as L-systems [6] or shape grammars [7], are well-researched. A third interesting topic that is addressed in this proposal is how an intuitive user interface could look like, be it for procedural modelling or for structure-aware editing. For both types of modelling, user interface design is an active topic of research. II. BACKGROUND PAPERS The three following sections present the three background papers related to the proposed research. First, Procedural Modelling of Buildings by Müller et al. describes a shape grammar for procedurally creating architectural models [8]. It allows the automatically generation of models of massive urban environments and entire cities. Highly detailed content for movies or games can be created in a fraction of the time that a human artist would require. The second paper, An Algebraic Model for Parameterized Shape Editing, focuses on structure-aware editing [9]. A first step analyses a given input shape and finds global characteristics and structures such as repeating patterns. In a second step, the shape is interactively deformed while maintaining the found structures. Finally, in Interactive Modelling by Procedural High-Level Primitives, Lars Krecklau and Leif Kobbelt introduce novel concepts for the intuitive and interactive handling of complex procedural shapes without requiring the user to understand the rules of the underlying grammar [10]. This allows amateurs and non-programmers to easily modify and combine procedural content.

2 EDIC RESEARCH PROPOSAL 2 III. PROCEDURAL MODELING OF BUILDINGS [8] Modeling large virtual environments like cities is very labour-intensive. Back in 2006, Müller et al. introduced the CGA Shape [8] that automates this task by using procedural modelling. CGA Shape extends available shape grammars [7] and split grammars [11]. Production rules are used to iteratively design buildings. First a crude volumetric model of a building, a so-called mass model, is created. Afterwards, more and more details are added hierarchically: the façades are structured, and in the end one adds details for the floors and windows. Interactions between parts of the models are handled by context sensitive ruled that ensure, e.g., that windows do not intersect with walls, that certain parts of the model are not occluded, or that doors are only placed in the front of the house leading to the street.. A. The Shape Grammar CGA Shape is inspired by L-systems [6]. However, CGA Shape has been extended to suit architectural modelling. One main difference is that CGA Shape is a sequential grammar. The rules are applied sequentially allowing the design of structure, i.e., the spatial distribution of features and components (L-systems, on the other hand, execute their rules in parallel). Also, shape grammars replace shapes and not strings as L- systems do. The grammar s basic element is a shape consisting of a symbol (either a terminal or a non-terminal symbol), geometry (geometric attributes), and numeric attributes. The most important attributes (position, three orthonormal vectors, and a size vector) define a oriented bounding box called a scope (see Figure 1 on the left). condition is fulfilled. Stochastic rules are possible by associating probabilities to several rules with the same predecessor (and condition). The grammar is similar to L-systems and uses common rules for adding, scaling (S), translating (T), and rotating shapes. Also [ and ] are used to push and pop the current scope on or from a stack. An example (the result is shown in Figure 1 on the right) is the following rule: 1 : A [T(0, 0, 6)S(8, 10, 18)I( cube )] T(6, 0, 0)S(7, 13, 18)I( cube ) T(0, 0, 16)S(8, 15, 8)I( cylinder ), where I is the command for instancing geometric objects (can be arbitrarily complicated models and not just simple primitives as in the example). Among the most fundamental rules are also split and repeat commands, e.g., 1 : fac Subdiv( Y, 3.5, 0.3, 3, 3, 3){floor ledge floor floor floor} will partition a façade along the y-axis into four floors with fixed heights. Using fixed values might cause problems as they only work for a certain scope size. A new contribution was the use of relatives size which allow to completely fill a scope. Relative values for sizes are marked with r. The following example splits a floor into four windows, two of which have non-absolute width: 1 : floor Subdiv( X, 2, 1r, 1r, 2){B A A B}. The described examples are depicted in Figure 2. Fig. 1. Left: Scope of a shape. The position P together with three axis and sizes defines a box that encloses the shape. Right: A simple mass model. Starting with an arbitrary configuration of shapes, called the axiom, the production process works as follows: (1) an active non-terminal shape B is selected, (2) a production rule for B is chosen and applied and the result is a set of successor shapes, (3) finally B is marked as inactive and the new shapes from step two are added to the configuration. These three steps are repeated until only terminal symbols remain. Symbol and rule selection are both ambiguous. This is resolved by assigning priorities to production rules and using a breadth-first derivation in step one. Usually priorities are assigned to rules according to the amount of detail a rule introduces. This way a building evolves from low to high detail in a controlled manner. The notation for production rules is: ruleid : predecessor : condition sucessor : probability. Rules can be associated with conditions to make them context sensitive. A rule with a condition can only be selected if the Fig. 2. Left: A façade design. Right: use of relative sizes allows to fill the whole scope. Further, a so-called repeat split rule, e.g., 1 : floor Repeat( X, 2){B} horizontally tiles as many elements of type B as there is space in the scope. If there is no exact fit, the elements get scaled to match the scope. Component splits allow to break up higher-dimensional shapes into lower-dimensional shapes. This is mainly used to add more details to façades and roofs after the mass model has been established. Comp( faces ){A}, Comp( edges ){A}, Comp( vertices ){A} creates new shapes (of two or one dimension) of type A for faces, edges, or vertices respectively. It is also possible to select specific components only (e.g. Comp( edge, 3){A} for the third edge). To switch back to higher dimensions one uses the scope size command S with a non-zero value along an axis that was zero before. This is used, e.g., for instancing detailed three-dimensional bricks on a roof that was first designed as a two-dimensional grid of tiles.

3 EDIC RESEARCH PROPOSAL 3 B. Modelling Strategy The described grammar is sufficient to create arbitrary building models. The main question is how to use and combine the grammar rules to assemble a building step by step. Given a scope for a building, the strategy is to first build the mass model with simple volumetric primitives such as cylinders, cubes, and unions of these. It is a necessity to also have predefined volumetric shapes for different types of roofs as shown in Figure 3. Rules that create the mass model have a Fig. 4. Left: A detailed building, created procedurally by CGA Shape. Right: Stochastic variations of the same mass model. Only four rules are used to produce one of the mass models. Fig. 3. Simple mass models with different roof types. Roofs from left to right: gambrel, cone, gabled, hipped, cross-gable, and mansard. higher priority than rules that arrange smaller details. Once the volumetric mass model (including its roof) is ready, component splits are used to switch to two-dimensional scopes, and façades and roof surfaces are modelled. This way the façades are correctly aligned and parameterised. At last, the scope is often extended again to three dimensions and concrete models are loaded from files and instantiated to represent the smallest details such as windows, bricks on the roof, etc. Not just the grammar, but also this general modelling strategy is a key contribution of the paper, especially the idea of transitioning from mass modelling to façade and roof modelling through component splits. CGA Shape allows for more intuitive modellings rules than previously defined split grammars [11]. Split grammars are well suited for pure façade design, but they have limitations in mass modelling. An example from the paper is given in Figure 4. On the left is a final building with details, on the right is a bunch of mass models that were all created with the same four stochastic rules: 1 :lot S(1r, building height, 1r) Subdiv( Z, Scope.sz rand(0.3, 0.5), 1r){facades sidewings} 2 :sidewings Subdiv( X, Scope.sx rand(0.2, 0.6), 1r){sidewing ɛ} Subdiv( X, 1r, Scope.sx rand(0.2, 0.6)){ɛ sidewing} 3 :sidewing S(1r, 1r, Scope.sz rand(0.4, 1.0))facades : 0.5 S(1r, Scope.sy rand(0.2, 0.9), Scope.sz rand(0.4, 1.0)) : 0.3 ɛ : :facades Comp( sidefaces ){facade}. For different and more complex examples please refer to the original paper [8]. C. Occlusion Complicated mass models with overlapping shapes can cause problems as the visibility of faces is not trivial anymore. E.g., one does not want to place a window on a part of wall if that part intersects or overlaps with another volumetric shape of the building. As mentioned, the grammar supports context sensitive rules through conditions. The feature used to resolve the visibility problem are so-called occlusion queries that check if a shape is occluded by other shapes. A shape can be partly, fully, or not occluded at all. A rule could, e.g., state that window is only placed on part of a wall if does not intersect any other part of the building. Queries can be run against all available shapes, against certain shapes only, or most commonly against everything except the current shape s predecessors. An occlusion query is usually done against the current state of the building model. Note that during the creation process parts of the building might not exist yet. This is not a problem as the mass model gets developed first, and the occlusion queries are mainly used later on during the design of façades, therefore it should not occur that a shape gets occluded after having executed an occlusion query for that shape in an earlier rule. There is also a different type of queries that check the visibility of sight lines, e.g., testing if the street is visible from a certain shape (allowing to place a door only on the wall facing towards the street). Spatial queries can be executed efficiently due to the shapes being stored in an octree. D. Snapping Another feature are snapping lines and planes. They are inserted into the scenes like any other shape. When using repeat or subdivision splits, the splits can be forced to align with snapping lines or planes. This proves useful when tiling shapes over several façades of different heights. Due to relative size values the floors might get scaled slightly differently on different walls. Inserting a snap plane for every floor leads to floors with the exact same height. E. Conclusion When designing not just one building but entire cities (or parts of them as in Figure 4 on the right), data can directly be imported from the GIS database. The footprints of the lots are used as the starting points: they are extruded vertically to form the bounding scope for a building. If zoning information is know one can adapt the maximal height or type of the buildings in an area. Combining procedural modelling of city street networks [12] with CGA Shape allows quick generation of random cities. The paper s prime example is a procedural

4 EDIC RESEARCH PROPOSAL 4 model of ancient Pompeii generated by using old ground plans and by abstracting archaeological information into a set of rules that describe the style of old Roman architecture. CGA shape is very powerful, however, a major drawback is that programming knowledge is required to use it. Reading and understanding complex rule sets can be tricky. One way to simplify the unintuitive moddeling process is presented in the third paper [10]. IV. AN ALGEBRAIC MODEL FOR PARAMETERIZED SHAPE EDITING [9] The creation and editing of highly detailed shapes is still a cumbersome and time-consuming process. A way to overcome this is to adapt existing shapes for new purposes instead of starting from scratch. However, most available methods for structure-aware editing do not alter a model s topology. The second paper by Bokeloh et al. [9] introduces a novel approach for structure-aware editing. A shape and its structure is changed while global characteristics (patterns of reoccurring elements such as windows) are maintained. E.g., new windows are inserted or removed when a building is scaled horizontally, and new floors are added or deleted when scaling vertically (see Figure 5). The presented paper is a follow up to the sliding dockers [13]. Sliding dockers allow structure-aware editing of shapes that contain one-dimensional translational patterns that can be extended or shortened. The main drawback is the used elastic deformation model. Regularity constraints are weighted against the user s editing constraints in the optimisation. This can lead to unsatisfying artefacts. The authors new algebraic approach clearly separates the two types of constraints and allows the user to move only in the space defined by the algebraic model. Another promising approach would be inverse procedural modelling [14], but finding a grammar for an input shape is an ambiguous and combinatorial problem. A. Pattern Detection The different types of patterns are: rigid patch, discrete line patch, discrete area patch, continuous line patch, continuous area patch and mixed-case patch (see Figure 6). The most fundamental pattern is the discrete one-parameter line patch (Figure 6b) that is parameterised by an origin o, the generating transformation t, and the length of the pattern or the number of repetitions l. The line patch is generalised to the area patch (Figure 6c), a discrete two-parameter pattern, that describes a subset of a regular grid. It is fully described by the boundary of the polygon that encloses the area patch, and each polygon edge is a discrete line patch. When discrete patterns are edited, the number of the repetitions is updated, but the generating element does not change. Fig. 5. Example variations of an edited building model: three differnt parts of the building are scale. Note that windows are added or removed to the façades while the windows themselves do not change. The key contribution is an algebraic model of shape structure that characterizes shapes in terms of linked translational patterns. Most man-made shapes exhibit regular patterns or pieces of them. There are discrete patterns such as windows, ornamental elements, etc., but also continuous patterns like planar surfaces and straight edges. One limitation is that the method can only handle discrete tranlational patterns of one and two dimensions. A shape can be described completely by a collection of such patterns that are linked with each other. Each pattern is represented by a few numerical parameters and some associated geometry. Given those variables, one can form linear constraints that link together overlapping and adjacent patterns. All linear constraints describe a convex space that contains all shape variations that conform with the characterisation of the initial shape. The paper proposes a two-step approach for robust editing. First, an offline analysis step decomposes the input and finds all the prevalent patterns. In the second step, the user interactively edits the input shape and explores the convex shape space. Manipulation is done by placing and dragging handles. Note that the degrees of freedom for editing the model are limited to the generating translational directions of the detected patterns. Fig. 6. The six different types of regular patterns and their parametrisation. For both discrete patterns, line and area patch, there exist continuous corresponding counterparts (Figure 6d,e). These describe planar surfaces or straight edges and manipulating them is trivial. A mixture between a continuous and discrete pattern is also possible (Figure 6f). Finally, there are rigid patches (Figure 6a) that are too small to be considered continuous. They will not change during manipulation. Figure 7 shows an example input model, the found patterns, and the degrees of freedom for editing. For detecting the patterns a RANSAC technique is used. The mesh is first decomposed into features (connected components, polygons, polygon edges) that are clustered according to their geometric shape in a second step. Pattern detection is done within the clusters: two random features are taken and their transformation calculated. Next, one checks how many other features also support the pattern spanned by the two samples.

5 EDIC RESEARCH PROPOSAL 5 spanned by the kernel of A. All valid shapes are parameterised by this subspace and are written as the sum of the original configuration x 0 and a linear combination of the basis vectors of A s null space: x(λ) = x 0 + K A λ, (2) Fig. 7. An input model (a) is analysed to find regular patterns (b) that define the degrees of freedom for editing. The search space can be reduced to a line for one-parameter and to an area for two-parameter patterns. In the latter case a generator voting technique is used to detect the grid [4]. This is done a number of times and only the pattern with the most support is kept. The process is repeated until no more patterns are found (while removing the features of already found patterns from the pool). B. Linking Patterns with Constraints Two patterns are linked if they intersect or if they are adjacent. When two patterns are coupled, a linear equation is used to keep the relative position between two individual elements of the patterns constant. For a line patch i the origin is given by o i and the end by o i + t i l i. New variables need to be introduced for in-between elements, e.g., χ i to address o i + t i χ i. The restriction 0 χ i l i must hold. χ i can change during manipulation. The distance vector between two coupled elements of two shapes a and b is noted as i,j a,b, where i and j stand for the indices of the elements. An example of two coupled line patches is shown in Figure 8. The two adjacent origins are coupled together, the end of the blue line patch must by connected to any of the yellow pattern s elements. Extra variables must also be introduced to parameterise the interior of area patches. Along area boundaries the edge line patches are used to establish links. Fig. 8. Two coupled line patches. Both origins are coupled. The end of the blue patch is coupled with the eighth element of the blue patch, for this the new variable χ a is introduced. Finally, the system of constraints is written as a large, redundant linear system: Ax = b, (1) where x not only contains the origins and lengths of the patterns, but also the extra variables. b contains the offsets. An overview over the whole analysis pipeline is given in Figure 9. C. Shape Editing The linear system with the constraints is usually underdetermined. The solutions are given by a linear subspace that is where K A is a basis for Ker(A) (see also Figure 9e). Null space analysis for finding K A can be done numerically stable by using singular value decomposition (SVD). All restrictions on the extra variables are inequalities. They are summarized, together with inequalities that require the pattern lengths l i to be positive, by Mx m. Expressed in the parameter domain of λ they become: [MK A ] λ m Mx 0. (3) }{{}}{{} M m For the interactive manipulation the user places handles on a pattern element and drags it new position y. A quadratic energy is formulated to measure the distance of the user constraint to the pattern element. Energy minimisation is used to find the best possible and valid pattern position e closest : E point (x) = (e closest y) 2. (4) A regularisation term trying to maintain original length values of the patterns is added: E reg (x) = w reg (l i li 0 ) 2. (5) Together the quadratic program becomes: i E(x) = E point (x) + E reg (x) = x T Qx + x T q. (6) The energy is projected into the domain of parameter λ so that the final solution lies within the subspace of valid shapes: E (λ) = λ T ( K T AQK A ) λ + λ T K T Aq. (7) The final convex problem is written as: Minimize E (λ) subject to M x m. (8) In the result x, the variables for pattern repetitions are rounded to integers. The generating transformation are undergo an affine scaling so that the patterns keep their size. D. Conclusion The approach is simple and very elegant. However, there are limitations: it is restricted to translational patterns only, no rotations, hierarchical structures are not supported, and the generators of repeating elements cannot be changed by the user, i.e., the distances and directions between the elements stay constant (the patterns can also not rotate). Global relationhips between patterns, such as symmetries, are not taken into account either. Also the system provides only one solution, the user cannot adjust the stiffness of constraints or create new constraints between structures (only fixing specific points to their absolute position is possible). These drawbacks clearly limits the exploration space and calls for future work.

6 EDIC RESEARCH PROPOSAL 6 Fig. 9. Analysis pipeline: regular patterns are found (a) that are represented as line patches by (o, l, t) (b). Links of adjacent patterns (c) are described by linear constraints (d). All valid shapes are spanned by the null space of the linear system A (e). V. INTERACTIVE MODELING BY PROCEDURAL HIGH-LEVEL PRIMITIVES [10] For non-programmers it is hard to use procedural grammars to produce geometric models. It is difficult to map procedural rules to interactive controllers that let amateurs edit the model in an intuitive way. The paper addresses exactly that problem by defining 3D manipulators (i.e., for adjusting lengths, angles, etc.) that map parameters of procedural rules to interactive handles. There is a professional mode (P-mode) that is text-based (with some interactive elements) and allows to create so called high-level primitives, i.e., encapsulated objects with defined parameters. In high-level mode (HL-mode) the user interactively changes and combines HL-primitives without being exposed to the grammar. This is more intuitive but limited, not all possible editing operations are available in this mode. The changes are applied through the manipulators by using the mouse. Manipulators need to be specified within the grammar s production rules while defining the HL-primitives. Camera views can be defined to limit the set of visible handles from a certain viewpoint, this helps as there are usually a large number of parameter manipulators: handles for adjusting details are displayed in a close-up view while handles for coarse features are available from further away. The underlying textual P-mode uses a procedural shape grammar. Specifically, the authors use their own G 2 grammar [15]. The notation is similar to CGA Shape [8] and it would go beyond the scope of this summary to elaborate all the details of G 2. As CGA Shape, the grammar also builds a hierarchy of instanced objects. There are three new feature that are important for understanding the presented modelling methodology: 1) Modules allow to encapsulate several rules that are needed to describe a certain procedural object into one entity. Modules keep the grammar clear and unambiguous. A module can be used without understanding its sub-rules. 2) Abstract structure templates are special modules that take non-terminals as parameters. E.g., a façade could be an abstract structure template that takes a non-terminal symbol as parameter that describes the window style (as in Figure 11). The concept facilitates code reuse. 3) Locators [16] can be used to assign tags to subtrees in the instance hierarchy. A tag is directly defined in a production rule. All object in the subtree that the rule creates receive the same tag. A tag consists not only of its name but also of the instance index. E.g., when a repeat split is used to create several tagged floors, they are all individually identifiable by their index, allowing, e.g., to place a door on the bottom floor. A. Professional Mode The P-mode allows to use all features of the grammar through a text editor. Manipulators are directly defined and added to production rules in P-mode. Instead of passing static parameters to production rules, one passes a reference to the previously defined manipulator rule. In addition to length and angle manipulators, there are also sliders to adjust abstract parameters such as colours or boolean variables. Those manipulators will be available later in the HL-mode. The P-mode also has some interactive components. For certain commands, such as the repeat split or the scope size command, there exist built-in manipulators that do not need to be defined manually, i.e. for adjusting the number of repetitions or the size of a scope respectively. When the user select any object, the last rule used for the generation of that object is highlighted in the textual grammar editor. With the mouse wheel one can navigate through the rule hierarchy that was used to build the geometry. Note that not all rules can be selected and edited this way, e.g., if a specific rule was never applied, there will not be any selectable instances. If the mouse cursor in the text editor is placed on a rule that has a manipulators associated to it (built-in or manually defined), those manipulators become visible in the 3D view. An example is shown in Figure 10. Fig. 10. In this window example, a rule M is used to define manipulators (e.g., the length manipulator). Whenever the mouse is placed over a reference to M, all its manipulators become active. In addition to the length manipulator, there are manipulators for changing the left window s opening angle and the window colour. Manipulators for one specific parameter can be displayed several times if the corresponding rule was applied several times (e.g., the window sizes in Figure 11.

7 EDIC RESEARCH PROPOSAL 7 Fig. 11. Example of a HL-mode: a house façade is created as the composition of three HL-primitives (façade, embed, and the window). From the left to the right, red shapes are non-terminals that are replaced. Also the manipulators for the currently active primitive are shown. The already mentioned camera views are directly specified as special rules in the grammar. Camera views are helpful in solving the problem of having too many or even overlapping manipulators in the scene. But they can be problematic themselves as it is not always obvious what the best viewing frame is for changing a certain parameter, especially when the same parameter is used in different location. E.g., with the parameter for adjusting the window size on a façade. Sould only one window or the whole façade be displayed? It is possible to built larger compound primitives by combining several modules and mapping their parameters. Let us assume there is a module X that is used by another module Y. When defining Y, the author needs to specify the manipulators of X that are still available in Y and those that receive static values by Y. Parameters of X can also be mapped to mathematical expression that depend on Y s parameters. An extreme example for this is the chair with the stick figure in Figure 12. The resulting compound primitive only has the manipulators for the stick figure (for adjusting the figure s limb lengths and orientations). The chair s parameters are mapped to the figure parameters the through mathematical expressions that fit the chair ergonomically to the stick figure. represented by a prototype shape (usually just a box or planar surface, and usually non-terminals associated with the same rule are drawn in the same colour to emphasize their shared identity). Further lookups in the database are used to find modules that replace the prototypes. The mouse is used to combine modules, and the grammar gets written automatically in the background. An example that shows the construction of a house façade in the HL-mode is given in Figure 11. For more examples please check out the original paper [10]. Prototype non-terminal can define so-called filter tags that limit the available modules in the database so that only meaningful replacements can be made. Similar to the P-Mode, the user can select HL-primitives by clicking on them or iterate through the hierarchy of HLprimitives by using the mouse wheel. For the active primitive, a camera view must be chosen and the manipulators for all associated parameters are displayed. Local modifications modifications are also possible for abstract structure templates. That means, if a non-terminal parameter is used several times it can change locally. This functionality is enabled through tags (that are defined in P- mode during the generation of the HL-primitive). In a 2D interface the user can select available tags for an object, and change parameters only for the instances marked with those tags. E.g., in the façade of Figure 11, the top and bottom floors could each have a tag assigned to them, what would allow to change windows style of those two floors. Fig. 12. A compound primitive that uses a stick figure as a complex manipulator object. The chair is ergonomically fitted to the stick figure.. B. High-Level Mode As already mentioned, the HL-mode provides an intuitive interface for non-programmers that allows them to choose, manipulate and combine models from a given catalogue of HLprimitives. One starts with one HL-primitive imported from a database. Keyword search can be used to find such primitives as façades, windows, plants, furniture, etc. A screenshot is also assigned to every database entry to give a visual impression. If a loaded HL-primitive contains non-terminals as parameters (i.e., it is an abstract structure template), they are C. Conclusion The paper presents a simple and intuitive procedural modelling interface for non-programmers. A major drawback is that a lot of preliminary work is required to establish a database with enough modules so that users of the HL-mode have sufficient diversity for compositing. Also, the P-mode users must take extra caution when building HL-primitives: they need to specify camera views, the manipulators, and keep the modules as flexible as possible. VI. RESEARCH PROPOSAL We have seen that procedural modelling allows for fast generation of 3D content, but for non-programmers it is difficult to design objects from scratch. On the other hand, when starting from an existing shape, the main problem is to decompose

8 EDIC RESEARCH PROPOSAL 8 it into meaningful parts and detect structures such as regular patterns. In the second presented paper [9], Bokeloh et al. present an interesting approach for that problem. However, it has several limitation that we mentioned earlier. Ideally one could recover the complete generating process for a given shape, and store it as procedural production rules. Inverse procedural modelling, i.e., finding a grammar for a given input, is a hard task, and there exist many different grammars that generate the same object. Previous work in this direction exists, but is limited to very simple context free grammars [14]. One would also like to find a representation that is as compact as possible and that is aware of the semantics of the different parts of a model. One solution, for building models, could be to use the modelling strategy presented in the first paper, but applied in the opposite direction: a first step would identify a mass model by detecting primitives such as planes, boxes, or cylinders. In a second step one would switch to two dimensional scopes and analyse the building s façades and roofs. There are already methods for finding procedural rules of a giving façade [17]. Also, the analysis of a shape does not need to be fully automatic, a semi-supervised approach is sufficient in our opinion. E.g., the user could manually select one pattern element such as a window, and the rest of the pattern would be detected automatically. The third paper presented an intuitive modelling tool for non-programmers. Its main drawback is the preliminary work required to establish a database with enough HL-primitives. The process would be simplified if the same concepts could be used for arbitrary input objects. If structure detection or inverse procedural modelling could be used to decompose any input shape into meaningful parts, one could try to apply interactive manipulators to the found parts. A totally different approach for designing a user interface for procedural modelling could use visual graphs: instead of writing the grammar as text, it could be displayed as a graph of connected nodes, with the nodes representing production rules. An incoming connection would be the predecessor shape and the outgoing connections would reference the resulting shapes. Other node types could be used for implementing conditions and commands such as splits. The graph could be edited with the mouse, new elements could be inserted or connected via drag and drop. Our experiments so far only considered the pattern and symmetry detection part of the project. We developed and implemented a technique that is similar to the second paper s method (unfortunately the paper was released shortly after we started to see promising first results with our own method). In the future we want to investigate methods that combine both ends, i.e., procedural modelling and structure-aware editing, and provide an intuitive interface to the artist. for procedural models a priori (it is implicitly given in the grammar s production rules), no such information is known when starting with an arbitrary existing model. For future research, we would like to establish a middle ground and try to fill the gap between procedural modelling and shape analysis. The idea is to use pattern analysis to gain an idea of a model s structure in a first step. In a second step, we would like to use procedural techniques to modify the input shape in a structureaware manner. REFERENCES [1] R. Gal, O. Sorkine, N. J. Mitra, and D. Cohen-Or, iwires: An analyze-and-edit approach to shape manipulation, ACM Transactions on Graphics (SIGGRAPH), vol. 28, no. 3, pp. 33:1 33:10, [2] Y. Zheng, H. Fu, D. Cohen-Or, O. K.-C. Au, and C.-L. Tai, Componentwise controllers for structure-preserving shape manipulation, in Computer Graphics Forum (Proceedings of Eurographics), [3] N. J. Mitra, L. Guibas, and M. Pauly, Partial and approximate symmetry detection for 3D geometry, ACM Transactions on Graphics (SIGGRAPH), vol. 25, no. 3, pp , [4] M. Pauly, N. J. Mitra, J. Wallner, H. Pottmann, and L. Guibas, Discovering structural regularity in 3D geometry, ACM Transactions on Graphics (SIGGRAPH), vol. 27, no. 3, [5] M. Bokeloh, A. Berner, M. Wand, H.-P. Seidel, and A. Schilling, Symmetry detection using line features, in Computer Graphics Forum (Proceedings of Eurographics), [6] P. Prusinkiewicz and A. Lindenmayer, The Algorithmic Beauty of Plants. Springer Verlag, [7] G. N. Stiny, Pictorial and formal aspects of shape and shape grammars and aesthetic systems, Ph.D. dissertation, University of California, Los Angeles, [8] P. Müller, P. Wonka, S. Haegler, A. Ulmer, and L. V. Gool, Procedural modeling of buildings, ACM Transactions on Graphics (SIGGRAPH), vol. 25, no. 3, pp , [9] M. Bokeloh, M. Wand, H.-P. Seidel, and V. Koltun, An algebraic model for parameterized shape editing, ACM Transactions on Graphics (SIGGRAPH), [10] L. Krecklau and L. Kobbelt, Interactive modeling by procedural highlevel primitives, Computers & Graphics, vol. 36, no. 5, pp , [11] P. Wonka, M. Wimmer, F. Sillion, and W. Ribarsky, Instant architecture, ACM Transactions on Graphics (SIGGRAPH), vol. 22, no. 3, pp , [12] Y. I. H. Parish and P. Müller, Procedural modeling of cities, in Proceedings of the 28th annual conference on Computer graphics and interactive techniques, ser. SIGGRAPH 01, 2001, pp [13] M. Bokeloh, M. Wand, V. Koltun, and H.-P. Seidel, Pattern-aware shape deformation using sliding dockers, ACM Transactions on Graphics (SIGGRAPH), vol. 30, no. 6, pp. 123:1 123:10, [14] M. Bokeloh, M. Wand, and H.-P. Seidel, A connection between partial symmetry and inverse procedural modeling, ACM Transactions on Graphics (SIGGRAPH), vol. 29, no. 4, pp. 104:1 104:10, [15] L. Krecklau, D. Pavic, and L. Kobbelt, Generalized use of nonterminal symbols for procedural modeling, Computer Graphics Forum (Proceedings of Eurographics), vol. 29, no. 8, pp , [16] M. Lipp, P. Wonka, and M. Wimmer, Interactive visual editing of grammars for procedural architecture, ACM Transactions on Graphics (SIGGRAPH), vol. 27, no. 3, pp. 102:1 102:10, [17] P. Müller, G. Zeng, P. Wonka, and L. V. Gool, Image-based procedural modeling of facades, ACM Transactions on Graphics (SIGGRAPH), vol. 26, no. 3, VII. CONCLUSION In this research proposal, we study different concepts for the fast creation and adaption of 3D content through procedural modelling and through structure-aware editing of existing shapes, and also concepts for the interaction of the user with the content. While all semantic information is available