A sketch on Sketch-Based Interfaces and Modeling.

Leandro Moraes V. CruzVision and Graphics Laboratory

Instituto de Matematica Pura e Aplicada - IMPARio de Janeiro, Brasil

www.impa.br/˜lcruz

Luiz VelhoVision and Graphics Laboratory

Instituto de Matematica Pura e Aplicada - IMPARio de Janeiro, Brasil

lvelho@impa.br

Abstract—Geometric Modeling is a widely studied area incomputer graphics and methods from constructing 3D modelswith intuitive interfaces are a topic that has been attractingthe interest of many researches. In contrast to the complicatedinterfaces of modeling software, created using the WIMPparadigm (Window, Icon, Menu, Pointer), several studies haveshown applications with interfaces based on gestures, whichare simpler and more natural. In this scenario, the area ofSketch-Based Interfaces and Modeling (SBIM) emerged.

Sketch is a very efficient tool to convey the essence of anobject with few strokes, because humans have the ability ofinferring 3D models from 2D drawings. However, associatinga sketch to a 3D model is not a computationally trivial task.In this paper we present a conceptualization of the area,highlighting opportunities, challenges and trends in SBIM.

Keywords-Sketch-based Interfaces and Modeling; 3D Mod-eling; Modeling Applications Design;

I. INTRODUCTION

The work on geometric modeling of graphic objects,in particular models of three-dimensional objects, gainedprominence in the 1960s and 1970s, in auto plants inEurope. For a long time, the modeling softwares weremainly used in engineering contexts to generate accuratemodels that specify the geometry of an object that would bemanufactured. Some examples of modeling software, in thisline, are AutoCAD and SolidWorks.

Over time, besides the engineers specifying objects, 3Dmodeling softwares started to be used by other professionalssuch as architects, designers and artists in general, whomodel objects for animations, games, architectural sketches,clothing, and other representations of objects and scenarios.In such cases, the aim of modeling is no longer accuratespecifications. The goal is to communicate conveying theessence of the form of objects, without necessarily highgeometric accuracy. This is the purpose of softwares likeMaya and Blender.

The softwares mentioned so far were developed usingthe WIMP paradigm (Window, Icon, Menu, Pointer). Theseapplications are powerful and accurate, but they have com-plicated interfaces which increase the learning time andmake them difficult to use. The new purpose for modeling,and the change of profile of its users, highlighted the needto change the building paradigm of modeling applications.

In this scenario emerged the Sketch-Based Interfaces andModeling (SBIM).

Sketches are excellent communication forms, allowing anidea to be transmited with only few strokes. The reason ishuman ability to understand 2D drawing by abstraction of a3D model. We are able to recognize patterns and associatesketches to 3D elements. So, researchers became interestedin developing methods for 3D objects modeling from user-generated drawings. Besides using sketches in modeling, itwas also noticed that they are a good tool for interaction.There are two central problems in developing sketch-basedtools: constructing a 3D model from 2D drawings (sketch-based modeling) and developing an intuitive interface thatallows such a construction (sketch-based interface).

Sketch-based applications are more intuitive and naturalto the user. The first work in this line was the SketchPad [1],which was followed by SKETCH [2], Teddy [3], Chateau[4], ShapeShop [5] and FiberMesh [6].

As a research line, SBIM is still recent and not allconcepts and results are neither considered consensus amongresearchers, nor generic enough to be used in any modelingapplication. The modeling methods used in SBIM systemshave strengths and weaknesses. For now, any choice isinextricably linked to the application purpose. The con-cepts presented in this paper aim at creating a systematicformulation for the area, while the methods and systemsdiscussion seek to provide a general overview, highlightingthe possibilities of modeling objects using sketches, throughan analysis of the state of the art. Besides this, other studiesshows themes in the area [7], [8], [9].

A. Overview

In this text we will make an analysis of geometricmodeling of graphic objects using sketches. According toVelho and Gomes [10] geometric modeling is the area thatdeals with the problem of describing structure and geometricdata in computer. A graphic object is a pair (S, f), whereS ⊂ Rm is called geometric support and f : S −→ Rn iscalled attribute function. This function defines the attributes(texture, material, etc) of each element on the geometricsupport.

Figure 1. Sketching process.

In this text we will deal with the modeling of graphicalobjects from drawings made by the user. That is, we have2D objects drawn by the user and the 3D objects built bythe system.

We will refer to the process of model specification throughdrawings as sketching. The drawings made by the userduring sketching take different characterizations (Figure 1).These characterizations lead to the proposed architecture thatwill be presented in this work. This is a generic architecturethat presents the main processes essential for SBIM systems.

The sketching process begins with the user drawing onthe device. This drawing is sampled. Each sample will becalled cursor. The cursors set that represent curves in thedrawing we will call trace. The cursor and trace represen-tation processes will be called Acquisition. The traces areconveniently grouped to construct a model curve to whichthe system should infer some meaning. This model willbe called sketch. The sketch composition process will becalled Curve Modeling. The sketch can be used for 3Dgraphic object modeling, as well as application control.In the latter case, the application chooses the task it willexecute, according to the sketch interpretation. Finally, wewill call this sketches category of gesture. The process ofcreating and editing 3D graphic object will be called ObjectModeling.

After the sketch composition, it is necessary to interpret itto in order to decide which operation the user desired. Thisprocess results in a signal that determines which operation isperformed. This operation generates a change on applicationstatus, on model or on scene view. After this was processed,we must update the scene view on the output device.

In Section II we will present an analysis of the Represen-tation of Sketch, including discussions about the acquisitionand representation of data, in addition to curve modeling.In Section III we will present operations done with sketches(control, creation and editing). Finally, in Section IV wewill present an analysis of interaction in SBIM applicationsaddressing acquisition devices and object interfaces.

II. SKETCH REPRESENTATION

The sketch-based modeling process begins by building amodel with curves. This construction consists in capturingthe traces and putting them together properly, making thesketch. The capture of the trace is made from successivemeasurements of the cursor attributes at different moments,

at the specific frequency of the input device. Data fromthe drawing sampling often has irregular sampling andnoise. Another undesirable fact is the large number ofsampling points. Many of these points are redundant andtheir presence increases the cost of processing and storage.Thus during the process of data acquisition two operationsare required: filtering and fitting. Filtering consists of areorganization of sampled points through local analysis.During filtering, you can space the points evenly, smooththem, remove close points or interpolate distant points. Onthe other hand, the fitting process is a global process thatconsists, from an analysis of the data set, in obtaining controlpoints which allow the reconstruction of the original curve(or a similar one).

A. Acquisition

Input devices vary among themselves on the way theuser can interact with the system. Some devices captureinformation, beyond the cursor position in a given time,which may be useful to the modeling process. We cancite for example, multiple strokes, pen pressure and tilt,type and orientation of the fiducial, etc. Thus, the attributesrepresented in the cursor are directly related to the devicethat will be used during the acquisition.

In addition to the captured information, there are otheracquisition aspects to be considered. The first is the sam-pling frequency. The user’s drawing speed is not constant.Therefore, a drawn curve is sampled more in certain regionsthan others. Another important feature is the precisionof the cursor position. In some devices, such as tangibleinterfaces, for example, the interaction is of low precision.In such cases, the system may have to interprets the desiredcursor position in the specific context of the application. Aprecision problem example occurs when the user tries toselect a point on a curve, but does not positions the cursorexactly on the curve, but close enough. So, the applicationshould interpret that position as a point on the curve.

We will use in this paper the Four Universe Paradigm [10]to outline the sketching process (Figure 2). The user drawingmade on the device (Physical Universe) is captured from suc-cessive measurements of the cursor’s attributes. Each cursorcan be thought of as a point x = (x1, ..., xn) ∈ Λ, whereeach coordinate refers to an attribute of this point and Λ isthe Cartesian Product of n Attributes Spaces. Thus, the tracecan be seen as a continuous curve c : I −→ Λ (Mathematical

Universe). To represent this curve computationally, we needa discrete structure able to reconstruct the curve drawn,exactly or up to a tolerated error. This representation canbe a list T = {p1, ..., pn}, where pi = (x1, ..., xn) (Rep-resentation Universe). To handle this trace computationallyit is necessary to define a data structure with the capturedinformation (Implementation Universe).

The most common representation of data from a cursorcontains location information (the coordinates of the win-dow or device) at a given time. However, some devicescapture additional cursor information. Besides the attributescaptured, you can also calculate others, such as identifier,type, speed, acceleration, etc.

We present a vectorial approach to represent a trace.However, we may want to store a trace in an image. Thisapproach can be used in SBIM systems that allow theuser to make a decal or edit an image. This is a staticrepresentation that can leverage existing resources in imageprocessing. However, there are several disadvantages formodeling. First, it does not store any temporal information.Second, it is complicated to deform the geometry of modeldrawn interactively (to change the curve’s shape is necessaryto delete what you want to change and remake).

There are still other representations that are specific to theprocedures used in curve modeling. We can cite the modelsrepresented by control points (perhaps with an additionalweighting parameter). The captured point set of a trace maynot be appropriate a priori, because it might contain noise orredundancy. So, there are methods for fitting a set of controlpoints and reconstructing the curve drawn (exactly or up toa tolerated error) by a global analysis of captured points.Moreover, problems such as noise and redundancy can becircumvented by local approaches to filtering.

Filtering can be performed to remove outliers, noise,smoothing the data and spatial redistribution. The filteringprocess can be performed while the user is drawing (on-line),or after the user has finished making the drawing (off-line).

One way to remove outlier and noise is to smooth thecurve. We can divide the problem of noise in two categories:Information Noise and Device Noise. The Information Noiseoccurs when the sampling are performed on an objectalready with noise. In the case of sketching, this noise canoccur when the user does not have much ability to drawshapes or to handle the device, generating an inaccurate

Figure 2. Four Universe Paradigm for Trace Representation.

Figure 3. Filtering by B-Spline Wavelet Filter.

Figure 4. Drawing segmentation and merging

stroke, causing the loss of the desired form. Device Noisecomes from an inaccurate capture of the user drawing. Itscauses vary from device to device. The removal of noise canbe accomplished by applying a Gaussian filter, Laplacian, orthrough some other convolution filter applied to the set. Theneed for noise processing highlights that the system purposeis to model the object desired by the user, and not necessarilywhat was drawn on the input device.

A simple way to reduce noise is downsample the data.For this purpose, the most basic algorithm is to get pointsfrom k in k. On the one hand, this technique is very simpleto implement, on the other hand, if the sampling distributionis very irregular the result can be unsatisfactory. One wayto redistribute the points spatially is to define a threshold(ε) and discard the other captured points that are within adistance of less than ε, from the previous stored ones. Aproblem with this technique is that the disposal does notguarantee that the distance between two points is exactly ε.After finishing the drawing, we can do a resampling basedon ”curvature” of the curve at each point (the quotes aredue to the fact that we are working with discrete data). Youcan also determine the position of each point by the averageposition of its neighbors. Besides leaving the samples moreuniform, this latter approach reduces noise. However, thenew position of the points can deform the curve drawn bythe user, generating an undesired outcome. An alternative isto use a filter of B-spline wavelets [11] (Figure 3).

Typically, drawing regions, with greater curvature, tendsto accumulate points because these are places where users doit more slowly, allowing capture of a more dense sampling.Moreover, in regions of lower curvature, the user tends todraw faster. This is a desirable property in many applica-tions. If the sampling is denser than necessary, you can applya downsample maintaining the criterion of curvature.

In addition to filtering, sometimes it is interesting todetermine some characteristics of the sketch, such as corners(high curvature), curve regions (low curvature) and straightregions [12]. With these features, it is possible to segment

Figure 5. Geometric characteristics analyzed in the Beautification process.

and to merge traces conveniently [13] (Figure 4).The methods listed are independent of the curve repre-

sentation. Moreover, there are methods that approximate thecurve drawn by a Bezier or B-Spline curve, determiningthe position of the control points so that the generatedcurve is a satisfactory approximation of the drawing. Thisrepresentation, besides requiring fewer control points thanthose captured, reduces noise, since they are smooth curves.

B. Curve Modeling

After filtering the trace, the result contains redundantpoints. Therefore, it is common to fit them with an equivalentrepresentation, which can be generated by a smaller set. Thisnew representation has advantages such as simplifying theinput data and simplify future comparisons and interpreta-tions. Moreover, many of these representations are smooth(or piecewise smooth). This process is known as fitting.

There are curve fitting approaches that approximate thedata by curves with sufficiently low average error. Oneapproach consists in to approximate the points locally byLeast Square Polynomial. Other approaches use implicitcurves and variational subdivision [5]. However, the mostcommon approach is to use parametric curves as B-Splinesand Bezier curves [14].

Most modeling systems use spline to fit curves. Splinesare piecewise polynomial curves or surfaces generated byinterpolation or approximation of a control point set. Twoissues stand out when working with splines: deformation andfitting.

Casteljau and Bezier developed a method for buildinggraphical objects such as cars, engines, boats, airplanes,etc. This method was used in CAD systems at Renault in1969, and Citroen in 1962. In these systems, a curve wasspecified by control points, and the deformation was doneby repositioning them.

The advent of sketch-based modeling has brought abouta systematic change in the creation and editing processesof curves and surfaces. Instead of manipulating the controlpoints, a more intuitive method is sketching the object thatyou want to model, and directly manipulate a point on thecurve [15] or surface [16]. This is a solution to the problemof manipulation of graphical objects.

One simple solution to fit a drawing is to consider thesample points as the spline control points. This is simple, butif the sampling is very refined, the reconstruction process isexpensive, because the application needs to calculate many

points. On the other hand, if the sampling is too sparse, theaverage error is high. Some works [17], [18] show solutionsto get a sparse set of curve control points without increasingthe average error.

To use spline on fit curves can be a good idea becausethis curve’s class has good structures and geometric features.Besides representation, another advantage regards editing.You can directly manipulate a point on a spline (curve [15]and surface [16]). However, in certain applications, the classof curves used may have more structure than a spline. Theprocess of beautification works with an example of such acurve’s class.

The beautification term was first used in the SBIM contextby Takeo Igarashi et al in 1997 [19]. In this work, theypresented a modeling system of two-dimensional graphicalobjects called PEGASUS (Perceptually Enhanced GeometricAssistance Satisfies US). In this system, freehand drawingsare interpreted as straight line segments. This interpretationwas based on geometric restrictions such as: connectivity,parallelism, perpendicularity, congruence, symmetry and in-terval equality (Figure 5). The user drawing is shown by atrace of greater thickness.

When the user draws a curve the system must decide howto insert it into the existent model. However, an automaticdecision may not be consistent with the desire of the user.This is because there are multiple insertion possibilities. Bythis ambiguity, the system can make mistakes on choice ofwhich segment should be added to the model. An alternativeis to allow the user to delete the section chosen by theapplication, and try to recreate it. But the error may recur.Another more reliable alternative, used in PEGASUS, isto display all the calculated possibilities and to leave thechoice to the user. However, depending on the complexityof the model, many candidates may appear. In this casethe visualization of these segments would be compromised,

Figure 6. Semantic in curve modeling.

because there would be many overlaps, impairing the userselection of the desired segment. One possibility is tolimit the amount of the solution candidates. A factor thatdecreases the amount of candidates is to reduce the amountof geometric features analyzed.

The PEGASUS application provides a simple user inter-face and also allows creation of precise models. On theother hand, it is limited by the straight models. Often themodels are composed of curves (non-straight). S. Murugap-pan presented a similar work [20] (Figure 6). In this work,the author presents a method that recognizes curved andlinear parts with circular arcs. These curves are analyzedby inferring a semantic in the modeling process of curves.Although the set of primitives of this work is larger thanthat reported in PEGASUS it is still limited. Thus, it cantake other representations.

In some modeling applications, the geometry of the mod-eled object is more generic (and therefore less structured)than that obtained with beautification. In these cases, theuser desires more control over the object shape. In suchcases, we can use parametric curves (spline or polygonal)as primitive. As the user is liable to make mistakes duringconstruction, it is important to offer him means to correctwhat is not in accordance with the desired. One way is todirectly manipulate the geometry of the modeled object.Another way is known as oversketching. There are twoapproaches to oversketching. In the first, the user is able tocreate a sketch and remake parts that are incorrect (Figure7a). In the second, he creates the sketch through severalsmall traces superimposed (Figure 7b). To avoid confusion,we call the first approach corrective oversketching and thesecond oversketching in batch. These techniques can alsobe called overdrawing, re-sketching, re-drawing, overtracing,scribbling, and ”nervous hand”.

The first work on oversketching [21] presented a correc-tive oversketching method. This technique needs to interpretthe new strokes to know what the user intends (add thetrace in the model, or correct the sketch). When identifiedas corrective oversketching, we must find the point where it

Figure 7. Oversketching.

Figure 8. Oversketching in batch.

(a) (b)

Figure 9. Objects drawing in Billboards.

begins and ends to fix this. The new line will indicate howthis segment should be reparametrized. Some works showhow this technique can be used in 3D modeling [22], [23].

The oversketching in batch approach [24], [25] is more re-lated to the acquisition problem. This approach was inspiredby the fact that many designers use several small curves todraw an object. However, in most applications, the drawingmust be done by full curves representing the object contours.

Although drawing an object through small curves mightbe more intuitive for the user, this representation can beinconvenient in many SBIM applications. To model 3Dgraphics objects, full curves are more robust primitives. So,to transform oversketching in batch on a curve is a necessaryrequirement in some SBIM systems. The Figure 8 shows anexample of a model generated with oversketching in batch.

Pusch shows [24] how various traces received from thedevice can be interpreted as a B-spline curve using PrincipalComponent Analysis (PCA). To use this analysis, the inputis subdivided into smaller pieces and analyzed separately.This method ensures that the join of each piece is continuouswhen the input traces have a ”continuous flow”. This occursbecause, after being subdivided, the input is ordered; in eachsection a set of points are estimated, and these points, in theorder defined, are regarded as control points of a B-Splinecurve, therefore continuous.

The curve modeling methods shown are independent ofthe space environment dimension. Although usually thedrawing is done by the user on a plane device, it maybe necessary to interpret the sketch as a 3D curve. A firstalternative is to define plans on the scene, called billboards,and project the drawing on them [26], [27]. Note that,in Figure 9a, if we change the viewpoint, we can seethat billboard objects lack volume (actually, the objectsare just an image in the scene). In the second example,it was specified a landform from a silhouette drawn on abillboard in the scene. In the landform case, the billboard isa orthogonal plane to the ground, passing through the firstand last point of the design. Some works [23], [28], [29]show how to construct 3D curves.

The sketch construction process consists to generate atrace representation done by the user and make up it withthe sketch already drawn. Thus, it is directly related to theapplication purpose and which platform will be run. In eitherscenario, the sketch should be interpreted to identify whichprocedure will be performed on the system. This processwill be presented in the next section.

III. MODELING USING SKETCHES

After building the sketch, the system should interpret itto determine which task should perform. In WIMP systemsthis decision is straightforward. Every button or menu topicperforms a particular operation. However, in SBIM applica-tions a trace can have multiple interpretations. For example,a closed curve, around an already constructed object, canbe interpreted as part of this object. But, it can also beinterpreted as the act of selecting it, or it can be a gestureinvoking another particular system action. This ambiguitycomplicates the construction of a natural system. Therefore,similar to any software, SBIM applications will also havea set of procedures that the user must know to interactwith the system. The goal of gesture-oriented applicationdevelopment is that these specified procedures are natural tothe user, within a clear context and unambiguous.

To infer a sketch’s meaning, we should first determinewhich operations the system will perform and associateeach of them with a gesture. In this process, the gesturemay be followed by a mouse or pen button pressed, keypressed; tangible objects placed on the device; or a pre-defined system states. These choices are specific for eachapplication.

Although different developers can define different set ofstates for a SBIM application the main categories are control,creation and editing. The first relates to user interaction.It is usually responsible for interpreting the sketch anddetermining the next application state. The latter two canbe subdivided into different states. For example, a systemmay have more than one form of constructing or editing theobject. In the next section, we will explain how to controlthe system through gestures, and in subsequent sections,we will present some methods for creation and editing ofobjects from sketches. Still there are other papers [7], [8],[9] with more information on modeling techniques based onSketches.

A. Control

Every application needs a component that manages theinput and output data and its relationship with the model. Animportant control approach, in software engineering context,is the Model-View-Controller pattern [30]. In this context,the controller defines how the graphical interface reacts tothe user input. In SBIM systems, we have the same need.We need to define how the sketch interferes with modelingand visualization of the graphic object. This action can becreation or editing. We can make a weak analogy betweenthe Sketch Interpreter and the Controller. Both have the roleof to monitor the application (to decide how to handle themodel based on input data).

Controlling the application means deciding which op-eration should be performed by each gesture. To createa gesture-oriented application it is necessary to define agesture vocabulary, ie, a mapping between gestures and

Figure 10. Gestures examples.

operations. As defined, a priori, a gesture is a set withone or more traces used for control. Deciding which actionshould be performed, following a gesture is a task taht isspecifc to each application. This decision may be a complexprocess because a gesture can be ambiguous, ie, a gesturemay be related to more than one operation. Moreover, tomake this decision it is necessary to interpret the gesture,ie, to recognize the shape of the gesture.

Regarding the ambiguity problem of the gestures, analternative is defining application states or modes. Somepossible states to the SBIM application are creation, editing(deformation, add detail, painting, etc), camera control,affine transformations, etc. Thus, every gesture would have aspecific context according to application state. Another wayto solve ambiguity problem of gestures is to allow the userto specify what action should be performed. This decisionmust be made among the options of possible operations.The user can know these options beforehand or these canbe displayed after the gesture be completed.

Some works [31], [32], [33] shows methods to recognizesome examples of gestures (Figure 10). The gesture inter-pretation consists of a systematic process of defining sketchfeatures and associating them with a particular operation.This interpretation can be done through some technique ofComputational Intelligence, or through a geometric analysisof the curve defined by the gesture.

An example of application whose the main form of controlconsists of gestures is Teddy [3]. In this application buttonsare only used to perform operations such as starting adrawing, undo an operation, bend an object and save. Thereare not menus or other widgets commonly used in WIMPsystems in this application. The control is basically doneonly using gestures, mouse click and states.

As mentioned above, to develop a gesture-oriented mod-eling application is desirable, but it is not a simple task.As more functionalities the application has it may be moredifficult to build an interface based solely on gestures. Thus,during the application development process it is necessary todefine a compromise between gestures and classical interfaceobjects.

Figure 11. Magic Canvas, an examples of Template Retrieval Systems.

B. Creation

We can divide the methods the sketch-based 3D modelinginto two categories: evocative and constructive. The evoca-tive methods rely on primitives that are added to the modelwhen it is identified a associated sketch. The constructivemethods use more directly the sketch made by the user.This sketch is processed to generate the 3D model. Briefly,the difference between these methods is that the evocativefirst needs a sketch recognizing step and then builds thegraphic object, while the constructive one will direct to theconstruction phase.

We can cite two types of evocative systems: the IconicSystems and the Template Retrieval Systems. The IconicSystems associate a sketches to a geometric primitive andthe Template Retrieval Systems associate a sketch to anyobject (or class of objects) already modeled.

An example of Iconic System is SKETCH [2]. It uses asprimitives cubes, revolution surfaces, cones, spheres, prisms,cylinders and quadrics. All these primitives are generatedfrom the interpretation of a sketch. An example of TemplateRetrieval System is Magic Canvas [34] (Figure 11). Thisapplication allows to easily build a 3D scene from sketches.The user does a sketch, it is segmented and each segmentis interpreted and associated with a object in the database.Template Retrieval Systems are easily extensible by simplyenlarging their model database.

The Constructive Systems interpret the sketch to generatea 3D model. One possibility is to interpret the sketch as anobject contour. However, the problem of associating a sketchto a 3D graphic object is not well posed. So, many objectshave the same sketch as contour. A proposal to solve thiskind of ambiguity is [35] (Figure 12). Another alternativeis to reduce the application scope, adding restrictions thatallow the system to choose an option (or a few, leaving thefinal choice to the user).

Contours are an important concept in SBIM because

(a) (b)

Figure 12. Sketch reconstruction in engineering applications.

(a) (b) (c)

Figure 13. Objects contours.

it determines a representation of the graphic object withmuch structure. It is understood by contour as the set ofthe points whose normals are perpendicular to the viewdirection (look at vector of the camera). Note that thecontours contain more information than the silhouette ofthe object. Figure 13a shows an example of the contour ofan object. Applications such as Teddy [3] and ShapeShop[5] are examples of constructive systems based on contours.These systems calculate the skeleton (medial axis). Based onthis element, there are different approaches to generating theobject’s surface. One example is to rotate the points of thetrace around the medial axis. This technique is illustrated inFigure 13b. Another approach is the technique of inflationshown in Teddy (Figure 13c).

We can still cite other 3D modeling techniques, suchas techniques for building height fields [36], as shown inFigure 17. This type of technique creates a surface that isthe function graph. Another technique for building heightfields is defining level curves. Height fields are an interestingway to specify terrains. A work, in this area, is the TerrainSketching [37]. In this work, besides the sketches used todefine the macro-structure of the land, the application usessome procedural methods to synthesize a realistic geometry(Figure 18).

As mentioned, sketching is a very good way to convey anidea with few strokes. Thus, we should not expect a wealthof details on the drawing provided. Therefore, a character-

(a)

(b)Figure 14. Specific classes of modeled objects.

Figure 15. Example of a sketch difficult to create a 3D model.

istic of sketch-based modeling is generating objects withcoarse geometry. Even with this set of different techniquesfor building 3D graphics objects from sketches, it is stillvery difficult to create precisely a generic object, with highquality and realism.

Moreover, there are applications that model objects of aspecific class with enough realism and accuracy. When themodeled object classes is known it can compensate for thelimited information contained in the sketch with data knownby application a priori. In such cases, the sketch is used todetermine the structural elements of the model, while thedetails are inferred by the application. We can cite specificclasses of modeled object: hair [38] (Figure 14a), trees [39](Figure 14b)) and flowers [40].

Creating a geometric model from sketches is not a simpletask. For example, Figure 15 shows an example of a sketchwith which one can not yet generate a 3D environment onlyby interpreting the model curves. This operation is onlypossible from simplistic construction techniques. Thus, torefine the geometry of object it is necessary to edit it aftercreated. Editing techniques will be presented in the nextsection.

C. Editing

The modeling process is often interactive (interactionrefers to edit a template already set). This editing canoccur on two levels. The first one refers to the sketch

Figure 16. Detail adding on object surfaces.

Figure 17. Use of Sketch to define high field.

Figure 18. Terrain generated by sketches.

editing. This editing varies with the sketch representation.For example, if the sketch is represented by a parametriccurve it can be directly manipulated. If this curve is a spline,the user can manipulate its control points. Another approachis using corrective oversketching to modify sections of thesketch. The other editing level is to modify the 3D graphicobject modeled. Again, the method and representation areinextricably linked. In this section we will focus on theediting of 3D object.

The editing process can contain operations such as addingdetails to the surface; adding members to the object, per-forming punctual deformation of the surface, or global defor-mations (such as bending, twisting, etc); changing topology,such as creating holes; performing affine transformations,etc. Botsch and Sorkine [41] showed a collection of surfacedeformation methods (although the deformation specifica-tion in this paper does not emphasize the use of sketches,these can be adapted for use in SBIM applications).

The adding detail operation is intrinsically linked to thesurface representation. For example, you can edit details

Figure 19. Shading-based surface editing.

Figure 20. Detail adding in meshes.

Figure 21. Surfaces Blending.

Figure 22. Adding a piece object on Teddy.

using normal information [42] (Figure 16a). You can addsome features to the modeled object, such as elevations,holes, slots, etc. (Figure 16b). Gingold and Zorin [43] showsa editing method based on sketches that represent shadingon surface (Figure 19).

The work of Luke Olsen et al [44] shows an exampleof editing details in a subdivision surface. The Figure 20shows the editing pipeline. Initially there is the mesh of theobject. Then, the sketch is projected on this mesh. It appliesa method of adaptive subdivision based on the projectedcurve. Finally, it creates a sharp feature in the mesh.

Another editing operation is adding members to the object(Figure 22). This operation consists of adding a new piece tothe model previously created. The work of Wang [45] showshow a blending between two surfaces joins pieces smoothly(Figure 21).

The aforementioned editing operations do not changethe structure of the previously modeled object. But, thereare some operations that modify the structure locally orglobally. A simple example is a resizing operation of anobject modeled in Chateau [4] (Figure 23b). Note that inthe left frame an edge is marked and resized. Then, theapplication resizes all parallel edges and it adjusts the model.In this case, the application needs to interpret the meaningof the operation on the full object (global deformation) andnot just changing the faces containing the manipulated edge(local deformation).

iWIRES [46] is another application that interprets thesketch’s meaning to perform a global structural deformation.In this work, the deformation process starts by drawing acurve on the object’s surface. Then, we can draw anothercurve determining how the first will be deformed. This de-formation is interpreted and properly propagated throughoutthe object. Figure 23d shows an example of an object beingdeformed by this application.

Another example of global structural deformation is toapply operations such as bending, twisting, etc. Normally

Figure 23. Local structural editing.

these operations are based on structural curves. Cherlin etal in 2005 [47] showed a way to deform objects by structuraldeformation. The editing is performed by modifying themedial axis of an object (Figure 23e).

We can also deform a mesh by local structural curves.This operation marks a curve on the object surface andapplies corrective oversketching to modify it. This methodwill deform the object surface so that the initially markedcurve is carried on to the edited curve. Nealen et al showa method to apply local structural editing [22]. The authorspresents an application for editing meshes preserving details(Figure 23a).

Another example of structural editing using sketch waspresented by Kho et al [48]. In this work, after modeling,the application constructs the medial axis of the object.It enables deforming the object locally through a partialdeformation of the medial axis. This deformation is donethrough a sketch determining the new shape of part of themanipulated axis (Figure 23b).

Throughout this section, we presented some editing oper-ations on the model. Similar to creation techniques, editingtechniques are strongly tied to the object representation. Inthe next section will present a brief discussion of differentgraphic object representation techniques.

D. Model Representation

As mentioned above, the choice of object representationis closely linked to choice of possible methods for creationand editing. We can divide the surface representations in twocategories: parametric and implicit.

Parametric surfaces is a possibility widely used to rep-resent objects. This technique consists in defining an atlasfor the modeled surface. We can define an atlas as a setof parametrization ϕ : V −→ W whose images coverthe surface. This atlas may have interesting features, likeall parameterizations are Ck functions, which may allowperforming operations with surface derivatives. NURBS

(Non-Uniform Rational B-Splines) and revolution surfacesare examples of parametric representations, widely used inmodeling applications. These techniques have been widelystudied, which means, several possibilities of creation andediting parametric objects are already known. Dependingon the object topology, the atlas definition can be morecomplex. It may be necessary to perform operations suchas union and blending to join properly different surfaces.

Implicit surfaces are obtained from the solution of anequation. For example, given f : U ⊂ R3 −→ R, we couldconsider a surface M = f−1(0) = {(x, y, z); f(x, y, z) =0}. This representation facilitates operations such as conti-nence test and boolean operations (union, intersection anddifference). On the other hand, it hinders perform operationssuch as smoothing, adding features and structural or punctualdeformation. One type of implicit surface used in modelingare isosurface.

Both implicit and parametric objects are commonly trans-formed into meshes to aid rendering. Graphic hardwareswork well with meshes. Furthermore, there are severalresults that work with meshes. These representations arewidely used in modeling applications, because they allowmodeling objects of any topology. On the other hand, it ismore complicated to perform editing operations on meshes.

In this section, we have seen several modeling operationsand different graphic object representations. Both operationsand representation techniques have its positive and negativeaspects. Thus, it is not possible to determine a set ofoperations and a specific representation to produce goodresults for all modeling purposes. These choices depend oneach project. In the next section, we present some challengesand possibilities on SBIM development, highlighting somechoices made in some works.

IV. INTERACTION IN SBIM APPLICATIONS

When developing an application, there are several deci-sions to be taken regarding data acquisition, object represen-tation, modeling operations and interface objects. We canclassify the development decisions of a SBIM applicationinto two categories: modeling and user interaction. Themodeling decisions refers to the choice of modeling methods(creation and editing) and objects representation. In thissection, we discuss the decisions regarding user-applicationinteraction, addressing the different possibilities that arisefrom different device acquisitions and analysing interfaceaspects.

With the advancement of data acquisition devices user-application interaction have emerged. We can differ thesedevices by how many cursors they can capture, what infor-mation they capture and feedback. Throughout this sectionwe will analyze, in particular, some data acquisition devices:keyboard/mouse, Tablet and iTable, highlighting how theycan help in the modeling process.

Figure 24. iTable.

The mouse and keyboard are the most known and useddata acquisition device. By moving the mouse, we canobtain a set of positions on the screen of our application.The possible information obtained from the mouse is itsposition, if any button was pressed or if the scroll was turned.With the keyboard, it is possible to trigger events related topressing one or more keys. These events have been shownsufficient for developing of modeling applications. However,devices such as Tablet and tangible interfaces let we captureinformation that can be used in modeling process, makingit more natural.

Tablets allow capture of the position and the inclinationof the pen, beyond the pressure exerted by the user doingthe drawing. Furthermore, a feature that makes the drawingprocess more natural is the fact of the input interface isthe same as the output. This allows that the location wherethe user touches the pen to be mapped onto the screen inthe same position of the cursor. This is different from whathappens with the mouse.

People prefer drawing with a pen than with a mouse. Inmodeling applications that use the mouse, the users adjustthemselves to the system, making drawings with precision.However, drawing with the Tablet’s pen is more natural.Often Novice users find it easier to use a Tablet, makingmore accurate and faster strokes.

The iTable (Figure 24) is a multitouch table built at IMPA,based on ReacTable, using the TUIO protocol. Multitouchinterfaces allow the user to interact with the system usinghis fingers or tangible objects (which enables to create aimmersive and natural system). In this device the input andoutput are on the same interface, similar to the Tablet.

The interaction using multiple fingers allow performingoperations that with just one single cursors would be moredifficult or even impossible. For modeling, this feature facil-itates the drawing of curves with symmetry and parallelism.Another advantage of using of the finger is to avail themaximum efficiency of the user motor control.

The information captured from a fiducial are position andangle (the rotation relatives to the coordinate system of thetable). A fiducial can be used to trigger events or evoke somewidgets such as menus, for example.

Multitouch devices usually have a lower precision, be-cause the input interface may have low resolution, or simplybecause the finger occupy a large area (compared to themouse cursor). This precision decrease can hinder the detail

Figure 25. Suggestive Interfaces of Magic Canvas.

adding process, for example. Another disadvantage is itis susceptible to noise, in this type of system. Althoughnoise can be prevented with a proper calibration and treatedthrough post-processing, their presence may cause someundesired effects, or at least, require special attention of thedeveloper.

An application can run on more than one type of acqui-sition device through a mapping of the captured informa-tion. However, some information id device specific. Thus,an important development decision is which devices aresupported. If we choose a specific type, we can avail theirresources and accomplish operations in a particular way.

The interface objects, used in the application, are anotherrelevant aspects of the interaction. The interface paradigmaffects directly in the inference of which operation thesystem should execute based on user action. A modelingsystem must be able to support creating, editing and controloperations.

The interfaces of modeling applications like Maya,Blender and autoCAD are extremely complicated. Moreover,this type of interface lets we easily add a functionality tothe system (adding a widget interface). Moreover, the userstarts a specific action once he activates a widget, withoutambiguity. Accomplishing this in gesture-based systemsremains a challenge.

Another challenge, related to the interfaces, is known asSelf-Disclosure. This problem consists in fact of in purelygesture-oriented interface a user does not know, a priori,which gestures are significant to the system. Instead, in aWIMP system, the user can explore it, trying the widgets,reading labels and looking at icons. So he achieves performsome tasks without prior instruction.

Therefore, a major challenge in developing applicationswith sketch-based interfaces is a compromise in the choiceof interface objects. The functionalities should be easily ac-cessible without too many widgets that pollute the interfaceand hinder the learning process. Another challenge is topropose interfaces objects that solve problems inherent inSBIM applications.

We can classify an object interface in an SBIM applicationin three categories: widgets of window, of scene and ofobject. The widgets of window are application objects thatare outside of the modeling canvas, used to specify a stateor operation in the application. Widgets of scene are objectsin the modeling canvas carrying out some operations oncamera or on lighting. Widgets of objects are elements thatoperate on modeled objects. Each of these widgets can bemodeled taking into account four aspects: representation,status, operation and feedback.

In purely gesture-based interfaces, the greatest challengeis recognizing a gesture to associate it with an operation.Existing solutions to this problem relate to very specificgestures that the user must know a priori. The use of gesturescan replace the use of a set of widgtes. On the other hand,if the system accomplish many operations there are muchchance of have ambiguous gestures, or very similar (whichcomplicates the recognition process).

An alternative to resolve the gesture ambiguity is present-ing all possible operations and let the user choose. This typeof interface is known as a suggestive interface. The Figure25 shows the interface of Magic Canvas [34], an exampleof application that shows a suggestive interface.

By the difficulty of interpreting certain gestures, anotherpossibility to facilitate inferring a semantic in a gesture isto enable the user to make annotations suggestive. Theseannotations can be used in the interpretation of the sketch.An example of application that uses annotations to infer ameaning to sketch is the Sketch2Photo [49].

Another interface resource is the application trying to inferfuture strokes that the user can do, based on already drawn.This feature is called prediction, and it can accelerate themodeling process, and ensure that the object maintains somegeometric properties such as parallelism, perpendicularity,

Figure 26. Anotaion on Sketch2Photo.

Figure 27. Layers.

Figure 28. Drawing surfaces.

congruence, etc.The use of interface elements, such as suggestion, pre-

diction and annotation, facilitate both the application knowwhich operation should run in a given time, as the usermakes decisions regarding a specific operation that willperform. Note that, the suggestions may be considered anapplication widgets (a menu of operations). However, it isa hybrid application example (gestures and WIMP) with anunpolluted interface, as the menu displays only the optionsthat the user can choose among the last gesture executed.Another simple and interesting feature, which facilitatesthe user-application interaction, is to highlight the selectedelements (eg vertices, edges, faces, objects, or some otherelement of the scene).

Layers are another interface object. When a designeris making a drawing, he usually uses some constructivetechnique, based on specific curves, such as silhouette,suggestive contours and constructive curves. Some of thesecurves are used to aid the modeling process, but they do notenter the final drawing (Figure 27).

Sketches curves can be projected on various surfaces. Oneis the screen plane. In this case, once you start a modelingoperation the sketch points should be transformed to thecoordinate system of the scene. Another way is to projectthe sketch onto the scene as soon as it is captured. Thisprojection can be made on existing objects or on drawingsurfaces placed at the scene. Tsang et al presented a work[26] that uses these planes for modeling (Figure 28). Thissupport surface can have a more complicated geometryenabling creation of a convenient environment space for theuser to sketch a curve.

We can still think of other interface elements such ascontrol elements for lighting, camera and scene dimensions;different views, etc. Beyond these interface elements we canhave mechanisms such as learning from the user, queryinginformation in a database, multiple remote users, etc.

All resources mentioned in this section can be used on ainterface of an SBIM application. The choice of using themor not should be made to simplify the life of the user and /or the developer. Thus, an interface should be clean, easy to

use and learn, accessible functionalities and natural. Thesegoals must be analyzed to define a compromise betweengestures and interface objects.

V. SBIM-TKBased on the architecture proposed in this paper, we

developed a prototype toolkit with a set of generic featuresthat can be used in different SBIM applications. This toolis available at http://www.impa.br/˜lcruz/sbim/sbimtk

VI. CONCLUSION

We have presented a conceptualization and identificationof key trends and features present in SBIM applications.We have shown different modeling tasks that are possibleto make using sketches. These tasks exploit the abilityof the sketch to quickly convey an idea. In particular, inmodeling sketching is useful to draw contours as silhouettes,or to highlight the main features of the object’s surface.Furthermore, the use of sketch in a modeling applicationis an intuitive resource because it is similar to the act ofmaking a drawing on paper.

A SBIM trend is to interpret the sketch to attribute asemantic to each operation. Some examples are applicationsthat use beautification [20], [4]; or applications that performglobal deformation based on few traces [4], [46]. Anothermodeling trend is to make structural deformation preservingdetails [22], [47].

Because of the difficulties shown in gesture-based appli-cations development, some studies have used resources todisplay predictions and suggestions to the user, to facilitatethe modeling and resolve ambiguities. The use of predictionsalso follows the trend of inferring semantics to sketch inorder to generate models with certain geometric features, aswell as accelerate the modeling process.

On the one hand, interpreting a sketch is not a simple taskand ambiguity problems may be encountered. On the otherhand, by dominating this procedure, we will be able to createcleaner interfaces (with fewer Widgets) and therefore fasterto learn and easier to use. Although in this work we haveconcentrated only in specific concepts and features relatedto modeling applications, the paradigm of gestures, as wellas the WIMP paradigm, is more generic and can be usedin other applications. We can cite games, media organizersand viewers, story board, smart boards, image manipulation[50] (Figure 29), etc.

Currently it is possible to develop interesting applicationsusing sketches and gestures, though there are still some

Figure 29. Sketch-based image deformation.

challenges and open problems. The first challenge relatesto the difficulty of interpreting sketches. On the one hand,sketching is interesting to humans, because they can easilyassociate it with more complex forms, for the computer thisoperation is not trivial. Normally, what is done is to interpretthe sketches iteratively, or segmented. Another importantfact on development of an interface based solely on gesturesis the difficulty to create many application’s functionalities,because the gesture vocabulary tends to become increasinglyambiguous.

Although the major motivation of SBIM is to createan application that resembles the way an artist makes adrawing with pen and paper, we are still far from achievingthat. Usually the applications have its own peculiaritiesthat must be respected by the user, to simplify the sketchinterpretation process, as well as the modeling operations.This reduces the sense of immersion and naturalness withwhich the user would interact with the system. Thus, one ofthe biggest challenges when developing an SBIM applicationis developing the user interface.

Another challenge is interpreting the sketch shapes to mapthem into 3D objects. Although we have shown sketch-basedtechniques for modeling and deformation, the vast majorityfocus on contour lines, constructive curves or significantcurves. Moreover, many artists while drawing using othertechniques such as shading, oversketching, dotted, etc. Tointerpret together all these elements is not a trivial task.

The major advantage of using a sketch is the ease ofquickly transmiting an idea. This is due to the fact thatpeople can easily interpret a sketch and associate to itwith some object (possibly a 3D object). Use sketch in theconstructive process involves to interpret it and associate itto some form. But, the more shapes an application can uses,the greater the chance of having ambiguities. Another majordifficulty is to interpret depth and occlusions.

Another SBIM challenge is creating models with highquality, as in traditional modeling applications. A resourceis to build simple forms and refine them interactively. Thischallenge is very much related to object representation. Forexample, by manipulating meshes, it is possible to createcomplex models, but the higher the mesh resolution thehigher the computational cost to perform the deformation.Another possibility is to handle the modeling problem withspecific classes of objects. We have presented works that cansynthesize objects such as hair, trees, flowers and land withprecision and quality.

Understanding the particularities, challenges and limita-tions of modeling using sketches are interesting researchtopics in SBIM. Despite the challenges listed, applicationsbased on sketches have shown a trend in modeling. In thistext, we presented several examples of applications, withsome interesting results, and several possibilities that can bemerged to build a robust modeling system.

ACKNOWLEDGMENT

We would like to thank the CNPq, for funding thefirst author of this article, and the VISGRAF - IMPA, byproviding an environment for fruitful research.

REFERENCES

[1] I. Sutherland, “Sketch pad a man-machine graphical commu-nication system.” Share design automation workshop, 1964.

[2] R. Zeleznik, K. Herndon, and J. Hughes, “Sketch: An inter-face for sketching 3d scenes.” ACM SIGGRAPH, 1996.

[3] T. Igarashi and J. F. Hughes, “Teddy: a sketching interfacefor 3d freeform design.” ACM SIGGRAPH, 1999.

[4] T. Igarashi, S. Matsuoka, and H. Tanaka, “A suggestiveinterface for 3d drawing.” Eurographics - Workshop onsketch-based interfaces and modeling, 2001.

[5] R. Schmidt, B. Wyvill, M. Sousa, and J. Jorge, “Shapeshop:sketch-based solid modeling with blobtrees.” Eurographics- Workshop on Sketch-Based Interfaces and Modeling, 2005.

[6] A. Nealen, T. Igarashi, O. Sorkine, and M. Alexa, “Fiber-mesh: designing freeform surfaces with 3d curves.” ACMSIGGRAPH, 2007.

[7] L. Olsen, F. F. Samavati, M. C. Sousa, and J. A. Jorge,“Sketch -based modeling: a survey.” Computers and Graph-ics, 2008.

[8] M. T. Cook and A. Agah, “A survey of sketch-based 3-dmodeling techniques.” Interacting with Computers, 2009.

[9] P. Company, A. Piquera, M. Contero, and F. Naya, “A surveyon geometrical reconstruction as a core technology to sketch-based modeling.” Computer Graphics, 2005.

[10] J. Gomes and L. Velho, Fundamentos da ComputacaoGrafica. IMPA - Serie de Computacao e Matematica, 2003.

[11] F. F. Samavati and R. H. Bartels, “Local filters of b-splinewavelets.” Biometric, 2004.

[12] T. M. Sezgin, T. Stahovich, and R. Davis, “Sketch based inter-faces: Early processing for sketch understanding.” Workshopon Perceptive User Interfaces, 2001.

[13] T. F. Stahovich, “Segmentation of pen strokes using penspeed.” AAAI Fall Symposium Series 2004: Making Pen-Based Interaction Intelligent and Natural, 2007.

[14] L. Eggli, C. yao Hsu, B. D. Bruderlin, and G. Elber, “In-ferring 3d models from freehand sketches and constraints.”Computer-Aided Design, 1997.

[15] B. Fowler and R. Bartels, “Constraint-based curve manipula-tion,” in Computer Graphics and Applications. IEEE, 2004.

[16] D. F. Rogers and R. Bartels, “Constrained b-spline curve andsurface fitting,” in Computer-Aided Design, 1989.

[17] P. J. Schneider, “An algorithm for automatically fitting digi-tized curves,” in Graphics gems, 1990.

[18] S. F. Frisken, “Efficient curve fitting,” in Journal of GraphicsTools. A K Peters, 2008.

[19] T. Igarashi, S. Matsuoka, S. Kawachiya, and H. Tanaka,“Interactive beautification: A technique for rapid geometricdesign.” Symposium on User Interface Software and Tech-nology, 1997.

[20] S. Murugappan, S. Sellamani, and K. Ramani, “Towardsbeautification of freehand sketches using suggestions.” Eu-rographics - Workshop on sketch-based interfaces and mod-eling, 2009.

[21] T. Baudel, “A mark-based interaction paradigm for free-hand drawing.” Symposium on User interface software andtechnology, 1994.

[22] A. Nealen, O. Sorkine, M. Aleax, and D. Cohen-Or, “Asketch-based interface for detail-preserving mesh editing.”ACM Transactions on Graphics, 2005.

[23] T. Fleisch, F. Rechel, P. Santos, and A. Stork, “Constraintstroke-based oversketching for 3d curves.” Eurographics -Workshop on Sketch-Based Interfaces and Modeling, 2004.

[24] R. Pusch, F. Samavati, A. Nasri, and B. Wyvill, “Improvingthe sketch-based interface forming curves from many smallstrokes.” The Visual Computer: International Journal ofComputer Graphics, 2007.

[25] L. B. Kara, C. M. D’Eramoc, and K. Shimada, “Pen-basedstyling design of 3d geometry using concept sketches andtemplate models.” ACM Symposium on Solid and PhysicalModeling, 2006.

[26] S. Tsang, R. Balakrishnan, K. Singh, and A. Ranjan, “A sug-gestive interface for image guided 3d sketching.” Conferenceon Human factors in computing systems, 2004.

[27] J. M. Cohen, J. F. Hughes, and R. C. Zeleznik, “Harold: aworld made of drawings.” NPAR, 2000.

[28] J. M. Cohen, L. Markosian, R. C. Zeleznik, J. F. Hughes, andR. Barzel, “An interface for sketching 3d curves.” Sympo-sium on Interactive 3D graphics, 1999.

[29] O. Tolba, J. Dorsey, and L. McMillan, “Sketching with pro-jective 2d strokes.” Symposium on User interface softwareand technology, 1999.

[30] E. Gamma, R. Helm, R. Johnson, and J. Vlissides, DesignPatterns: Elements of Reusable Object-Oriented Software.Addison-Wesley, 1994.

[31] T. M. Sezgin and R. Davis, “Temporal sketch recognition ininterspersed drawings.” Eurographics - Workshop on sketch-based interfaces and modeling, 2007.

[32] J. Pu and K. Ramani, “Implicit geometric constraint detec-tion in freehand sketches using relative shape histogram.”Eurographics - Workshop on sketch-based interfaces andmodeling, 2007.

[33] L. Olsen, F. F. Samavati, and M. C. Sousa, “Fast strokematching by angle quantizationy.” International Conferenceon Immersive Telecommunications, 2007.

[34] H. Shin and T. Igarashi, “Magic canvas: Interactive designof a 3d scene prototype from freehand sketches.” GraphicsInterface, 2007.

[35] H. Lipson and M. Shpitalni, “Optimization-based reconstruc-tion of a 3d object from a single freehand line drawing.”SIGGRAPH courses, 2007.

[36] Y.-J. Liu, K. Tangb, and A. Joneja, “Sketch-based free-formshape modelling with a fast and stable numerical engine.”Computers Graphics, 2005.

[37] J. Gain, P. Marais, and W. Straber, “Terrain sketching.”Symposium on Interactive 3D graphics and games, 2009.

[38] H. Fu, Y. Wei, C.-L. Tai, and L. Quan, “iwires: an analyze-and-edit approach to shape manipulation.” Eurographics -Workshop on sketch-based interfaces and modeling, 2007.

[39] J. Wither, F. Boudon, M.-P. Cani, and C. Godin, “Structurefrom silhouettes: a new paradigm for fast sketch-based designof trees,” in Computer Graphics Forum, 2009.

[40] T. Ijiri, S. Owada, M. Okabe, and T. Igarashi, “Floral dia-grams and inflorescences: interactive flower modeling usingbotanical structural constraints.” Transactions on Graphics,2005.

[41] M. Botsch and O. Sorkine, “On linear variational surfacedeformation methods.” IEEE Transactions on Visualizationand Computer Graphics, 2008.

[42] T. S. Pereira, “Normalshop: Normal surface mesostructure,”Master’s thesis, IMPA, 2010.

[43] Y. Gingold and D. Zorin, “Shading-based surface editing.”ACM SIGGRAPH, 2008.

[44] L. Olsen, F. F. Samavati, M. C. Sousa, and J. A. Jorge,“Sketch-based mesh augmentation.” Eurographics - Work-shop on sketch-based interfaces and modeling, 2005.

[45] H. Wang and L. Markosian, “Free-form sketch.” Eurograph-ics - Workshop on sketch-based interfaces and modeling,2007.

[46] R. Gal, O. Sorkine, N. J. Mitra, and D. Cohen-Or, “Sketchinghairstyles.” ACM SIGGRAPH, 2009.

[47] J. J. Cherlin, F. Samavati, M. C. Sousa, and J. A. Jorge,“Sketch-based modeling with few strokes.” S. SpringConference on Computer Graphics, 2005.

[48] Y. Kho and M. Garland, “Sketching mesh deformations.”ACM SIGGRAPH, 2005.

[49] T. Chen, M.-M. Cheng, P. Tan, A. Shamir, and S.-M. Hu,“Sketch2photo: internet image montage.” ACM SIGGRAPHAsia, 2009.

[50] M. Eitz, O. Sorkine, and M. Alexa, “Sketch based imagedeformation.” In Proceedings of Visual, Modeling andVisualization, 2007.