Computational Smocking through Fabric-Thread Interaction

We formalize Italian smocking, an intricate embroidery technique that gathers flat fabric into pleats along meandering lines of stitches, resulting in pleats that fold and gather where the stitching veers. In contrast to English smocking, characterized by colorful stitches decorating uniformly shaped pleats, and Canadian smocking, which uses localized knots to form voluminous pleats, Italian smocking permits the fabric to move freely along the stitched threads following curved paths, resulting in complex and unpredictable pleats with highly diverse, irregular structures, achieved simply by pulling on the threads. We introduce a novel method for digital previewing of Italian smocking results, given the thread stitching path as input. Our method uses a coarse-grained mass-spring system to simulate the interaction between the threads and the fabric. This configuration guides the fine-level fabric deformation through an adaptation of the state-of-the-art simulator, C-IPC. Our method models the general problem of fabric-thread interaction and can be readily adapted to preview Canadian smocking as well. We compare our results to baseline approaches and physical fabrications to demonstrate the accuracy of our method.


Introduction
Embroidery, one of the oldest forms of art, produces exquisite decorations through the interplay of fabric and threads, and continues to captivate researchers in visual computing [EMZ16, MS22, RSSH23,ZPH * 23].A recent paper [RSSH23] delves into Canadian smocking, an embroidery technique renowned for its intricate and voluminous pleats, whose geometric shape is difficult to predict by looking at the smocking pattern alone.During the fabrication of Canadian smocking, multiple points along the same stitching line are gathered and secured with a knot.To compute a digital preview of a smocked result, Ren et al. [RSSH23] cast Canadian smocking as a graph embedding problem, merging multiple graph nodes into a single one, as fabric thickness has a negligible effect in this technique.However, this method is not applicable to Italian smocking, a different traditional smocking technique, in which fabric thickness significantly influences pleat formation and cannot be disregarded.
In Italian smocking, the fabric is "drawn up into close pleats on rows of gauged stitching with deviations that create patterned irregularities" [Wol96].An Italian smocking pattern is typically divided into rows (thread paths, not necessarily straight); each row is stitched with a separate thread.The thread alternates between passing in and out of the fabric, creating front stitches and back stitches.After completing the stitching of all rows, the threads are gently pulled on, so that the fabric is pushed and gathered, creating folded pleats.Finally, the thread ends are tied to secure the pleats in the desired shape.See Fig. 1 for an example and Fig. 2 for a demonstration of the fabrication process.We can readily observe the distinctive characteristics of Italian smocking, setting it apart from English and Canadian smocking.In English smocking, the fabric is stitched in straight paths with regular spacing, yielding uniform pleats.The colorful rows of stitches running through these pleats are similar to standard 2D embroidery.In contrast, the stitching lines in Italian smocking do not follow a straight path.As the stitching line turns and curves, the fabric gathers and crinkles along the stitched thread, resulting in complex and unpredictable pleats with diverse, irregular structures, which play the main decorative role.Unlike the localized knots in Canadian smocking, which immobilize the stitching points and validate the assumption of negligible fabric thickness, Italian smocking per-arXiv:2401.05533v2[cs.GR] 16 Jan 2024  [Han22].A single thread is sewn through the fabric along one row of the pattern.Then, the free ends of the threads are pulled on, resulting in intricate pleat patterns.©HandiWorks YouTube channel.Used with permission.mits the stitching points (i.e., the fabric) to move freely along the stitched thread, and the thread may not necessarily be pulled taut in the final fabrication (see Fig. 3 for some examples).We summarize the major differences between English, Canadian, and Italian smocking techniques in Table 1, and provide an illustrative comparison in Fig. 4.
In this work, we propose a novel method for previewing the result of Italian smocking given a stitching pattern by employing the general perspective of fabric-thread interaction.We model the fabric using a coarse-grained mass-spring system at a scale similar to the size of the front and back stitches on the fabric, as indicated in the input pattern.Subsequently, we simulate the dynamics of this coarse mass-spring system by incorporating adjustable stitching springs to model taut threads during the thread-pulling stage of Italian smocking fabrication.The resulting configuration of the mass-spring system is then used to guide the deformation of the fabric in a finer resolution by adapting C-IPC [LKJ21].

Contributions. (1)
We introduce a formalization of Italian smocking pattern design and propose a simple method to preview the smocked results.(2) Our formulation is capable of handling continuous stitches on both the front and the back of the fabric, which can be used to facilitate free-form embroidery design.(3) We integrate non-zero sewing lengths and positional constraints into the state-of-the-art simulator C-IPC [LKJ21].©DIYstitching YouTube channel.Used with permission.

Related work
Fabric manipulation, such as embroidery, folding, and pleating, is a fascinating art form that poses challenging problems in computer graphics.These challenges include how to model the geometry of folds and how to efficiently and accurately simulate wrinkles.We therefore review the literature in these two aspects.
Modeling folds and pleats.Curves are popular for abstracting cloth folds.For example, Popa et al. [PZB * 09] extract fold curves from input images to guide the 3D fabric deformation, achieving folds that closely match the reference.Jung et al. [JHR * 15] propose a method to generate folds for garments or fashion accessories that are guaranteed to align with the curves drawn as silhouettes on a design sketch.The FoldSketch system [LSGV18] solves for an updated sewing pattern that aligns with user-specified curves, achieving expected folds through a combination of graph editing and cloth simulation.Zheng et al. [ZSS20] develop a system that allows users to generate folds on draped cloth by drawing curves and reconstructing the modified cloth surface for downstream simulation.Frequency-based models are investigated to simulate the fine-scale wrinkles and their evolution on coarse meshes [CCK * 21, CKSV23].Hermite radial basis functions can also be used to approximate the shape of wrinkles [MSYA21].However, while curves and smooth basis functions have proven effective in modeling prominent folds, they are less suitable for capturing the intricate and structural folds found in embroidery, especially at a fine level of detail.In the special case of Canadian smocking, Kim [Kim20] accounts for the fold angle when performing step-by-step simulation manually set up using the Clo software [CLO23].Ren et al. [RSSH23] propose using a coarse graph to abstract the pleat shape and solve for the fine-grained shape of the pleats via surface deformation guided by this coarse graph.However, none of the existing formulations can be applied to Italian smocking [Wol96,Shi13], where the intricate pleats are formed by the special fabric-thread interaction.

Preliminaries
An Italian smocking pattern P is usually drawn on a piece of fabric with a set of stitching paths L = {ℓ}.Each stitching path is a list of consecutive grid vertices with alternating front stitches and back stitches.(3) The decorative pleats are formed differently as well.In Canadian smocking, the localized stitches exert force to push the fabric out of the initial fabric plane, resulting in voluminous pleats.Consequently, the fabric's thickness can be largely ignored, assuming that after stitching, several points merge into one [RSSH23].In contrast, for Italian smocking, the fabric is gently compressed and folded, and the resulting pleats take shape as the thread is pulled at the free ends.These threads interweave a long sequence of points in Figure 5: Mass-spring system.For the Italian smocking pattern shown on the left, with front (resp.back) stitches annotated in solid (resp.dashed) line segments, we define a mass-spring system based on the original grid.Left: we highlight the stitching vertices Vs, front midpoints V f , back midpoints V b , and pleat vertices Vp, in orange, green, purple, and gray, respectively.Right: we color the fabric spring (stitching spring) in gray (orange).
the fabric and gather pleats.The thickness of the fabric plays a crucial role in maintaining the order of the created pleats and cannot be disregarded in physical simulation.
We model an input pattern P by a mass-spring system (V, E), where V is the set of vertices from the original grid and E is the set of edges (springs) that connect the vertices in V. Specifically, there are two types of springs in E: (1) the fabric springs E f that connect the adjacent grid vertices in V, and (2) the stitching springs Es that connect two stitching vertices of a line in L.
We categorize the vertices in V into two groups, see also Fig. 5: (1) Vs: the stitching vertices that lie on the stitching paths L, and (2) Vp = V\Vs: the remaining vertices, which we refer to as pleat vertices.Note that the encoding of the front-back information is not possible within the stitching springs because there are no faces to distinguish the front or back side of a fabric in the mass-spring system.We therefore sample the midpoints of all front and back stitches in the stitching paths to encode the front-back information.Specifically, V f denotes the midpoints of the front stitches in L (we call them front midpoints for simplicity) and V b denotes the midpoints of the back stitches in L (called back midpoints).See Fig. 5 (left) for an illustration.For a vertex v i ∈ V ∪ V f ∪ V b , we denote its original 2D position in the flat fabric as

Method
Given an input Italian smocking pattern, our goal is to preview the corresponding fabricated result in the form of a surface mesh in 3D, showing the intricate folds and pleats.The main challenges of this problem include accounting for the fabric thickness, distinguishing between front and back stitches, and determining the nonvanishing length of stitched threads in the fabricated state.Existing methods such as [RSSH23] and C-IPC [LKJ21] do not support advanced stitching primitives.If the smocking stitches are considered as seams, these methods struggle with Italian smocking, since the distance between two stitching points is assumed to be zero.
To tackle the challenges, we propose an abstraction of a massspring system with front-back information from the input pattern.We then dynamically estimate the expected lengths of the stitching springs and find the 2D embedding of the stitching vertices via the simulated configuration of the mass-spring system (Sec.4.1).

2D simulation of the mass-spring system
Drawing inspiration from [RSSH23], we extract a low-resolution mass-spring system (V, E) to distill the geometric priors from the input Italian smocking pattern.Solving the dynamics of such a mass-spring system appears straightforward at first glance.However, the fact that the expected lengths for all fabric springs E f and the stitching springs Es are unknown makes the problem hard to formulate and solve.For example, as shown in Fig. 3, the final distance between two consecutive stitching vertices is not necessarily zero, leaving the expected length of a stitching spring unpredictable.Furthermore, in our setting, the length of a fabric spring in the final embedding is often much smaller than its original length in the fabric.Specifically, in typical cases where a high-resolution mass-spring system is employed to model a small fabric piece, it is common to assume that fabric springs preserve their original lengths during fabric deformation.Here the length indicates the anticipated Euclidean distance between two vertices.However, this assumption is not applicable to our low-resolution mass-spring system.For a fabric spring shown in Fig. 5 (right), with the thread tightened, its two endpoints would be closely embedded at a distance equal to the fabric thickness after smocking, which significantly deviates from the spring's original length within the fabric.
To address these challenges, we propose solving for a constrained 2D projection of the dynamics of the abstracted massspring system, rather than dealing with the full 3D mass-spring system with unknown expected lengths.More precisely, we would like to find a 2D projection X for the mass-spring system by solving: where τ is the fabric thickness, |Es| is the number of edges (springs) in the stitching paths L, x i is the original 2D position of the vertex v i and X is the set of all these original positions.The function D(X | L) measures the total length of the threads that pass through the fabric along the stitching paths L given the current embedding X: (2) The energy in Eq. (1a) encourages the vertices to stay away from each other to avoid cluttered pleats, similar to [RSSH23].The first set of constraints, Eq. (1b), poses restriction on the length of a fabric spring (p, q) ∈ E f : once embedded in 2D, it must be at minimum the fabric thickness τ and at maximum equal to the original spring length of the initial flat fabric state.A violation of these constraints can result in fabric penetration or tearing.
The second set of constraints, Eq. (1c), poses restrictions on the stitching springs.Recall that when fabricating an Italian smocking pattern, the free ends of the threads (aligned with the stitching paths L) are pulled.This action causes the fabric to fold and pleat along the stitching paths until the desired texture is achieved.The in-between stitching vertices have the freedom to slide along the thread.We therefore consider the total length of the threads D(X | L) instead of each stitching spring independently.The minimal possible total length is τ |Es|, which corresponds to the scenario when the threads are pulled completely taut, such that no stitching vertices can slide.At the same time, we propose a natural upper bound where the sum of the thread lengths is reduced to a γ fraction of their original total length.Here, the hyper-parameter γ models the pulling force applied to the threads.For example, when γ = 1, we can see that X = X gives the optimal solution.A smaller value γ < 1 drives the stitching vertices to move closer to meet the constraints, leading to folds and pleats.See Fig. 6 for an example.
Algorithm overview.The non-linearly constrained, non-convex problem in Eq. ( 1) is hard to optimize directly.We therefore propose to solve for the embedding X in an alternating scheme: Step 1: initialize the embedding X (0) = X; Step 2: estimate the expected distances d (k) i j from the constraints based on X (k) (detailed below); Step 3: update the embedding X (k+1) based on the expected distances d i j , which is solved as an unconstrained problem: (3) Step 4: set k ← k + 1 and go to Step 2, unless a stopping criterion is satisfied.
We now detail the estimation of d is determined to make sure the constraints in Eq. (1b) are satisfied: For stitching springs, we introduce a pulling direction to model their shrinkage speed.In physical fabrications, we observe that the stitches that align more closely with the pulling direction (i.e., with a larger projected length) shrink more rapidly (i.e., have a smaller expected length d (k) i j ), and vice versa.Specifically, for a stitching spring (i, j) ∈ Es (ℓ), we compute where P d (x) gives the projected length of a vector x onto the direction d, which is orthogonal to the pulling direction.Here, for notation simplicity, instead of expressing the expected length as inversely proportional to the projection onto the pulling direction, we represent it as proportional to the projection onto the orthogonal of the pulling direction.The upper bound in Eq. ( 1c) is adopted as the stopping criterion in Step 4. Specifically, we stop the algorithm when the total length of the threads is below the preset shrinkage ratio γ.See Algorithm 1 for a detailed description and Appendix A for its convergence behavior analysis.In Appendix B, we provide a comparison to an existing solver, sequential least squares programming (SLSQP) [Kra88], where our algorithm shows significantly faster convergence and leads to better simulated results.

Mesh deformer via C-IPC
We use the solved 2D embedding Xs of the stitching vertices to guide the 3D deformation of the fabric, which is now represented in a much finer resolution.During the 2D simulation, the fabric springs E f mainly serve as the inextensible constraints for the stitching springs Es, and their actual positions, depending on the final shape of the formed pleats, are undetermined at this stage.We therefore only use the stitching points to guide the deformation, since they are better constrained to provide more accurate control.
Algorithm 1 2D simulation of the mass-spring system Hyper-parameters: shrinkage γ, projection direction d, fabric thickness τ, time step ∆t = 0.1 sec, damping ratio α = 0.9, fabric spring stiffness k f = 1, stitching spring stiffness ks = 5. 1: procedure 2D SIMULATION(X, X, L, Es, E f , E) for (i, j) ∈ Es do ▷ Expected length for stitching springs 5: end for 7: for (i, j) ∈ E f do ▷ Expected length for fabric springs 8: end for 10: for (i, j) ∈ E do ▷ Calculate acceleration 11: a i ← a i − k∆d i j 13: a j ← a j + k∆d i j 14: end for 15: v ← v + a∆t 16: v ← αv 17: x ← x + v∆t 18: a ← 0 ▷ Reset for next timestep 19: end while 20: end procedure Specifically, we first determine the 3D positions of the stitching vertices by assuming they all share the same height and experience no unbalanced external forces.Without loss of generality, we set the height to zero, i.e., the estimated 3D position for the stitching vertex, denoted x c s ∈ R 3 , is: Next, we estimate the 3D position of the front/back midpoint vm of the stitching spring (i, j) ∈ Es: The superscript c abbreviates "constrained", as these positions serve as positional constraints.Intuitively, the front stitches cause midpoints to fold inward, resulting in a negative height (−hm), while the back stitches cause midpoints to fold outward, resulting in a positive height.A good approximation for hm is (See Fig. 7): For simplicity one can also estimate hm as (∥xi−x j ∥−∥xi−x j ∥) /2 when the fold is vertical with a flat crease.
We augment the original incremental potential of C-IPC [LKJ21] with the positional constraints of the embedded stitching vertices Xs, the estimated midpoints Xm, and the sewing length constraints to obtain the deformed fabric mesh in 3D: where n is the total number of vertices in the finer representation of the fabric.The coefficients ws and wp are weights for these constraints.The term Esew encourages the sewing length between two stitching vertices to be equal to our computed values.We add ∆t 2 , the squared timestep of C-IPC, to Esew, incorporating it into the incremental potential as the sewing energy potential: The term Epos is the positional regularizer that encourages the stitching vertices and midpoints to remain close to the solved positions Xs ∪ Xm: We consider Epos as a soft positional constraint instead of a virtual energy potential.Therefore the timestep ∆t 2 is not included.Integrating these two regularizers into C-IPC effectively guides the fabric from its initial flat state toward the desired pleat shapes, while the original configurations of C-IPC handle self-collisions during the cloth simulation.

Comparisons to physical fabrications
To validate that our method produces faithful results, we manually fabricated several Italian smocking patterns.Using a laser cutter, we engraved the pattern onto the fabric, followed by sewing through the fabric along the pattern rows and pulling the threads to achieve a similar appearance to that shown in YouTube tutorials.We then measured the approximate thread shrinkage γ and executed our method using the same value.In Fig. 8 we show four examples of smocking patterns, where we color the front and back stitches in green and purple, respectively.We can see that our simulated results are close to the physical fabrications.
Italian smocking is relatively easy to fabricate, requiring merely the pulling of threads stitched through the fabric to create pleats.However, the complexity lies in pleat adjustment, as the resulting pleats after pulling are often irregular or distorted if the fabric does not properly slide along the threads (see Fig. 2).The fabricator has to adjust the pleats to achieve the desired shape.Therefore, in practice, designing a new Italian smocking pattern is challenging.If the fabricated result appears irregular or less pleasing, it is difficult to determine whether the issue lies in the pattern itself or the pleat refinement process was not adequately executed, since the pleat shape is unknown.In Fig. 9, we showcase two patterns ((b) and (c)), not available online, and utilize our computed results to assist in adjusting the physically fabricated pleats to improve their shapes.Specifically, we start from a known, classic pattern in Fig. 9 (a) and make local modifications to obtain the patterns (b) and (c), which retain the overall zigzag style.Despite the minor nature of these modifications, they lead to significant and unexpected changes in the final fabricated results.Our simulated results successfully helped us to adjust the shape of the physical pleats.We believe our algorithm can benefit artists in designing new patterns, as our results are consistently regular and reproducible in physical fabrications.

Justifications of formulation
A key factor of our formulation is to model the gradual extraction of the thread during the fabric-thread interaction.As detailed in Eq. (1c), we achieve this by introducing the parameter γ to describe the shrinkage of the total length of the threads.In Fig. 10, we compare our results when using different values of γ to physi-cal fabrications.It is evident that our results faithfully capture the smocking patterns, validating our choice of the parameter γ.
Our formulation is flexible and capable of accommodating scenarios where the expected sewing length distribution varies due to additional external constraints.For example, artists may incorporate beads into the fabrication process (see Fig. 3, left), which can be regarded as additional lower bound constraints for selected stitching springs.These constraints can be seamlessly integrated into our formulation, i.e., Eq. (1c).In Fig. 12, we show an example of an Italian smocking pattern with beads.The arrow indicates the placement of the beads during fabrication.For these selected stitching springs, we set the lower bound to the diameter of the beads.The resulting smocked design shows a distinct pleat pattern with an altered sewing length distribution imposed by these beads.

Comparisons to cloth simulators
Baselines.We consider the closest setting in Blender [Ble23] (build-in cloth simulator), and C-IPC [LKJ21] (vanilla version without any prior knowledge) as baselines, where two stitching points are expected to have zero distance after sewing and the fabric is not allowed to slide along the threads.We admit that existing cloth simulators hold great potential to address the Italian smocking problem by modeling the threads with thin rods.However, this requires non-trivial considerations such as establishing boundary constraints and formulating pulling forces that guide the fabric to slide.We consider it a challenging open question and demonstrate our naive attempt at rod-fabric interaction in Appendix C.
Fig. 11 shows the comparison between our method, the considered baselines, and real fabrications.Specifically, we use the builtin cloth simulator in Blender to simulate the smocking process, treating each front and back stitch in the pattern as a sewing line.During the simulation, we manually halt the process when the total length of the sewing lines reaches γ fraction of their initial lengths.We particularly fine-tune the maximum sewing force parameter to mimic the real fabrication process, ensuring that stitched threads are gently pulled out and avoiding rapid fabric shrinkage during simulation.We can see that Blender fails to produce reasonable results: the solver cannot distinguish between the front and back stitches and fails to produce correct and consistent bending directions for the fabric during the simulation.We also employ C-IPC without priors to simulate smocking, treating each front and back stitch as a sewing line.However, the simulated results often appear cluttered due to C-IPC's assumption of zero-length sewing lines.Furthermore, without distinguishing between front and back stitching lines, the generated pleats exhibit randomly oriented bulges in both upward and downward directions.In contrast, our preview results are more plausible and faithful in comparison with real fabrications.

Adaptation for Canadian smocking
Applying the method designed for Canadian smocking [RSSH23] to Italian smocking leads to disastrous results, since all the stitching points on the stitching line are simply merged into a single node.We therefore decompose a stitching path ℓ in an Italian smocking pattern into a set of separate stitching lines to avoid a degenerated smocked graph.However, even after this modification, the method in [RSSH23] still fails to produce reasonable results, as shown in Fig. 13.On the other hand, our method can be easily applied to Canadian smocking.We define the set of back midpoints as empty (V b = ∅), set the expected lengths for all stitching springs to zero, and run our algorithm.See Fig. 14 for some examples.Our method produces reasonable pleat shapes.Our results exhibit less regularity compared to [RSSH23], primarily because their approach incorporates structural geometry priors, whereas our method is simulation-based and offers less control over the regularity of the pleats.

Ablation on geometric priors
In Fig. 15, we conduct an ablation study to justify the usefulness of the computed sewing lengths and positions for guiding C-IPC.In particular, we consider the following settings: When comparing (b) to (a), we can observe that the correct offsets in the initial configuration guide C-IPC to create more regularly folded pleats.However, the overall result appears cluttered and excessively shrunken.Incorporating the computed non-zero sewing lengths into C-IPC results in less cluttered but still unrealistic pleats, since the sewing length constraints still permit significant deformation freedom.On the other hand, positional constraints offer a stronger prior for C-IPC to achieve regular and realistic pleats.Note that the stitching vertices and the sampled midpoints are treated equally in the positional constraints.Incorporating the sewing length regularizer can impose stricter constraints on the stitching vertices alone.This combined energy results in more regular pleats, particularly in the boundary region.

Implementation, parameters & runtime
Implementation.We implement the 2D mass-spring system simulator in Python.The 3D deformer is implemented in C++ based on the Parameters.The input smocking pattern is scaled to have the longest side of 1 m.For all experiments, we use the same set of parameters: ws = 0.1, wp = 0.01.The shrinkage parameter γ is manually selected to replicate the textures demonstrated in online tutorials; we provide the values in the figures.Regarding the parameters for C-IPC, we retain most of the parameters provided for cotton material in the released code of [LKJ21].We set the bending stiffness scaling parameter to 100 and use the isotropic membrane model without strain limiting.Our 3D deformer is executed for 100 frames with a timestep size of ∆t = 0.04 sec, which is sufficient for convergence, starting from the fabric's initial planar state.For all the patterns except the CURVE pattern shown in Fig. 11 (left), we set the pulling direction (orthogonal to d discussed in Eq. ( 5)), to a unit horizontal vector, and the fabric thickness τ to 0.01.Altering the fabric thickness does not affect the appearance of the pleats, as these patterns rely on loose stitches to create their textures.The CURVE pattern is more challenging, since the fabric crinkles sharply along the curly stitching paths, whose accumulative rotation is more than 2π.The directions of stitching lines change significantly along the path and induce many local minima for the 2D spring system.We therefore align the pulling direction with each stitching spring instead of setting a uniform direction as in other patterns.We also adjust the thickness τ to 0.1 to better cap-  ture locally squeezed multi-layer folds of the pattern size used in physical fabrication.
Runtime.In Table 2, we report the smocking pattern complexity and the runtime breakdown of our algorithm for the examples shown in Figures 8 and 9.The runtime of the 2D simulator depends on the number of grid vertices (|V|), the number of stitching vertices (|Vs|), and the shrinkage (γ).The runtime of the 3D deformer depends on the number of vertices in the finer fabric mesh (n) and the number of constraints added to C-IPC, closely related to |Vs|.Our 2D simulator is highly efficient, taking only seconds to converge even for smocking patterns with hundreds of stitching vertices.The 3D deformer can take minutes to deform the finer representation of the fabric with 10-50K vertices with collision handling.We also implemented a fast preview algorithm based on ARAP [SA07] with our computed positional constraints incorporated.This method is much more efficient and only takes a few seconds to preview the smocked pleats without material consideration.However, since there is no collision handling in ARAP, when the shrinkage is significant, the final result can have obvious self-intersections, as shown in Fig. 16 (see our result in Fig. 10 (γ = 20%)).
The C-IPC-based deformer can handle self-collisions and produce more visually pleasing results, albeit at a higher computational cost.In practice, users or designers can use the ARAP-based deformer for a quick preview of the smocking results and switch to the C-IPC-based deformer to generate final results once satisfied with the smocking pattern design.
It is worth noting that incorporating additional non-zero sewing lengths and positional constraints actually speeds up the 3D simulation, contrary to intuition.In Table 3 we report the runtime comparison of the ablation study in Fig. 15, where we run each setting for 100 frames for a fair comparison.Our method, setting (e), is more than twice as fast as the original C-IPC without constraints (setting (a)).We believe this is because our accurate constraints reduce the search space, leading to faster convergence.Similar behavior is observed when comparing the setting (b) to (a), where adding the correct offset to the initialization helps C-IPC converge quicker.

Conclusion, limitations, & future work
In this work, we formalize the Italian smocking embroidery technique and propose a simple method to simulate the smocking results.Unlike Canadian smocking, Italian smocking involves continuous stitching lines that traverse the fabric.Pulling the free ends of the threads to gather the fabric along the stitching paths gives rise to intricate and complex pleat patterns.The distances between two stitching vertices in the final result are not necessarily zero, which makes existing methods, with zero-length stitching primitives, not directly suitable for the task.Our method consists of two main steps: firstly, we model the fabric as a coarse mass-spring system and solve for its projected 2D configuration by iteratively estimating the expected embedding length of fabric springs and stitching springs.Next, we incorporate the computed sewing lengths, along with the positions of the stitching vertices and their midpoints, into the C-IPC simulator to guide fabric deformation in finer resolution.Our method achieves more faithful results compared to baseline approaches.It is important to highlight that our smocked results closely resemble physical fabrications in structural and qualitative aspects, while not being completely identical.The inherent randomness in pleating persists, since the shape is not fully constrained, which is also a characteristic of smocking.
Our 2D simulator is efficient and offers accurate priors for 3D mesh deformation.However, running C-IPC to address selfcollisions while integrating the computed constraints is timeconsuming due to the fine level of details in the resulting pleats.A more efficient self-collision handling would greatly benefit interactive design, which we leave as future work.Another limitation of our formulation is that we use the shrinkage parameter γ with respect to the total length of threads to model the pulling process, implicitly assuming simultaneous shrinking for all stitches.In actual fabrication, it is common for stitches closer to the pulling end to shrink first, with the effect propagating to stitches farther away.While our final smocked results are reasonably faithful, the simulation process deviates from physical fabrication.It would be interesting to explore a more advanced and sophisticated formulation for accurately simulating the pulling process.In addition, we currently only address smocking in a planar configuration.Future work involving extensions to curved surfaces, such as adapting positional constraints through parameterization lifting, would contribute to digital textile design, providing realistic smocking patterns.Another interesting direction for future work is to develop an interactive system for pleated fabric.Many online smocking tutorials necessitate pleat adjustment by the fabricator to achieve the desired results, as pulling threads can result in irregular pleats.A digital equivalent in the form of an interactive system for digital design would be valuable.constraints except for the shrinkage requirement over iterations.Therefore, we consider the algorithm converged when the current shrinkage ratio aligns with the user-specified target shrinkage.
In Fig. 17 we report the convergence results for the four patterns showed in Fig. 8.The convergence behavior exhibits a similar logarithmic decrease across different patterns.Notably, the green line in Fig. 17, corresponding to the pattern in Fig. 8 (c), shows a slower convergence.This is attributed to the vertical stitching lines, which tend to shrink less rapidly compared to stitching lines in other orientations when the threads are pulled horizontally.This behavior aligns with real fabrications and is explicitly considered in Eq. (5).Fig. 18 shows a qualitative example showcasing the algorithm's progression at different shrinkage values and the corresponding 3D results derived from the solved 2D configurations.The intermediate steps can still provide valid positional constraints to achieve realistic smocked results in 3D before the target shrinkage is reached.This feature benefits simulation of the shrinking process under different shrinkages in a single pass, as shown in Fig. 10 and Fig. 18.

Appendix B: SQP for 2D simulation
An alternative solution to the problem in Eq. ( 1) is using off-the-shelf solvers, such as sequential quadratic programming (SQP) [BT95], designed for constrained nonlinear optimization.Here we compare Scipy's SLSQP solver [Kra88, VGO * 20] to our Algorithm 1 in solving Eq. ( 1) on two different patterns: the CURVE pattern shown in Fig. 1 and the pattern in Fig. 8 (a).We report the problem complexity and runtime comparison in Table 4, and show the corresponding qualitative comparison in Fig. 19.It is worth noting that solving Eq. ( 1) is quite challenging, primarily due to the significantly greater number of constraints (Nc) compared to the number of variables (|V|).The SLSQP solver manages to find feasible solutions even when the initialization (planar fabric) does not fully satisfy all constraints.However, the solver still struggles with generating regular pleats given the complicated search space from the large number of constraints.This also justifies our choice of designing a specialized solver, leading to more accurate and visually pleasing results at a significantly reduced computational cost.
Appendix C: Rod-fabric interaction modeling for smocking An alternative approach to simulating smocking involves treating the long threads as thin rods and exploring the interaction between

Figure 1 :
Figure 1: Our simulated result and physical fabrication (highlighted in yellow) for an Italian smocking pattern.

Figure 2 :
Figure 2: Italian smocking fabrication [Han22].A single thread is sewn through the fabric along one row of the pattern.Then, the free ends of the threads are pulled on, resulting in intricate pleat patterns.©HandiWorks YouTube channel.Used with permission.

Figure 3 :
Figure 3: Loose threads.An essential characteristic of Italian smocking is the deliberate avoidance of fully tightening the threads to achieve visually appealing pleats.Left: Beads are strategically employed to prevent the threads from being pulled taut [DIY18].Right: Visible threads provide structural support to the pleats and enhance the overall aesthetics in the final result [DIY17].©DIYstitching YouTube channel.Used with permission.
Fig. 4 (right) shows an example of Italian smocking, which differs fundamentally from Canadian smocking in several ways: (1) Canadian smocking patterns consist of disconnected and short stitching lines, which are only annotated on one side of the fabric.In contrast, Italian smocking patterns feature continuous and long stitching paths that traverse both the front and back sides of the fabric alternately.(2) Creating a Canadian smocking pattern requires independently sewing each stitching line with localized knots.Conversely, Italian smocking patterns are fabricated along the stitching paths in a row-by-row fashion without localized knots.

Figure 7 :
Figure 7: Pulling the thread of a back stitch (left) causes the fabric to bend outward (right).We can estimate the height hp of the midpoint xp based on Pythagoras' theorem, as shown in Eq. (8).

Figure 8 :
Figure 8: We compare our simulated results to physical fabrications.

Figure 9 :
Figure 9: Small changes in the smocking pattern can lead to significantly different pleats.

Figure 10 :
Figure 10: Our results with different values of shrinkage γ (top) and the corresponding fabrications (bottom).

Figure 13 :
Figure 13: [RSSH23] fails to produce reasonable results on the Italian smocking patterns shown in Fig. 9 (a) and Fig. 11 (left).The underlay edges in the smocked graphs are highlighted in red.

Figure 14 :
Figure 14: Our algorithm can be adapted to Canadian smocking.Physical fabrications are from [RSSH23].Used with permission.
(a) E cipc without priors: we use the released code of [LKJ21] for cloth draping with our fine-tuned parameters; the input stitching paths are considered standard sewing lines with an expected length of zero.(b) E cipc with offset initialization: the midpoints in V b (resp.V f ) on the planar fabric mesh are offset with uniform positive (resp.negative) height.This modified mesh is then loaded in C-IPC as the first frame.This configuration guides the simulator to deform the mesh with the corresponding bending direction of front and back stitches.(c) E cipc + wsEsew with offset initialization: setting wp = 0, we turn off the positional constraints and guide C-IPC only use the computed sewing lengths.Here we use the initialization with offsets, since the sewing lengths do not contain the labeling of front and back stitches.(d) E cipc + wpEpos: similarly, we set ws = 0 to analyze the importance of the positional constraints.We do not use the offset initialization here, since our positional constraints already encode the front-back information.(e) Ours, i.e., E cipc + wsEsew + wpEpos.

Figure 15 :
Figure 15: Ablation on geometric priors.For two patterns with the same unit pattern shown in Fig. 8 (a) and Fig. 9 (a), we compare our results (shown in (e)) to four different settings: (a) C-IPC [LKJ21] without any priors, (b) C-IPC with offset initialization, where we additionally provide initial configuration with inward/outward offset to guide C-IPC, (c) we only provide the computed sewing lengths for C-IPC i.e., wp = 0, with offset initialization, (d) we only provide the computed positional constraints for C-IPC, i.e., ws = 0.

Figure 18 :
Figure 18: The 2D simulation (top) and the corresponding 3D results (bottom) with different shrinkages γ for the pattern shown in Fig. 8 (a).

Table 1 :
We compare three different types of smocking including English smocking, Canadian smocking, and Italian smocking.

Table 2 :
For the examples shown in Figures8 and 9, we report the input complexity (including #stitching vertices |Vs|, #grid vertices |V|, #vertices in the finer fabric mesh n, and shrinkage γ), the runtime for 2D simulation, 3D deformer, and total process.

Table 3 :
The total runtime for the ablation study in Fig.15.