FoldSketch: Enriching Garments with PhysicallyReproducible FoldsbyMinchen LiB.Eng. in Computer Science and Technology, Zhejiang University, 2015A THESIS SUBMITTED IN PARTIAL FULFILLMENTOF THE REQUIREMENTS FOR THE DEGREE OFMaster of ScienceinTHE FACULTY OF GRADUATE AND POSTDOCTORALSTUDIES(Computer Science)The University of British Columbia(Vancouver)April 2018c©Minchen Li, 2018AbstractWhile folds and pleats add interest to garments and cloth objects, incorporatingthem into an existing design manually or using existing software requires expertiseand time. This thesis presents FoldSketch, a new system that supports simple andintuitive fold and pleat design. FoldSketch users specify the fold or pleat config-uration they seek using a simple schematic sketching interface; the system thenalgorithmically generates both the fold-enhanced 3D garment geometry that con-forms to user specifications, and the corresponding 2D patterns that reproduce thisgeometry within a simulation engine. While previous work aspired to computethe desired patterns for a given target 3D garment geometry, the main algorithmicchallenge here is that the target geometry is missing. Real-life garment folds havecomplex profile shapes, and their exact geometry and location on a garment areintricately linked to a range of physical factors; it is therefore virtually impossibleto predict the 3D shape of a fold-enhanced garment using purely geometric means.At the same time, using physical simulation to model folds requires appropriate 2Dpatterns and initial drape, neither of which can be easily provided by the user.FoldSketch obtains both the 3D fold-enhanced garment and its correspondingpatterns and initial drape via an alternating 2D-3D algorithm. We first expand theinput patterns by allocating excess material for the expected fold formation; thenwe use these patterns to produce an estimated fold-enhanced target drape geometrythat balances designer expectations against physical reproducibility. Next, we gen-erate an initial reproducible output using the expanded patterns and the estimatedtarget drape as input to a garment simulation engine. Then we improve the output’salignment with designer expectations by progressively refining the patterns and theestimated target drape, converging to a final fully physically reproducible fold-iienhanced garment. The experiments confirm that FoldSketch reliably converges toa desired garment geometry and corresponding patterns and drape, and works wellwith different physical simulators. My collaborators and I demonstrate the ver-satility of this approach by showcasing a collection of garments augmented withdiverse fold and pleat layouts specified via the FoldSketch interface, and furthervalidate this approach via feedback from potential users.iiiPrefaceThe ideas and algorithms described in this thesis, unless stated below, were devel-oped by myself in consultation with Prof. Alla Sheffer and Prof. Eitan Grinspun.The designer validation and perceptual validation mentioned in Section 8.4 andSection 8.6 were conducted by Prof. Alla Sheffer, Nicholas Vining, and myselfwith UBC approval (UBC BREB Number H16-02320).The manufacturing mentioned in Section 8.5 is conducted by Mary Buckland.The we and our used in this thesis express my acknowledgement and respectto all my collaborators.All the ideas and algorithms described will be published as a research paper inACM TOG and presented at a conference (SIGGRAPH) in August 2018:• Minchen Li, Alla Sheffer, Nicholas Vining, Eitan Grinspun. FoldSketch:Enriching Garments with Physically Reproducible Folds. Conditionally ac-cepted to SIGGRAPH 2018.ivTable of ContentsAbstract . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . iiPreface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ivTable of Contents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . vList of Figures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . viiAcknowledgments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xi1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 Related Work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.1 Garment Construction and Traditional Fold Design . . . . . . . . 62.2 Computational Garment Design . . . . . . . . . . . . . . . . . . 72.3 Fold and Wrinkle Modeling . . . . . . . . . . . . . . . . . . . . . 103 Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . 113.2 Solution Framework . . . . . . . . . . . . . . . . . . . . . . . . 113.3 Pattern Extension . . . . . . . . . . . . . . . . . . . . . . . . . . 123.4 3D Target Drape Estimation . . . . . . . . . . . . . . . . . . . . 133.5 2D-3D Update . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 Sketch Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14v5 Pattern Extension . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185.1 Tensor Field Computation . . . . . . . . . . . . . . . . . . . . . 195.1.1 Computation of 3D Expansion Direction . . . . . . . . . 205.1.2 Preliminary Region of Influence . . . . . . . . . . . . . . 215.1.3 Computation of Expansion Magnitudes . . . . . . . . . . 225.1.4 Tensor Field Projection onto 2D Patterns . . . . . . . . . 235.2 Pattern Deformation . . . . . . . . . . . . . . . . . . . . . . . . . 266 Target Drape Computation . . . . . . . . . . . . . . . . . . . . . . . 286.1 Design Preservation Energy . . . . . . . . . . . . . . . . . . . . . 296.2 Initial Drape . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307 2D and 3D Update . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337.1 Pattern Update . . . . . . . . . . . . . . . . . . . . . . . . . . . 337.2 Garment Update . . . . . . . . . . . . . . . . . . . . . . . . . . . 347.3 Convergence . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358 Results and Validation . . . . . . . . . . . . . . . . . . . . . . . . . . 368.1 Simulators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408.2 Timing And Parameters . . . . . . . . . . . . . . . . . . . . . . . 428.3 Algorithmic Choices . . . . . . . . . . . . . . . . . . . . . . . . 428.4 Designer Validation . . . . . . . . . . . . . . . . . . . . . . . . . 438.5 Manufacturing . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438.6 Perceptual Validation . . . . . . . . . . . . . . . . . . . . . . . . 449 Conclusions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459.1 Limitations and Future Work . . . . . . . . . . . . . . . . . . . . 45Bibliography . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48A Perceptual Validation Material . . . . . . . . . . . . . . . . . . . . . 52viList of FiguresFigure 1.1 Complex physically simulated fabric folds generated using FoldS-ketch: Plain input flag with user sketched schematic folds (a),original (green) and modified final (red) patterns (b); final post-simulation flag augmented with user-expected folds (c); real-life replica manufactured using the produced patterns (d); zoom-ing in highlights the complex and evolving output fold profileshapes (e). . . . . . . . . . . . . . . . . . . . . . . . . . . . 2Figure 1.2 Different types of folds and pleats supported by our frame-work: (top) schematic user sketch; (bottom) output folds. . . . 3Figure 2.1 Given the same schematic fold notations and visually identicalinput garments with different fabric properties (a) our frame-work produces reproducible fold-augmented garments (b,c) thatreflect the different bending parameters of the inputs and thecorresponding sets of patterns (d) - red for the thicker fabric(b) and blue for the thinner one (c). . . . . . . . . . . . . . . 7Figure 2.2 Existing fold modeling methods (here [28]) generate simplisticfold shapes (a); which cannot be reproduced via subsequentpattern computation and resimulation (b); given similar inputfold-paths (c) we compute complex reproducible folds (d). . . 8viiFigure 2.3 FoldSketch Algorithm: (left to right) The input consists of agarment pattern, a corresponding drape on a mannequin, anddesigner-sketched folds. Folds require additional fabric ma-terial, which is obtained by extending the pattern. Drapingdepends heavily on the initial drape of the simulation; a poorinitial drape does not lead to the desired fold arrangement. Weadd fictitious style constraining forces to induce the fold ar-rangement, obtaining a target drape. We iterate, seeking aninitial drape that yields a similar fold arrangement without fic-titious forces. Starting from the target drape, an unadulterateddraping simulation produces a candidate output drape. Thecandidate is acceptable if we cannot improve upon it. We at-tempt to improve the garment pattern to reduce differences be-tween the target and output drapes. If we make a substantialupdate to the pattern, we iterate, using our output candidate asthe new initial drape. . . . . . . . . . . . . . . . . . . . . . . 9Figure 3.1 Input garment and strokes (a) and unconstrained simulationoutputs produced using different initial drapes: (b) from flatpanels; (c) from initial 3D garment (augmented with pleat sewingscheme); (d) from our initial 3D target drape. (e) Final result(using iteratively updated patterns and target drape). The hori-zontal lines highlight the garment proportions. . . . . . . . . 12Figure 4.1 UI walkthrough example: (a) fold path strokes (blue) tracedover input garment in 3D view; (b) gathering stroke; (c) outputgarment. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14Figure 4.2 Impact of different gathering strokes on output folds: (a,b)hemline folds with different magnitude, (c,d) gathered foldswith different magnitude, (e) pinched pleats with different width(left and right shoulders), (f) knife pleats with different orien-tation (left and right panels). . . . . . . . . . . . . . . . . . . 16viiiFigure 5.1 Pattern extension: (a) input garment and strokes; (b) visualized3D space scaling field; (c) scaling field on 2D patterns; (d)extended patterns (blue) and input patterns (green). . . . . . . 19Figure 5.2 ei,k is the k-th edge of ti, qi is the vector defined in the localframe of ti, the discrete Levi-Civita connection is defined asri j = βi−β j . . . . . . . . . . . . . . . . . . . . . . . . . . . 20Figure 5.3 Impact of fold pre-conditions: (top) result without and with or-thogonal stretch cancellation; (bottom) result without and withfold path stretching. Note the impact on fold length and shape. 25Figure 6.1 Top: crisp knife pleats; bottom: pinched pleats sewing. . . . . 31Figure 6.2 Pattern and garment update: (a) user input garment and strokes;(b) extended patterns (blue) superimposed on original (green)and initial target drape; (c) unconstrained simulation output us-ing these patterns and drape; (d) updated patterns (purple) su-perimposed on extended ones (b,blue) and unconstrained sim-ulation output using these new patterns and initial drape; (e)final patterns (red) superimposed on updated (purple) and ex-tended (blue) and final unconstrained drape. . . . . . . . . . . 32Figure 7.1 Left: average triangle area per pattern update iteration; right:percentage of non-expanding triangles per pattern update iter-ation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34Figure 8.1 Manufactured example: (left to right) Plain input tissue boxcover with user sketched schematic folds and final post-simulationresult augmented with user-expected folds; original (green)and modified final (red) patterns; real-life replica manufac-tured using the produced patterns, with zooming in highlightsthe complex and evolving output fold profile shapes. . . . . . 37Figure 8.2 Additional results created using Sensitive Couture. . . . . . . 38Figure 8.3 Folds created from designer annotations. . . . . . . . . . . . . 39Figure 8.4 Examples created using ARCSim. . . . . . . . . . . . . . . . 40ixFigure 8.5 Comparison with deformation based pattern extension: (left)input, (center) garments simulated using deformation-basedextended patterns, (right) Our results. The naive approach re-sults in multiple artifacts. . . . . . . . . . . . . . . . . . . . . 41Figure 8.6 Extreme material experiment: user input garment and strokes(a), final unconstrained drape with thinner textiles (b), stretchyknits (c), silk (d), and thick leather (e). . . . . . . . . . . . . . 41Figure 9.1 FoldSketch fails to detect infeasible inputs such as long hori-zontal fold-paths in loose garment regions (a), or highly curvedindependent fold-path that would need more stitches along thepath, or special fabrics to support (b). . . . . . . . . . . . . . 46Figure A.1 Perceptual Validation, with stats. . . . . . . . . . . . . . . . . 53Figure A.2 Perceptual Validation, with stats (continued). . . . . . . . . . 54xAcknowledgmentsI would like to express my sincere thanks to my academic advisor Prof. Alla Shef-fer for her continuous support of my graduate study and research throughout thepast two years. Without her guidance and encouragement, this thesis would neverexist. I also thank her for providing me many oppoortunities for my career.Furthermore, I would like to thank Prof. Eitan Grinspun for helpful discussion,insight and feedback.Thanks to Nicholas Vining, Mary Buckland, Silver Burla, Yuan Yao, EnriqueRosales, Qingyue Wang, and Xinyu Li for the help when was most needed and forcomplementing my skills.Thanks to Aric Bartle, Vladimir G. Kim, Danny M. Kaufman, Floraine Berthouzoz,and Nobuyuki Umetani for providing their code and garment data, and thanks toDamien Rohmer for generating output of previous work for comparison.Most of all, I would like to deeply thank my parents, who encouraged andsupported my choice of studying far from home.xiChapter 1IntroductionFashion designers frequently use strategically placed folds and pleats to add in-terest to garments and other cloth objects to increase their visual appeal. Pleatsand folds are typically formed by gathering fabric along a seamline and stitchingthe gathered fabric to hold it in place. In both traditional garment design softwareand manual workflows, these features are incorporated into an existing design byfirst skillfully modifying the underlying 2D patterns, and then draping the garmentatop a mannequin or a dress form by meticulously positioning it to achieve thedesired fold look. This workflow requires expertise and time, since it often takesmultiple trial and error iterations to successfully incorporate the envisioned foldsor pleats into an existing design [1, 16]. We propose FoldSketch, a new algorithmicframework for fold and pleat generation that enables users to directly generate theirdesired fold-enhanced 3D garments without the need for manual pattern editing ordraping (Figure 1.1). Our output garments are physically reproducible - they canbe generated using physical simulation from a set of patterns and an initial drapewe compute. Our method applies to the design of both virtual and real cloth ob-jects, and enables experts and amateurs alike to quickly generate sophisticated foldand pleat configurations.Garment design literature distinguishes between folds and pleats based on howthey are formed (Figure 1.2). While folds are formed by uniformly gathering fabricalong a seam or a hemline, pleats are formed by doubling fabric back on itself andsecuring it in place. We will use the term folds in this paper to describe both folds1Figure 1.1: Complex physically simulated fabric folds generated usingFoldSketch: Plain input flag with user sketched schematic folds (a),original (green) and modified final (red) patterns (b); final post-simulation flag augmented with user-expected folds (c); real-life replicamanufactured using the produced patterns (d); zooming in highlightsthe complex and evolving output fold profile shapes (e).and pleats, for simplicity’s sake, and we will only refer to pleats when addressingpleat specific processing.Real-life folds have complex and smoothly changing cross-section geometry(Figure 1.1) that depends on a range of physical factors such as fabric stretchiness,thickness, and bending flexibility (Figure 2.1). While designers have an overall2Figure 1.2: Different types of folds and pleats supported by our framework:(top) schematic user sketch; (bottom) output folds.sense of how the folds they envision will look, they do not mentally account forall these factors. It is therefore unreasonable to expect designers to communicatean exact, detailed description of the folds they envision. Instead, using FoldS-ketch, designers schematically provide their anticipated fold configuration, namelytheir paths, magnitudes, and stitching patterns (Figures 1.1a, 1.2). Our underly-ing algorithm then generates a detailed fold-augmented garment consistent withthis schematic input, and a set of corresponding 2D patterns and initial drape thatreproduce this garment under physical simulation (Figure 1.1d).Translating the user’s input into detailed folds is a challenging task. Fold ge-ometry is highly dependent on physical factors such as fabric properties and ex-ternal forces, thus it is impossible to predict physically achievable fold shapeswithout a physical simulation context. At the same time, applying a physical sim-ulation to generate a fold-enhanced garment requires correctly extended patternscapable of supporting the desired folds and an initial drape configuration, neitherof which is available. Previous frameworks that attempted to generate garmentfolds in 3D space used highly simplified, groove-like fold shapes [32, 28, 27, 33]3(Figure 2.2,a) which do not reflect the complexity of real-life folds. More impor-tantly, the grooves they create are purely geometric and have no basis in real-worldphysics; they are not physically realizable, and any attempt to resimulate these ge-ometric folds using state-of-the-art physics-aware pattern computation [3] is likelyto fail ((Figure 2.2,b).Instead, we focus on computing patterns and the initial target drape, and obtainthe output garment geometry via actual simulation that uses these as input. Ourcomputation employs two key observations. First, we note that while we have noexact 3D fold geometry to begin with, we can use the designer-specified schematicinput to estimate the changes in 2D patterns necessary to accommodate their in-tended folds. We also observe that while we do not a priori know the shapeof the final fold-augmented garment, we can distinguish between changes to the3D garment which are consistent with the designer’s intended fold formation, andthose which are not: when editing existing garments, designers attempt to intro-duce the modifications they envision locally while maintaining the garment shapeelsewhere [3, 1]. In the context of fold generation, designers expect to see no gar-ment geometry changes in areas away from the folds, while in the region of interestnear the folds, they expect the fabric to bend along the specified fold direction.We use these two observations to compute the target drape and patterns, anduse those to obtain the output garment. Starting with an input simulated garment,its corresponding patterns, and a schematic indicating the user’s desired fold place-ment, we compute an initial new set of 2D patterns which have sufficient materialto incorporate these folds (Chapter 5). These new patterns are optimized by ex-tending the original patterns orthogonally to the fold paths to facilitate fold for-mation, while minimizing any secondary changes in pattern shape away from theuser specified folds. We use the new patterns to obtain a target 3D drape that bal-ances physical reproducibility and designer intent; this is achieved by using a sim-ulation framework which augments standard physical forces that reflect real-lifephenomena with new synthetic forces that reflect our style preservation and foldalignment constraints (Chapter 6). While the resulting drape conforms to designerexpectations, using it as starting point for simulation without these synthetic forcesmay produce undesirable artifacts in the output garment, such as local saggingand bulging that violates our expectation of style preservation (Figure 2.3). We4minimize these artifacts by progressively updating both the patterns and the targetdrape, reducing the difference between augmented and unconstrained simulationoutputs (Chapter 7).We demonstrate our method’s capabilities by applying a range of diverse foldand pleat patterns to different input garments and other cloth-made objects withvarying material properties. In all cases, the resimulated outputs reflect the de-signer’s intended fold configurations while preserving the original style of the in-put, and are accompanied by corresponding 2D patterns. Our framework is notspecific to a particular simulation engine; it works equally well with two distinctlydifferent simulation engines: Sensitive Couture [34] and ARCSim [21, 22], oneof which is optimized for speed while the other is optimized for accuracy (Fig-ures 8.2, 8.4). We validate our approach via expert critique, and by comparisons toalternative solutions. Finally, we generate two real cloth objects using the patternsproduced by our system, confirming its applicability to real-life fashion design(Figures 1.1, 8.1).Our overall contribution is a novel framework that allows expert and amateurfashion designers to enhance existing cloth-made objects with complex fold andpleat patterns via a simple to use interface that successfully replaces the currentlyused cumbersome, and time consuming, iterative workflow for adding folds to gar-ments. Key to our method are the pattern extension and target drape computationprocedures that incorporate cues provided by physical simulation into the geometryoptimization process.5Chapter 2Related WorkOur work builds upon traditional fashion design methodologies for fold creation,algorithms for fold generation, and modern computational fashion design tools.2.1 Garment Construction and Traditional Fold DesignGarments and other cloth objects are traditionally constructed by first cutting 2Dfabric panels following a given pattern and stitching these panels together alongshared seams. To incorporate folds into an existing design, tailors add additionalmaterial to panels along a hemline (open boundary) or a seam. While hemlinefolds form due to gravity, seam folds are formed by gathering the excess materialto match a shorter opposite panel boundary and stitching the two. Pleats are addedby folding the material sideways and stitching it in place (Figure 1.2); commonlypleats are then ironed to keep them in position.Designers employ a mixture of 2D and 3D fabric manipulation to form their de-sired fold arrangements [1, 16]. They typically start with approximate 2D patterns,then drape them around a mannequin, using pins to gather and hold the desiredfold configuration in place. Designers then trim the patterns, eliminating redun-dant material, or alternatively repeat the cycle with wider initial patterns when theoriginal are insufficient to achieve the desired fold magnitude. They subsequentlyadjust and repin the drape, and iterate. Successful fold design requires significanttime and skill; design courses and tutorials dedicate multiple lectures and chapters6Figure 2.1: Given the same schematic fold notations and visually identicalinput garments with different fabric properties (a) our framework pro-duces reproducible fold-augmented garments (b,c) that reflect the dif-ferent bending parameters of the inputs and the corresponding sets ofpatterns (d) - red for the thicker fabric (b) and blue for the thinner one(c).to fold design techniques [16].Commercial garment design software, such as [8, 7, 14, 13, 35], employs a 2D-to-3D design framework where users manually specify both 2D pattern geometryand an initial draping configuration. These systems then use physics-based simula-tion to generate the resulting 3D garment shapes. To add folds to a garment usingsuch systems users need to employ the knowledge intensive and time consumingworkflow described above - they need to manually edit the patterns, specify theinitial drape, and then use the simulation output to iterate on both.2.2 Computational Garment DesignRecent algorithms enable procedural modeling of static virtual garments that havethe appearance of clothing [36, 32, 12, 33, 27, 19, 11, 17].Some of these methods use sketching interfaces to produce low frequency gar-ments [36, 32, 12, 33, 27, 11]. Specifically, Wang et al. [36] propose a feature-based garment modeling method that can enable users to draw 2D sketches in 3D,using the extracted mannequin features to specify garment profiles and patterns.Tuiquin et al. [32, 33] use fine sketch inputs within multiple types of strokes, lead-ing to a more accurate modeling of garment profiles. Decaudin et al. [12] further7Figure 2.2: Existing fold modeling methods (here [28]) generate simplisticfold shapes (a); which cannot be reproduced via subsequent patterncomputation and resimulation (b); given similar input fold-paths (c) wecompute complex reproducible folds (d).enhance this sketching interface by enabling the user to draw seam-lines and darts.Moreover, to interpret sketches more consistently over different views, Robson etal. [27] incorporate context-aware considerations based on key factors that affectthe shape of garments. In addition, DePaoli et al. [11] propose a sketch-basedmodeling system to create structures that are comprised of layered and shape in-terdependent 3D volumes. This method potentially inspires the emergence of toolsfor multi-layered garment creation.Others support mixing of existing garment elements in 3D space [19, 17]. Forinstance, Li et al. [19] model new garments on individual human models by com-positing 3D parts from garment examples. In the meanwhile, Kwok et al. [17]generate new and reasonable styling designs from existing garments based on evo-lution theory. The garments produced by them have no physics aware patterns,no physical parameters, and are often not physically reproducible; they are thusunsuitable for cloth simulation or manufacturing.Grading methods algorithmically resize garments to fit a mannequin differentfrom the one they were originally designed for [9, 37, 6]. Cordier et al. [9] andWang et al. [37] resize the garment based on element correspondence betweengarment and mannequin. Brouet et al. [6] also explicitly define style measurementof shape, fit, and proportion to be preserved during grading. These methods can8Figure 2.3: FoldSketch Algorithm: (left to right) The input consists of a gar-ment pattern, a corresponding drape on a mannequin, and designer-sketched folds. Folds require additional fabric material, which is ob-tained by extending the pattern. Draping depends heavily on the initialdrape of the simulation; a poor initial drape does not lead to the de-sired fold arrangement. We add fictitious style constraining forces toinduce the fold arrangement, obtaining a target drape. We iterate, seek-ing an initial drape that yields a similar fold arrangement without fic-titious forces. Starting from the target drape, an unadulterated drapingsimulation produces a candidate output drape. The candidate is accept-able if we cannot improve upon it. We attempt to improve the garmentpattern to reduce differences between the target and output drapes. Ifwe make a substantial update to the pattern, we iterate, using our outputcandidate as the new initial drape.potentially transfer the location and 3D shape of existing folds to a new garment,but are not designed for forming new folds.Sensitive Couture [34] supports a limited set of 3D to 2D edits where simple 3Dchanges, such as elongating or widening a garment, are propagated to 2D space. Itdoes not provide the fine control necessary for detailed edits such as fold addition.Bartle et al. [2016] enable coarse scale 3D garment edits, such as garment mixing,length and fit changes. They use a geometric approach to produce a target 3Dshape encapsulating both the original design and user-specified changes, and thenreverse-engineer 2D patterns whose draped result is isometric to the target. Ourfocus on 3D fold design requires a target shape computation that, as opposed tobeing purely geometric, is closely linked to garment material’s constitutive laws(Figure 2.1) and external forces.92.3 Fold and Wrinkle ModelingComputer animation frameworks produce dynamic folds whose location and shapeare determined by the physical forces rather than the user [5]. The computationthey employ relies on input patterns and draped geometry to guide fold formation.In our setting we have neither. Sketch-based static garment modeling tools such as[33, 27] model folds by sweeping a cylindrical profile along a user sketched path.Turquin et al. [33] directly move the garment mesh vertices away or close to themannequin according to user specified fold orientation, depth, width and locationwith their fold-sketching UI. In contrast, Robson et al. [27] model the profile byrotating the nearby triangles along the path and re-solve for surface normals of thegarment.Cylindrical arc profiles, smoothly blended with the surrounding surface, aresimilarly used to procedurally model dynamic folds to augment low-quality ani-mations [24, 28]. In [24], folds are added to enhance details for garment animationcapturing techinques, where the fold locations are computed from the frames. Incontrast, the input in [28] is an existing garment animation, of which the stretchtensors are used to guide fold formation. Both methods ensure temporal coherencewith a space-time approach allowing for smooth and natural wrinkle behavior.However, real-life folds have complex profile shapes that can significantly dif-fer at different points along the path; thus the results produced by such methodsprovide only a coarse unrealistic-looking approximation (Figure 2.2a). Even withBendSketch [18] that translates user input into actual surface detail geometry, itis still hard for users to draw fold profiles that are physically reliable. More im-portantly, fold-enhanced garments generated using these approaches have no cor-responding patterns, and often are not physically reproducible. Figure 2.2b showsthe result of attempting to reproduce the geometry in Figure 2.2a by computingphysics-aware patterns [3] that match this geometry and using those patterns andthe fold-enhanced geometry as input to an actual simulator. Our framework suc-cessfully generates complex reproducible fold geometries and their correspondingpatterns using sketched paths as guidance (Figure 2.2,cd).10Chapter 3Algorithm3.1 Problem StatementThe input to our algorithm is a simulated 3D garment, draped around a charac-ter or mannequin, and its corresponding set of 2D patterns (Figure 2.3,a). UsingFoldSketch, designers specify their desired fold configuration by sketching on topof this input. They draw path strokes (Figure 1.2, blue) to indicate the directionand length of their desired folds, and schematic gathering strokes (Figure 1.2, red),whose label indicates the type of fold they want to form (e.g. ”knife pleats” or”gathered folds”) and whose geometry encodes fold properties such as the patternboundary location where new material should be added, the stitching scheme, andthe amount of extra material that should be added (Chapter 4, Figure 1.2). Giventhis input, our goal is to generate a new garment that has both the desired foldgeometry within the region of interest surrounding the input strokes and the inputgarment geometry away from the strokes, and to produce a corresponding set of2D patterns (Figure 2.3,d).3.2 Solution FrameworkWe approach this problem using an alternating 2D-3D process, inspired by tra-ditional garment design practices (Figure 2.3). We first create an initial set ofextended patterns. We then create an initial, synthetic, target drape that utilizes11Figure 3.1: Input garment and strokes (a) and unconstrained simulation out-puts produced using different initial drapes: (b) from flat panels; (c)from initial 3D garment (augmented with pleat sewing scheme); (d)from our initial 3D target drape. (e) Final result (using iteratively up-dated patterns and target drape). The horizontal lines highlight the gar-ment proportions.these patterns and conforms to designer expectations. We use the patterns and thisdrape as input to a standard simulator to obtain a reproducible output, which mayor may not align with designer expectations. We optimize output alignment withdesigner expectations by alternatingly refining the patterns and the target drape,and generate the final output (Figure 2.3, right) by performing one more round ofunconstrained simulation using those.3.3 Pattern ExtensionAdding folds to an existing garment requires extending the patterns in the region ofinterest, in the direction orthogonal to the fold paths direction, to allow for buck-ling. We compute the extension direction and the amount of extension necessary toaccommodate the user anticipated fold magnitudes for each triangle contained inthe region of interest. We extend the input patterns by scaling these triangles us-ing the specified directions and scaling factors, while retaining triangle shape andscale everywhere else (Chapter 5, Figure 2.3,b). In our pattern extension computa-tion, we explicitly account for sewing and pattern making constraints. We enforceseam compatibility, ensuring that shared boundaries between panels that had thesame length in the original garment retain this property after extension. We alsominimize changes in pattern boundary shape in order to prevent high curvature12oscillations, which complicate pattern cutting and sewing.3.4 3D Target Drape EstimationFoldSketch’s desired output is a 3D garment that is physically reproducible froman input set of patterns, and which conforms to the designer’s expectations as ex-pressed in the sketched input. The shape of a fold-enhanced garment is highlydependent on an initial drape (Figure 3.1), as loose fabric can be easily arranged tohave different forms. One of our core challenges is to obtain a suitable initial drapethat, when combined with the patterns, will produce the desired simulation output.We would like a drape that reflects designer expectations and is also close to thefinal output, in order to minimize the changes induced by the simulation. We gen-erate a target drape geometry that balances these two considerations by employinga constrained garment simulation. We augment the standard physical forces withsynthetic forces that serve two roles: they explicitly enforce designer expectationsof preserving input garment geometry outside the region of interest, and of purelyfold-aligned buckling inside it (Figure 2.3c, Chapter 6). We initialize this simula-tion using the extended patterns and an initial 3D garment drape which is based onthe original garment geometry, but which adds the additional synthetic constraintsthat are necessary to form the designer’s envisioned folds (Chapter 6.2).3.5 2D-3D UpdateUsing the obtained estimated patterns and drape as inputs to a simulation is unlikelyto produce a garment that fully aligns with designer expectations. We optimize theresulting garment using an alternating 2D-3D process that updates the patterns andthe drape (Chapter 7). The output of this final stage consists of a set of patterns,an initial drape, and a final output garment produced via simulation that uses thepatterns and the drape as input.13Chapter 4Sketch InterfaceFigure 4.1: UI walkthrough example: (a) fold path strokes (blue) traced overinput garment in 3D view; (b) gathering stroke; (c) output garment.This chapter illustrates FoldSketch’s UI with a worked example. Starting witha draped garment on a mannequin (Figure 4.1, a) a designer adds one or more pathstrokes (blue); the path strokes describe the locations, length and direction of thefolds that they wish to add. As explained earlier designers typically form folds byelongating one or more garment panel boundaries. While the choice of the bound-ary can be deduced from the path strokes end-points, designers need the means todefine the stitching pattern and the expected amount of boundary elongation. Thedesigner provides this information by specifying a fold type via a dropdown button,and adding a gathering stroke (Figure 4.1, b) atop of the corresponding boundary.14This stroke indicates the amount of extra material that must be incorporated intothe folds; in this case, uniformly gathered folds is to be added. The system thensynthesizes a new garment (Figure 4.1, c)), incorporating the designer’s desiredfolds. The designer may then add other folds as desired, or revert their folds andexperiment with new designs.The reason for sketching the gathering configuration and not the fold profile(cross-section) elsewhere along the fold paths is that designers know the gatheringconfiguration they want to use; while the fold cross-section varies in shape basedon fabric physics. This interface enables naturally employing schematic input toaugment garments with different fabric properties.The design tool provides four types of folds (Figure 1.2): hemline folds, uni-formly gathered folds, pinched pleats, and knife pleats. In all cases, the processis the same: the designer chooses a fold type, draws multiple path strokes whichdefine the direction and length of the folds, and concludes with a single gather-ing stroke which defines the amount of boundary elongation. The amount of extramaterial needed to form the folds is then computed by comparing the length ofthis stroke to the portion of the corresponding, gathering, boundary in-between thestroke end-points. To form pleats, fabric needs to be folded onto itself and theoverlapping portions need to be stitched together. We use the sharp corners in thegathering stroke to dictate the location and magnitude of the pleats (See Figure 4.2,e and f). For knife pleats, the user can also choose between right or left foldovers(See Figure 4.2, f). Designers can specify folds that extend between two gather-ing boundaries (Figure 2.2). To communicate their intent rather than drawing twogathering strokes, they simply need to draw path strokes that start and end at twoboundaries, and provide a gathering stroke on one of these boundaries. We inter-pret such strokes as two-sided and mirror the gathering pattern along the gatheringboundary onto its opposite boundary.For hemline and uniformly gathered folds the frequency and magnitude of theformed folds directly depend on the properties of the fabric used [28]. Thereforedesigners are only expected to encode the amount of the extra material, ratherthan the fold magnitude, when drawing the gathering stroke, and to use the pathstrokes to dictate fold direction rather than frequency or locations. In contrast, forpleats we use the stroke geometry to dictate the fabric folding and stitching pattern,15Figure 4.2: Impact of different gathering strokes on output folds: (a,b) hem-line folds with different magnitude, (c,d) gathered folds with differentmagnitude, (e) pinched pleats with different width (left and right shoul-ders), (f) knife pleats with different orientation (left and right panels).16determining their location, magnitude, and orientation (Figure 4.2).In many of the cases, the input garment contains pairs of symmetric patterns,which enables users to design symmetric folds. To support convenient symmetricfold design, FoldSketch can reflect the user strokes from one pattern to its symmet-ric pattern (e.g. all examples in Figure 4.2). This also proves that our system canhandle fold enhancement on multiple patterns simultaneously, while in this the-sis with the prototyping FoldSketch, all examples with folds designed on multiplepatterns (except symmetric designs) are enhanced successively (e.g. Figure 1.1,Figure 8.1, Figure 8.2a, Figure 8.3a).17Chapter 5Pattern ExtensionAfter the designer has marked up their desired changes in FoldSketch, we estimatethe shape of new garment patterns that are appropriately extended to allow thedesigner’s target folds to form. We have as inputs the garment patterns, drapedon the mannequin; the extended gathering seam length, computed from the userannotation; and the designer specified fold paths.We observe that, in order to facilitate the desired behavior, our extended pat-terns have to satisfy the following conditions. Inside the folds’ region of influencewe expect each triangle to be elongated orthogonally to the fold paths directionto facilitate subsequent buckling. We expect the elongation to be maximal next tothe gathering seam, and to smoothly decrease further away from it; we also expectthese triangles to retain their original length along the direction of the fold paths.Conversely, we expect pattern triangles away from the folds to retain their originalshape and size. To avoid sewing artifacts, we must pay special attention to panelboundaries: we need to strictly preserve the lengths of all panel boundaries exceptthe gathering seam. We also need to avoid high curvature oscillations along them,as those make sewing and cutting panels more challenging.We solve for our initial extended patterns using a two step process. We firstcompute the direction and amount of extension for each garment pattern triangle(Section 5.1). We then deform the existing 2D patterns to incorporate this desiredexpansion (Section 5.2).18Figure 5.1: Pattern extension: (a) input garment and strokes; (b) visualized3D space scaling field; (c) scaling field on 2D patterns; (d) extendedpatterns (blue) and input patterns (green).5.1 Tensor Field ComputationWe use stretch tensor field to represent the target expansion of patterns, thus we areessentially solving a sketch based tensor field design problem [38, 31]. In comput-ing the field we face a chicken-and-egg problem, where we must know the folds’region of influence in order to compute where scale should be preserved, while atthe same time we cannot determine the exact boundaries of this region of influ-ence without knowing the amount of scaling required to accommodate the folds.We compute expansion directions first and use them to compute preliminary regionof influence boundaries; we then use this set of boundaries to compute expansionmagnitudes and finalize the region of influence.We compute target pattern expansion directions and magnitudes in 3D spacefirst as this is where the user input is provided. We then project them to the actualpatterns accounting for the deformation these patterns undergo during the garmentsimulation. To define our tensor we use a 2-Rotational Symmetry tensor field [38],as stretch should be invariant under 180◦ rotation. We express each tensor T ti asa 2x2 matrix using the singular value decomposition T ti = R(θi)SiR(θi)T , whereR(θi) =[cos(θi) −sin(θi)sin(θi) cos(θi)]is a rotation matrix, and Si is the diagonal skew ma-trix Si =[si 00 1], where si ≥ 1. Both T ti and θi are defined on the 2D local frameof triangle i. This allows us to decompose the problem of finding the tensor fieldinto separately finding the per-triangle expansion directions θi and the per-triangle19expansion amounts si, facilitating the two stage region-of-influence computation.Figure 5.2: ei,k is the k-th edge of ti, qi is the vector defined in the local frameof ti, the discrete Levi-Civita connection is defined as ri j = βi−β j5.1.1 Computation of 3D Expansion DirectionFor computing the expansion directions θ of the tensor field, we follow the frame-work and nomenclature of Ray et al. [2009]. Rather than computing directionalangles θi, we employ their method and instead compute the representative vectorsVi = (cos(2 ·θi),sin(2 ·θi)), and extract θi from them. To compute Vi, we minimizean energy function that balances smoothness of the tensor directions against therequirements for these tensors to be orthogonal to the fold paths:E = Esmooth+EfitEsmooth = ∑i j∈E ∗w−1i j (Vi−R(2ri j)Vj)2Efit = (1/|ti|)∑i|ti|(Vi−V initi )2 (5.1)where E ∗ is the set of all adjacent triangle pairs.The term Efit is evaluated over all triangles i crossed by fold paths. Here wi j arethe standard cotangent weights [23]; ri j ∈ R is the discrete Levi-Civita connection[10], which is necessary as θi and θ j exist in different local tangent spaces; V initi20is the orthogonal direction of the path strokes on the triangle i; |ti| is the area oftriangle i; and |ti| is the average triangle area. Since Vi must be unit length, we usean iterative minimization: we first minimize Esmooth +Efit without normalizationconstraints, then normalize the computed Vi and proceed to iterate renormalizingthem after every iteration. We then compute θi = atan(Vi · (0,1)/Vi · (1,0))/2.This iterative renormalization could robustly achieve acceptable accuracy with justa few more iterations compared to directly enforcing the nonlinear constraints.One may consider directly taking the angles as optimization variable like in[25] or [10]. However, it turns out that [26] is most suitable for our settings sincein [25], an iterative framework is still needed for handling integer variables in theangles for invariance under 180◦, and in [10], 2-RoSy fields need to be handled byspecifying singularities with fractional indices while in our case the singularitiesmight be outside the garment surface and we really want it to be handled automat-ically.5.1.2 Preliminary Region of InfluenceWe use the computed directions to extract an approximate set of boundaries forthe folds’ region of influence. We trace the approximate boundaries by startingfrom the end points of the gathering seam, and following the direction orthogonalto our computed extension direction. Tracing terminates when the boundary ofthe current pattern is reached. We use the Runge-Kutta method [2] to performthe tracing. Specifically, we are solving an initial value problem of the ordinarydifferential equationdbpdt= f (bp(t)), bp(0) = pe,i, where bp is the boundary to be traced, t is the integration parameter, f is the vectorfield orthogonal to the extension directions θ , and pe,i is the i-th end point of thegathering seam. Starting from each pe,i, we applied the midpoint RK2 scheme toevaluatebp(tn+1)← bp(tn)+∆t f (bp(tn)+0.5∆t f (bp(tn)))in each step n.215.1.3 Computation of Expansion MagnitudesTo obtain the expansion magnitudes si, we compute a smoothly varying scalar fieldthat propagates the anticipated expansion along the fold paths throughout the trian-gles in the region of influence on the 3D garment mesh. Our formulation accountsfor four considerations: magnitude smoothness, accommodation of the anticipatedscaling along fold paths, preservation of original scale outside the region of influ-ence, and preservation of the lengths of all pattern boundaries except the gatheringseam:minsE = ∑i j∈E ∗w−1i j (si− s j)2︸ ︷︷ ︸Smoothness+ λlE len︸ ︷︷ ︸Boundary length preservation+ λvEFL︸ ︷︷ ︸Fold path scaling+ λv/|ti|∑i∈B|ti|(si−1.0)2︸ ︷︷ ︸Scale preservation outside region of interest(5.2)We empirically set λl = 100, λv = 10.Fold-Driven Scaling To scale garment material around fold paths, we first smoothlyinterpolate the scale terms si along each fold path. We use the ratio between thelengths of the gathering stroke and its corresponding pattern boundary segment asthe scale at the start of the path, and set the value to 1 at the end of the path furthestfrom the gathering boundary. We then constrain the scales within triangles inter-secting the fold path to scale by the average scale factor s′i along the intersectedfold path segment:EFL = 1/|ti| ∑i∈F|ti|(si− s′i)2 (5.3)whereF contains triangles intersecting fold paths.Pattern Boundary Length Preservation. We seek to strictly preserve the lengthsof non gathering seam panel boundaries. We can explicitly express triangle edgelength as a function of the stretch si in a given direction:22li(si) = l′i√s2i cos2αi+ sin2αi. (5.4)Here l′i and li are the lengths of the boundary edge before and after expansion, andαi is the angle between the stretch direction and the boundary edge. This functionis non linear and thus hard to optimize; we therefore linearly approximate Eq.5.4around si = 1 instead:lai (si) = l′i +(∂ li∂ st)st=1(si−1) (5.5)We express boundary length preservation as:E lenj = 1/l¯′i ∑i∈E ( j)(lai (si)− l′i)2 (5.6)Here l′i is the average boundary edge length, and E ( j) are the participating bound-ary edges. This expression is equivalent to enforcing the constraint that si = 1.0,i ∈ E ( j) weighted by l′i cos2αi. Note that if the extension direction is orthogonalto the edge segment, this constraint vanishes as desired.Linear Solver. Since both optimizations formulated for solving direction field andscalar field are linear optimization, the optimum is found by solving the linearsystem that enforces the energy gradient to be equal to 0 using Sparse Choleskyimplementation in the Eigen library [15] as the coefficient matrix is symmetricpositive-definite.Final Region of Influence. At this point, we can now trivially define the finalregion of influence: a triangle ti is contained in the region of influence if its scalarcomponent si ≥ 1.0+ ε .5.1.4 Tensor Field Projection onto 2D PatternsTo actually expand the patterns, we must transfer the expansion tensor field, com-puted on and expressed with respect to the 3D draped input garment, onto the setof 2D patterns. Since fabric often stretches under simulation this stretch must be23factored into our computations: failing to account for stretch incurred by the drap-ing process would cause a naive algorithm to assume sufficient material alreadyexists to form folds, and hence the amount of required 2D pattern extension maybe underestimated (Figure 5.3). We employ a transformation scaling approach tocorrectly account for stretch during 2D pattern extension.Recall that we have constructed the per-triangle symmetric tensors T ti withR(θi)SiR(θi)T , which specify how much each triangle must expand and in whatdirection. However, this deformation is computed with respect to the simulated3D garment. To obtain the corresponding change for garment patterns, we needto compute a transformation for each of the 2D pattern triangles ti that, after sim-ulation, will extend their corresponding 3D triangle t ′i in the direction and by theamount specified by the tensor field. We first compute a common coordinate framefor the 2D pattern and 3D garment triangles by rotating them to the xy plane andco-aligning them, so that both triangles are placed at the origin and have a desig-nated common edge u that is aligned with the x-axis. We refer to the transformedreplica of the triangle t ′ as t˜. The 2D intrinsic action of the garment simulation pertriangle is then described by the 2× 2 matrix T d0, t˜i = T d0ti. Assuming the im-pact of the simulation on the deformed triangle is the same as on the undeformedone, we must find a transformation T ′i such that Tti t˜i = Tti Td0ti = T d0T ′i ti. We canconsequently compute T ′i asT ′i = (Td0)−1T ti Td0 (5.7)Fold Pre-Conditions. In order for the designer’s specified folds to form, we musttake into account that the original simulation may have stretched the fabric whendraping it on the mannequin, and that this stretch is not explicitly accounted forin the computation of the per-triangle stretch tensors T ti . If the extension that wehave computed is of similar or smaller magnitude to the stretch of the draped gar-ment, then adding the amount of material specified by T ′i to the garment patternis sufficient to release the stretched fabric, but may not be sufficient to form folds(Figure 5.3 top).To actually add visible folds, the extension needs to be increasedto fully cancel out the stretch and to locally extend the 3D garment to reflect the24Figure 5.3: Impact of fold pre-conditions: (top) result without and with or-thogonal stretch cancellation; (bottom) result without and with fold pathstretching. Note the impact on fold length and shape.designer’s expected fold magnitude.In addition to accounting for stretch orthogonal to the fold direction in theoriginal drape, we also consider fold feasibility. While vertical folds are consistentwith gravity, horizontal and near-horizontal folds can only form if the fabric iseither very stiff or is stretched along the fold path (Figure 5.3 bottom). If theuser placed folds are on a loose part of the garment, there is no way to guaranteethat they show up without major changes to the garment style. However if thegarment is locally tightly fitting, we can improve fold feasibility by ensuring thatthe garment is, at least, weakly stretched along the fold direction.We therefore account for draped garment stretching and fold feasibility by si-multaneously canceling the stretch in the original deformation gradient of the drap-ing on the left-hand side of Eq.5.7 to approximate the deformation gradient whendraping the new patterns, and weakly shrinking each input triangle ti when T d0i hasno stretch along the fold path:(T si )−1T d0i T0i = Tti Td0i (5.8)25Here T si =R(θi)[max(1,T d0,Ri,(2,2)) 00 k]R(θi)T is the tensor with the part of stretchand compression to be cancelled in T d0i , where k = 1 if Td0,Ri,(1,1) >10.95 and k =0.95 ·T d0,Ri,(1,1) otherwise, and T d0,Ri = R(θi)T T d0i R(θi). The final transformation T 0iis then:T 0i = (Td0i )−1T si Tti Td0iAlthough obtaining the 2D tensor field by first projecting the strokes onto 2Dpatterns and then solve for the fields in 2D would be less complicated, the mecha-nism described in this section is more in demand. Since cloth simulation is a non-linear process, the 2D to 3D map T d0i is also nonlinear: computing T0i by smoothlyaveraging directions in 3D and projecting them to 2D is not equivalent to smoothlyaveraging in 2D. What’s more, only solving in 2D space will make it hard to do foldpre-conditions because there would be no access to direct manipulation of tensorsin design space - the tangent space of 3D garment surface.5.2 Pattern DeformationThe collection of transformations T 0 describes the intrinsic change that each tri-angle on the input 2D pattern P0 is expected to undergo. These can be applied tothe patterns using standard local-global deformation approaches [29, 20]. How-ever, as previously mentioned, the shape of the resulting pattern boundaries affectsboth cutting and sewing - more curved boundaries, especially those with high cur-vature variation are harder to process. We thus augment our formulation with aboundary-shape preserving term, and minimize:∑i∈T‖Si−RiT 0i S′i‖2F .+λb ∑j∈BEboundaryjHere Ri is a per-triangle rotation matrix; Si = [vi,1− vi,0,vi,2− vi,0] ∈ R2×2 is thelocal coordinate frame of the deformed triangles, and S′i ∈ R2×2 is the local co-ordinate frame of the original triangles. Eboundaryj encodes boundary shape. Weempirically set λb = 10. We minimize this energy using a standard local-globalapproach [29], where Ri is optimized in local step using singular value decompo-26sition, and Si is optimized in global step by solving a symmetric positive-definitelinear system using the Sparse Cholesky implementation in the Eigen library [15].Boundary Shape Preservation. When preserving boundary shape, we differenti-ate between vertices that are located on straight boundary sections and those thatare located on curved boundary sections. Let e′j be the vector between the twooriginal vertices v′j and v′j−1 on a boundary; that is: e′j = v′j − v′j−1. We distin-guish between straight and curved vertices by thresholding | |e′j·e′j+1||e′j||e′j+1| − 1| with thethreshold set to 10−3. For each curved boundary vertex v′j we express its curvaturenormaln′j = (−e′j,y− e′j+1,y,e′j,x+ e′j+1,x)as a linear combination of e′j−1 and e′j+1:n′j = α je′j +α j+1e′j+1.We then defineEboundaryj = ‖n′j− (α je j +α j+1e j+1)‖2where e j = v j− v j−1 is the unknown variable.For straight boundaries, we use line Laplacian as the respective energy:Eboundaryj = ‖v j− (w j−1v j−1+(1−w j−1)v j+1)‖2where w j−1 = |e′j+1|/(|e′j|+ |e′j+1|).To avoid simulation artifacts due to poor triangulations, we remesh the obtained2D patterns Pe, and resample the tensor fields defined on them for later use.27Chapter 6Target Drape ComputationOur final goal is a garment which can be reproduced via an unconstrained simula-tion from a set of appropriate patterns and a suitable initial drape. However, drapinga garment to achieve a desired fold look often requires careful initial placement. AsFigure 3.1 demonstrates, simulation using the extended patterns alone and a rangeof standard initial drape configurations can result in unappealing outputs that do notconform to the expected garment look. We thus require a principled way to com-pute an initial drape that, under simulation, will produce the designer’s expectedoutput. Our drape computation is based on two observations that follow traditionalfold design practices. We note the shape of the output garment is more stronglycorrelated with the shape of the input drape if this drape itself is reproducible -that is, if the drape is, by itself, an output of a simulation using the current pat-terns. While we have no direct control on the shape of the output garment, wenote that we can indirectly control its shape by computing a new target drape thatis as close as possible to reproducible, but that also aligns with designer expecta-tions. We balance reproducibility and design preservation by computing the drapevia a constrained simulation that augments the cloth simulation energy with syn-thetic design preserving forces. We can use the resulting drape and current patternsas an input to an unconstrained simulation that computes a reproducible garment(Figure 3.1c). To improve this garment’s adherence to designer expectations, weupdate the patterns and recompute the drape (Chapter 7, 3.1d).We introduce synthetic design-preserving forces by augmenting the energy for-28mulation used by the cloth simulator of interest Ecloth with an additional designterm Edesign. We integrate the synthetic term into the formulation, augmenting theenergy gradients and Hessians, and optimizeEPAS = Ecloth+Edesignusing the standard time-stepping process. We tested our framework with SensitiveCouture [34] and ArcSim [22], as discussed in Chapter 8.6.1 Design Preservation EnergyOur design preserving energy consists of two terms, one applied within the regionof interest and one applied outside it. Outside the region of influence, we preservethe original garment shape by aligning every vertex to its positions on the original3D garment Go using spring forces:Eudesign =12ku∑i||vi− v′i||2Here ku is the stiffness coefficient of the energy, and vi and v′i are vertex coordinateson the target garment Gt and original garment Go respectively.Within the region of influence, we expect the garment shape to significantlychange compared to the original. We expect the fabric to bend while forming thedesired folds; we therefore anticipate changes in surface normals, as well as sometangential and normal vertex displacement. Consequently, the main phenomenonthat we seek to penalize is buckling or bending along an undesirable direction.This requirement can be cast as a restriction that any change in the normal shouldbe orthogonal to the path direction:E fdesign =12k f∑i||Ti−R ji T pi ||2F . (6.1)Here k f is the stiffness coefficient of the energy, Ti and Tpi are the local coordinateframes [30] of the corresponding triangles on the target garment Gt and the 2Dpatterns Pe, and Rji is a 3×3 rotation matrix recomputed at every simulation time29step j. We compute R ji as the product of the two matrices Roi Re, ji , where Roi isthe rotation extracted from the deformation gradient of the original garment T oiusing singular value decomposition, and Re, ji is the projection of the transformationbetween the original and current time step drapes to the valid space of rotationsaround the fold line direction. We compute Re, ji at each simulator time step asfollows. We first project the current triangle normal n ji in simulation step j onto theplane orthogonal to the fold path to obtain np, ji =n ji−( fi·n ji ) fi|n ji−( fi·n ji ) fi|, where fi is the pathdirection on triangle i. Then we compute the angle θ e, ji = acos(np, ji · noi ) betweennp, ji and the normal on the input garment noi . Re, ji is then given by the matrix thatrotates noi to np, ji around fi with θe, ji .In addition to undesired buckling, we seek to minimize tangental displacementsof garment boundaries with respect to the body within the region of interest. Thisconstraint is enforced implicitly for all seam between panels inside and outside theregion of influence. For hemlines, we enforce this constraint by augmenting theenergy with a term that penalizes tangential shifts:E fdesign =12k f∑i||Ti−R ji T pi ||2F +12ku∑j(((v j− v′j) · t0j )2+((v j− v′j) · t1j )2)Here j iterates over the hemline vertices inside the region of interest, and t0jand t1j are two orthogonal tangential vectors at vertex j.To incorporate this term into the cloth simulator, we apply damping to Eudesignand E fdesign that is similar to the one employed by the simulator when minimizingEcloth, and adjust the magnitudes ku and k f of the staging “forces” to bring them tothe same scale with the cloth forces. Chapter 8 provides the specific numbers usedfor the simulators we tested.6.2 Initial DrapeWhen running the augmented simulation for the first time, we need a suitable initialdrape that can accommodate our target folds. While the initial garment providesa reasonable starting point for most fold types, pleats require special processing.In particular, we want fabric to fold sharply along pleats, and we want the foldingorder along them to be preserved (Figure 1.2). To allow crisp pleats, we refine the30Figure 6.1: Top: crisp knife pleats; bottom: pinched pleats sewing.mesh along the expected pleat paths starting at the sharp corners of each pleat, andfollowing the fold-path directions (see Figure 6.1, top). We introduce the correctfolding order by stitching the pleat boundary segments in an in-to-out order, in-stead of all at once, starting from the layer closest to the mannequin. To furtherpenalize interpenetrations, we apply weak spring forces to pull the segments inthe outer layer along their normal direction away from the mannequin. This termhelps separate the layers, guiding the fabric towards the desired folding order thatwe want while simultaneously avoiding collisions. The stiffness of these springs isset to be proportional to the gap between the inner stitch pairs, so that they won’tpull the outer layered fabrics after the inner layer has been stitched. We emphasizepinched pleats by introducing short 2cm seams orthogonal to the gathering seam atthe pinching point (see Figure 6.1, bottom).31Figure 6.2: Pattern and garment update: (a) user input garment and strokes;(b) extended patterns (blue) superimposed on original (green) and initialtarget drape; (c) unconstrained simulation output using these patternsand drape; (d) updated patterns (purple) superimposed on extended ones(b,blue) and unconstrained simulation output using these new patternsand initial drape; (e) final patterns (red) superimposed on updated (pur-ple) and extended (blue) and final unconstrained drape.32Chapter 72D and 3D UpdateAt this stage in the process we have extended patterns and an initial drape thatwe can use to compute a simulated garment, via simple unconstrained simula-tion. While clearly reproducible, this garment may exhibit undesirable artifacts(Figure 6.2). We minimize such artifacts by using a two pronged approach thatmodifies our patterns and target drape. First, we modify the 2D patterns to con-struct new patterns that, under unconstrained sumulation, result in an output that iscloser to the initial drape. Second, if the result is not sufficiently close, we repeatthe constrained simulation with the new patterns generating a new drape, which wecan expect to be more physically reproducible. We then iterate until the two stepsconverge.7.1 Pattern UpdateWe first look for a new set of 2D patterns that, in an unconstrained simulator with-out synthetic forces, will produce an output garment as similar as possible to thetarget drape. We achieve this goal by following the pattern update framework ofBartle et al. [2016]. Specifically, we measure the intrinsic difference between thetarget drape and the current simulated garment and update the patterns in a mannerdesigned to minimize this difference; we repeat the simulation and update stepsuntil convergence. The output of this stage is a set of patterns and a new simulatedgarment.337.2 Garment UpdateThe obtained simulated garments are close to, but not necessarily identical to, thetarget drape generated using synthetic forces. In particular they may exhibit fine-level deviations such as secondary folds, local sagging, or bulging (Figure 6.2c).These artifacts are typically due to the fact that the constrained simulation resultis not fully physically reproducible, and has material held in place by the syn-thetic draping forces; without these synthetic forces, this material sags or slidesdue to gravity. We rectify this problem by computing a new target drape that ismore reproducible. We repeat the constrained simulation (Section 6.2) using thenew patterns and the simulated garment as the initial drape. The input to this con-strained simulation consists of a set of more accurate patterns, and an initial drape(simulated garment) that is both reproducible and better aligned with the syntheticdesign energy we use. We thus expect the resulting target drape to be much closerto the simulated one, and thus more reproducible. We repeat the pattern and targetdrape update steps until the simulated garment geometry no longer changes. Eachiteration simultaneously improves the physical feasibility of the target garment andthe visual similarity between the target and simulated garments by reducing unde-sirable artifacts on the latter.Figure 7.1: Left: average triangle area per pattern update iteration; right: per-centage of non-expanding triangles per pattern update iteration.347.3 ConvergenceWhile there is no theoretical guarantee that the final, unconstrained simulation out-put garment fully conforms to designer expectations, in our experience this is thecase for all inputs where the user specified folds can be feasibly achieved; see Fig-ure 9.1 for some examples where they cannot. In our experiments, five updateiterations were sufficient for convergence. While we similarly have no theoreticalguarantees of algorithm convergence, we note that, starting from the initial ex-tended patterns, each pattern update step we perform reduces the area of patterntriangles [3], and each constrained simulation reduces the difference between thetarget drape and the prior unconstrained simulation output. Consequently, one cansee our framework as an example of a fixed-point iteration scheme [4]. We vali-date our convergence claim empirically by measuring the evolution of areas of thetriangles on the patterns and the simulated garment, as well as the percentage ofpattern triangles that at each iteration either shrink or remain the same with withrespect to the previous iteration (see Figure 7.1). The graphs show consistent andconvergent shrinkage behavior consistent with that of a fixed-point scheme.35Chapter 8Results and ValidationWe used FoldSketch to generate the multiple examples showcased throughout thisthesis, created from a range of diverse initial garments including shirts, dresses,pants, shorts, and overalls. We also tested input on non-garment cloth objects,including a flag and a tissue box cover. The outputs contain the designer’s expectedfolds, and preserve the input look in regions away from the folds.The inputs we tested on are representative of a large spectrum of cloth ob-jects, including both tight fitting (e.g. the shirt in Figure 2.2, and the skirts inFigures 3.1, 4.1) and loose garments (e.g dresses in Figure 8.3). We showcase allfour types of folds handled by FoldSketch UI: hemline folds (e.g. Figures 1.1 and8.1), gathered folds (e.g. skirt in 2.1, and shirt in 2.2), knife pleats (e.g. short sidesof the tissue box in 8.1, and blue pants in Figure 8.2d), and pinched pleats (e.g.orange dress in 8.4 and yellow dress in 8.2). We showcase a range of fold-pathorientations including vertical (Figure 1.1, pants in 8.2), diagonal (skirt in Figure4.1, green T-shirt in Figure 8.2), and horizontal (e.g Figure 8.1, 6.2, and shirt inFigure 5.3).Our examples were generated using four material settings: thinner (e.g. purpleskirts in Figure 4.2, green dress in Figure 8.3) and thicker (e.g. yellow skirt inFigure 8.5, yellow and purple dresses in Figure 8.3) textiles in Sensitive Couture(SC) examples, SC material matching our real-world flag and cover, and the de-fault shirt material in ARCSim. Figure 2.1 and Figure 8.6 depicts application ofthe same schematic input to garments created from the same initial patterns, but36Figure 8.1: Manufactured example: (left to right) Plain input tissue box coverwith user sketched schematic folds and final post-simulation result aug-mented with user-expected folds; original (green) and modified final(red) patterns; real-life replica manufactured using the produced pat-terns, with zooming in highlights the complex and evolving output foldprofile shapes.37Figure 8.2: Additional results created using Sensitive Couture.38Figure 8.3: Folds created from designer annotations.with different materials. While the resulting folds are distinctly different, they stillclearly reflect designer intent if only the schematic input is reasonable for the cho-sen material supported by the simulator. The flag and tissue-box examples showprogressive application of multiple fold types and orientations to the same input.39Figure 8.4: Examples created using ARCSim.8.1 SimulatorsWe tested our method with two simulation engines, Sensitive Couture [34] andARCSim [22]. Sensitive Couture is optimized for speed over accuracy, whereasARCSim is optimized for precision at the expense of slower computation times.Results created with ARCSim are shown in Figure 8.4; the remainder of the resultsin the paper were generated using Sensitive Couture, which is faster and providessufficient accuracy for this thesis.Note that the sensitivity analysis in Sensitive Couture is not used here. Al-though it is developed for speeding up convergence, it does not help on convergingto design preserved garment. This also means that simulators are treated as com-plete black box in FoldSketch, except for augmenting the style-preserving energy.For ArcSim to support garment meshes composed of multiple connected com-ponents, the stitching scheme in Sensitive Couture is implemented into ArcSim.However, in order to avoid numerical instability, stitches are only defined per ver-tex of the shorter seam, which allows small holes between seams if the two sideshave very different lengths; this occurs when our system produces gathered folds.After simulation concludes, we postprocess these seams for rendering purposes bymoving vertices on the longer seam towards their corresponding positions on the40Figure 8.5: Comparison with deformation based pattern extension: (left) in-put, (center) garments simulated using deformation-based extended pat-terns, (right) Our results. The naive approach results in multiple arti-facts.Figure 8.6: Extreme material experiment: user input garment and strokes (a),final unconstrained drape with thinner textiles (b), stretchy knits (c), silk(d), and thick leather (e).41shorter seam.Using garment meshes composed of single connected component would re-quire non-manifold vertices and edges to support pleats, where the gathering seamsof uniform folds will also be non-trivial to resolve.8.2 Timing And ParametersThe input meshes range in size from 10K to 20K triangles. This number is consis-tent with those used in commercial garment design softwares such as MarvelousDesigner, and was chosen to provide a reasonable trade-off between speed andaccuracy. The runtimes using Sensitive Couture Simulator [34] range from 8 to20 minutes, with the vast majority of the time spent inside the simulation engine.For Sensitive Couture, we set ku = 0.08 and k f = 0.1 for Edesign, and apply damp-ing with coefficient 0.01. For ARCSim, we set ku = 2.0 and k f = 2.5 for Edesignwith damping coefficient 0.25. These design-preserving energy parameters remainconstant over all examples generated with a specific simulator. They are chosento match the energy scale of the simulators and set to provide enough force tomanipulate the garment shape and override other simulation elements. Differentsimulators have different scales for their cloth energies, which is why we must usedifferent values across simulators.All parameters in Chapter 5 stay the same across different inputs, materials,and simulators.To test our algorithm’s scalability, we subdivided the input mesh in Figure4.1, creating a new mesh with 54K triangles. Running this model throughout thesystem took significantly longer - 110 minutes total - but required the same numberof iterations to achieve the same error bound and converged to a visually similarresult.8.3 Algorithmic ChoicesWe consider three different alternatives to our algorithm, and show their failuremodes. Figure 2.2, left shows the effect of producing a 3D target garment usingpurely geometric folds created by folding circular grooves around the designerspecified strokes, and then using the physics-aware pattern computation of Bartle42et al [2016] to create the patterns. As this figure shows, the intended folds simplycollapse during subsequent simulation.We compare our pattern extension technique to one which scales patterns alongthe gathering seam and fold paths using standard ARAP deformation, where scalesfor along the gathering seam and paths are computed using the same process asmine (Section 5.1.3). As Figure 8.5 shows, the results generated by this approachfail to capture the designer folds while introducing additional unwanted folds andchanging the garment style.Finally, we show the effects of sidestepping the 3D target computation stageand using the initial extended patterns directly within a simulation engine (Figure3.1). As shown, simulating a new garment using the extended patterns and a rangeof standard initial drape configurations results in unappealing garments that do notcorrespond to the expected garment look. FoldSketch’s final combination of pat-terns and drape produces a garment that satisfies both the physical reproducibilityrequirement and design constraints with no unwanted artifacts (Figure 3.1e).8.4 Designer ValidationThree of the input fold designs (Figure 8.3) were traced by a professional designerwho found our tracing interface easy to use. He commented that the results were“exactly what I expected!”, and that “the software you are working on really deliv-ers” and would be very helpful for experts and amateurs alike.8.5 ManufacturingOne of my collaborators Mary Buckland manufactured two cloth objects using pat-terns generated by FoldSketch - a flag (Figure 1.1) and a tissue-box cover (Figure8.1). The resulting manufactured objects clearly contain the designer’s expectedfolds, and were manufactured directly from FoldSketch generated patterns withoutfurther modifications. To evaluate the efficiency of FoldSketch, we asked a pro-fessional designer to modify the initial patterns for the tissue-box cover to containour desired folds. The designer produced an initial set of extended patterns for afold-enhanced tissue box that would still require several stages of revision in orderto be acceptable; this first set of patterns took five hours to complete. The designer43was very impressed to note that our complete set of patterns was created in underhalf an hour, including both design and computation time.8.6 Perceptual ValidationMy collaborators and I validate the outputs of our method via feedback from tennon-experts. To collect their input, we presented them with a series of picturesof garments, consisting of an input garment with FoldSketch annotations, and twooutputs: one of which was generated by FoldSketch, and one of which was gen-erated by one of our design alternatives. We asked the question: ”Which of thegarments below “B” or “C” is more reflective of the user input “A” above?” Surveyparticipants selected our results as being more representative of the input annota-tions 95% of the time; please see Appendix A for more information.44Chapter 9ConclusionsThis thesis presented FoldSketch, the first framework that allows designers of bothvirtual and real garments to create physically reproducible folds and pleats via asimple 3D sketching interface, eliminating the need for tedious and unintuitive 2Dpattern manipulation. We demonstrate the applicability of our framework on a largerange of fold and pleat configurations, and confirmed its ability to operate in con-junction with different simulation engines. The key novel technical components ofFoldSketch are a 3D to 2D pattern extension algorithm that translates user sketchedschematic folds into per-triangle deformation gradients applied to the triangles ofthe original patterns, a constrained simulation framework that incorporates designconstraints into off-the shelf garment simulators, and an update mechanism thatenables the correction of secondary simulation artifacts. We believe our contribu-tions will open up a new avenue for researches trying to enable direct manipulationin 3D space for various design problems.9.1 Limitations and Future WorkFeasibility Detection. Our system follows user specifications in an effort to gen-erate the folds they desire. While we do pre-processing of the garments to betteraccommodate folds in tight-fitting regions (Section 5.1.4) we cannot guarantee thatfolds that require more significant pattern edits will be generated. For future work,it would be interesting to explore detection of infeasible inputs, something our45Figure 9.1: FoldSketch fails to detect infeasible inputs such as long horizon-tal fold-paths in loose garment regions (a), or highly curved independentfold-path that would need more stitches along the path, or special fabricsto support (b).current system does not do, and to provide feedback to the designer. This wouldbe particularly useful for amateur designers who have no sense of what folds arefeasible.Extending Achievable Design Space. Our system is designed for creating foldsachievable through changes in pattern shape alone. Future work on incorporatingtopological changes, such as the introduction of darts and gussets, can extend therange of achievable designs. Besides, supporting more sophisticated and flexiblestitching schemes to allow more control along the profile is another interestingfuture work.Material Modeling. Future work on material modeling, such as searching for aspace of reasonable material parameters for a specific design, or applying adaptivestitching to achieve consistent design across different materials would benefit morepractical applications.46Avoid Simulation in the Loop. In the 2D-3D Update stage, FoldSketch seeks forpatterns that best reproduce the target garment geometry under simulation via pat-tern adjustment which requires simulation in the loop, and the reproducibility of thetarget garment needs to be improved in between each pattern adjustment process.For future work, on the technical side, it would be interesting to search for boththe 2D patterns and 3D target/output garment in an optimization that directly min-imizes the net forces exerted on the garment. Without simulation in the loop, thecomputational cost could be significantly improved, and the direct manipulationson 3D garment could be more flexible on improving the physical reproducibility.47Bibliography[1] J. Arnold. Patterns of Fashion: The cut and construction of clothes for menand women c1560-1620. Macmillan, 1985. → pages 1, 4, 6[2] U. M. Ascher and C. Greif. A First Course on Numerical Methods. SIAM,2011. → pages 21[3] A. Bartle, A. Sheffer, V. G. Kim, D. M. Kaufman, N. Vining, andF. Berthouzoz. Physics-driven pattern adjustment for direct 3d garmentediting. ACM Trans. Graph., 35(4):50:1–50:11, 2016. ISSN 0730-0301. →pages 4, 9, 10, 33, 35, 43[4] D. P. Bertsekas. Nonlinear programming. Athena scientific Belmont, 1999.→ pages 35[5] R. Bridson, S. Marino, and R. Fedkiw. Simulation of clothing with folds andwrinkles. In Proc. Symposium on Computer Animation, pages 28–36, 2003.→ pages 10[6] R. Brouet, A. Sheffer, L. Boissieux, and M.-P. Cani. Design preservinggarment transfer. ACM Trans. Graph., 31(4):36:1–36:11, 2012. ISSN0730-0301. → pages 8[7] S. P. L. Browzwear. Browzwear, 2017. URL https://browzwear.com/. →pages 7[8] V. F. I. CLO. Marvelous designer, 2017. URLhttps://www.marvelousdesigner.com/. → pages 7[9] F. Cordier, H. Seo, and N. Magnenat-Thalmann. Made-to-measuretechnologies for an online clothing store. IEEE Computer graphics andapplications, 23(1):38–48, 2003. → pages 848[10] K. Crane, M. Desbrun, and P. Schro¨der. Trivial connections on discretesurfaces. Computer Graphics Forum, 29(5):1525–1533, 2010. ISSN1467-8659. → pages 20, 21[11] C. De Paoli and K. Singh. Secondskin: sketch-based construction of layered3d models. ACM Transactions on Graphics (TOG), 34(4):126, 2015. →pages 7, 8[12] P. Decaudin, D. Julius, J. Wither, L. Boissieux, A. Sheffer, and M.-P. Cani.Virtual garments: A fully geometric approach for clothing design. InComputer Graphics Forum, volume 25, pages 625–634, 2006. → pages 7[13] O. EFI. Optitex pds, 2017. URL http://optitex.com/. → pages 7[14] M. Fontana, A. Carubelli, C. Rizzi, and U. Cugini. Clothassembler: a cadmodule for feature-based garment pattern assembly. Computer-AidedDesign and Applications, 2(6):795–804, 2005. → pages 7[15] G. Guennebaud, B. Jacob, et al. Eigen v3. http://eigen.tuxfamily.org, 2010.→ pages 23, 27[16] K. Kiisel. Draping: the complete course. Laurence King Publishing, 2013.→ pages 1, 6, 7[17] T.-H. Kwok, Y.-Q. Zhang, C. C. Wang, Y.-J. Liu, and K. Tang. Stylingevolution for tight-fitting garments. IEEE transactions on visualization andcomputer graphics, 22(5):1580–1591, 2016. → pages 7, 8[18] C. Li, H. Pan, Y. Liu, A. Sheffer, and W. Wang. Bendsketch: Modelingfreeform surfaces through 2d sketching. ACM Trans. Graph. (SIGGRAPH),36(4):125:1–125:14, 2017. → pages 10[19] J. Li and G. Lu. Modeling 3d garments by examples. Computer-AidedDesign, 49:28–41, 2014. → pages 7, 8[20] L. Liu, L. Zhang, Y. Xu, C. Gotsman, and S. J. Gortler. A local/globalapproach to mesh parameterization. Computer Graphics Forum, 27(5):1495–1504, 2008. ISSN 1467-8659. → pages 26[21] R. Narain, A. Samii, and J. F. O’Brien. Adaptive anisotropic remeshing forcloth simulation. ACM Trans. Graph., 31(6):152:1–152:10, 2012. ISSN0730-0301. → pages 549[22] R. Narain, T. Pfaff, and J. F. O’Brien. Folding and crumpling adaptivesheets. ACM Trans. Graph., 32(4):51:1–51:8, 2013. ISSN 0730-0301. →pages 5, 29, 40[23] U. Pinkall and K. Polthier. Computing discrete minimal surfaces and theirconjugates. Experimental Mathematics, 2(1):15–36, 1993. → pages 20[24] T. Popa, Q. Zhou, D. Bradley, V. Kraevoy, H. Fu, A. Sheffer, andW. Heidrich. Wrinkling captured garments using space-time data-drivendeformation. In Computer Graphics Forum, volume 28, pages 427–435,2009. → pages 10[25] N. Ray, B. Vallet, W. C. Li, and B. Le´vy. N-symmetry direction field design.ACM Trans. Graph., 27(2):10:1–10:13, 2008. ISSN 0730-0301. → pages 21[26] N. Ray, B. Vallet, L. Alonso, and B. Levy. Geometry-aware direction fieldprocessing. ACM Trans. Graph., 29(1):1:1–1:11, 2009. ISSN 0730-0301. →pages 20, 21[27] C. Robson, R. Maharik, A. Sheffer, and N. Carr. Context-aware garmentmodeling from sketches. Comput. Graph., 35(3):604–613, 2011. ISSN0097-8493. → pages 3, 7, 8, 10[28] D. Rohmer, T. Popa, M.-P. Cani, S. Hahmann, and A. Sheffer. Animationwrinkling: Augmenting coarse cloth simulations with realistic-lookingwrinkles. ACM Trans. Graph., 29(6):157:1–157:8, 2010. ISSN 0730-0301.→ pages vii, 3, 8, 10, 15[29] O. Sorkine and M. Alexa. As-rigid-as-possible surface modeling. InSymposium on Geometry processing, volume 4, 2007. → pages 26[30] R. W. Sumner and J. Popovic´. Deformation transfer for triangle meshes.ACM Trans. Graph., 23(3):399–405, 2004. ISSN 0730-0301. → pages 29[31] K. Takayama, M. Okabe, T. Ijiri, and T. Igarashi. Lapped solid textures:filling a model with anisotropic textures. In ACM Transactions on Graphics(TOG), volume 27, page 53. ACM, 2008. → pages 19[32] E. Turquin, M.-P. Cani, and J. Hughes. Sketching garments for virtualcharacters. In Eurographics Workshop on Sketch-Based Interfaces andModeling, Grenoble, France, 2004. Eurographics. → pages 3, 7[33] E. Turquin, J. Wither, L. Boissieux, M.-P. Cani, and J. F. Hughes. Asketch-based interface for clothing virtual characters. IEEE Comput. Graph.Appl., 27(1):72–81, 2007. ISSN 0272-1716. → pages 3, 7, 1050[34] N. Umetani, D. M. Kaufman, T. Igarashi, and E. Grinspun. Sensitive couturefor interactive garment modeling and editing. ACM Trans. Graph., 30(4):90:1–90:12, 2011. ISSN 0730-0301. → pages 5, 9, 29, 40, 42[35] P. Volino, F. Cordier, and N. Magnenat-Thalmann. From early virtualgarment simulation to interactive fashion design. Comput. Aided Des., 37(6):593–608, 2005. ISSN 0010-4485. → pages 7[36] C. C. Wang, Y. Wang, and M. M. Yuen. Feature based 3d garment designthrough 2d sketches. Computer-Aided Design, 35(7):659–672, 2003. →pages 7[37] C. C. Wang, Y. Wang, and M. M. Yuen. Design automation for customizedapparel products. Computer-aided design, 37(7):675–691, 2005. → pages 8[38] E. Zhang, J. Hays, and G. Turk. Interactive tensor field design andvisualization on surfaces. IEEE Transactions on Visualization and ComputerGraphics, 13(1):94–107, 2007. ISSN 1077-2626. → pages 1951Appendix APerceptual Validation Material52Instructions • The goal of this study is to assess a tool for adding folds and pleats to garment designs. • Using the tool designers can schematically specify the folds they want using a sketching interface demonstrated below. • Designers use two types of strokes – Gathering strokes (red): are drawn along the folds respective gathering seam (or hemline for hemline strokes). They indicate the gathering pattern and the amount of material the folds are expected to use. See more details on the next page – path strokes (blue): define the location, directions and length of the folds • Next page shows the conventions used to communicate fold or pleat types. • In the subsequent pages you will be asked to assess the quality of different algorithm generated results and their adherence to the user input. 4 Types of Supported Folds and Pleats Pinched Pleats Gathering Folds Hemline Folds Knife Pleats A B C Which of the garments below ("B" or "C") is more reflective of the user input above ("A")? ours 100% [Rohmer et al. 2010] after pattern adjustment [Bartle et al. 2016] 0% Which of the garments below ("B" or "C") is more reflective of the user input above ("A")? A B C ours 100% [Rohmer et al. 2010] after pattern adjustment [Bartle et al. 2016] 0% A B C Which of the garments below ("B" or "C") is more reflective of the user input above ("A")? ours 90% a naïve extension method using ARAP 10% A B C Which of the garments below ("B" or "C") is more reflective of the user input above ("A")? ours 100% a naïve extension method using ARAP 0% A B C Which of the garments below ("B" or "C") is more reflective of the user input above ("A")? ours 100% [Rohmer et al. 2010] after pattern adjustment [Bartle et al. 2016] 0% A B C Which of the garments below ("B" or "C") is more reflective of the user input above ("A")? ours 100% a naïve extension method using ARAP 0% Figure A.1: Perceptual Validation, with stats.53A B C Which of the garments below ("B" or "C") is more reflective of the user input above ("A")? ours 100% a naïve extension method using ARAP 0% A B C Which of the garments below ("B" or "C") is more reflective of the user input above ("A")? ours 90% our first reproducible garment 10% A B C Which of the garments below ("B" or "C") is more reflective of the user input above ("A")? ours 100% a naïve extension method using ARAP 0% A B C Which of the garments below ("B" or "C") is more reflective of the user input above ("A")? ours 90% a naïve extension method using ARAP 10% A B C Which of the garments below ("B" or "C") is more reflective of the user input above ("A")? ours 80% our method without stretching in fold path directions and the following computations 20% A B C Which of the garments below ("B" or "C") is more reflective of the user input above ("A")? ours 90% a naïve extension method using ARAP 10% Figure A.2: Perceptual Validation, with stats (continued).54
- Library Home /
- Search Collections /
- Open Collections /
- Browse Collections /
- UBC Theses and Dissertations /
- FoldSketch : enriching garments with physically reproducible...
Open Collections
UBC Theses and Dissertations
Featured Collection
UBC Theses and Dissertations
FoldSketch : enriching garments with physically reproducible folds Li, Minchen 2018
pdf
Page Metadata
Item Metadata
Title | FoldSketch : enriching garments with physically reproducible folds |
Creator |
Li, Minchen |
Publisher | University of British Columbia |
Date Issued | 2018 |
Description | While folds and pleats add interest to garments and cloth objects, incorporating them into an existing design manually or using existing software requires expertise and time. This thesis presents FoldSketch, a new system that supports simple and intuitive fold and pleat design. FoldSketch users specify the fold or pleat configuration they seek using a simple schematic sketching interface; the system then algorithmically generates both the fold-enhanced 3D garment geometry that conforms to user specifications, and the corresponding 2D patterns that reproduce this geometry within a simulation engine. While previous work aspired to compute the desired patterns for a given target 3D garment geometry, the main algorithmic challenge here is that the target geometry is missing. Real-life garment folds have complex profile shapes, and their exact geometry and location on a garment are intricately linked to a range of physical factors; it is therefore virtually impossible to predict the 3D shape of a fold-enhanced garment using purely geometric means. At the same time, using physical simulation to model folds requires appropriate 2D patterns and initial drape, neither of which can be easily provided by the user. FoldSketch obtains both the 3D fold-enhanced garment and its corresponding patterns and initial drape via an alternating 2D-3D algorithm. We first expand the input patterns by allocating excess material for the expected fold formation; then we use these patterns to produce an estimated fold-enhanced target drape geometry that balances designer expectations against physical reproducibility. Next, we generate an initial reproducible output using the expanded patterns and the estimated target drape as input to a garment simulation engine. Then we improve the output's alignment with designer expectations by progressively refining the patterns and the estimated target drape, converging to a final fully physically reproducible fold-enhanced garment. The experiments confirm that FoldSketch reliably converges to a desired garment geometry and corresponding patterns and drape, and works well with different physical simulators. My collaborators and I demonstrate the versatility of this approach by showcasing a collection of garments augmented with diverse fold and pleat layouts specified via the FoldSketch interface, and further validate this approach via feedback from potential users. |
Genre |
Thesis/Dissertation |
Type |
Text |
Language | eng |
Date Available | 2018-04-19 |
Provider | Vancouver : University of British Columbia Library |
Rights | Attribution-NonCommercial-NoDerivatives 4.0 International |
DOI | 10.14288/1.0365821 |
URI | http://hdl.handle.net/2429/65532 |
Degree |
Master of Science - MSc |
Program |
Computer Science |
Affiliation |
Science, Faculty of Computer Science, Department of |
Degree Grantor | University of British Columbia |
GraduationDate | 2018-05 |
Campus |
UBCV |
Scholarly Level | Graduate |
Rights URI | http://creativecommons.org/licenses/by-nc-nd/4.0/ |
AggregatedSourceRepository | DSpace |
Download
- Media
- 24-ubc_2018_may_li_minchen.pdf [ 37MB ]
- Metadata
- JSON: 24-1.0365821.json
- JSON-LD: 24-1.0365821-ld.json
- RDF/XML (Pretty): 24-1.0365821-rdf.xml
- RDF/JSON: 24-1.0365821-rdf.json
- Turtle: 24-1.0365821-turtle.txt
- N-Triples: 24-1.0365821-rdf-ntriples.txt
- Original Record: 24-1.0365821-source.json
- Full Text
- 24-1.0365821-fulltext.txt
- Citation
- 24-1.0365821.ris
Full Text
Cite
Citation Scheme:
Usage Statistics
Share
Embed
Customize your widget with the following options, then copy and paste the code below into the HTML
of your page to embed this item in your website.
<div id="ubcOpenCollectionsWidgetDisplay">
<script id="ubcOpenCollectionsWidget"
src="{[{embed.src}]}"
data-item="{[{embed.item}]}"
data-collection="{[{embed.collection}]}"
data-metadata="{[{embed.showMetadata}]}"
data-width="{[{embed.width}]}"
async >
</script>
</div>
Our image viewer uses the IIIF 2.0 standard.
To load this item in other compatible viewers, use this url:
https://iiif.library.ubc.ca/presentation/dsp.24.1-0365821/manifest