TopoKnit : A Process-Oriented Representation for Modeling the Topology of Yarns in Weft-Knitted Textiles
Levi Kapllani, Chelsea Amanatides, Genevieve Dion, Vadim Shapiro, David E. Breen
TTopoKnit : A Process-Oriented Representation for Modeling the Topologyof Yarns in Weft-Knitted Textiles
Levi Kapllani , , Chelsea Amanatides , Genevieve Dion , , Vadim Shapiro , David E. Breen , Computer Science Department, Center for Functional Fabrics, Design Department, Drexel University University of Wisconsin - Madison, and International Computer Science Institute
Abstract
Machine knitted textiles are complex multi-scale material structures increasingly important in many industries, includingconsumer products, architecture, composites, medical, and military. Computational modeling, simulation, and designof industrial fabrics require e ffi cient representations of the spatial, material, and physical properties of such structures.We propose a process-oriented representation, TopoKnit, that defines a foundational data structure for representing thetopology of weft-knitted textiles at the yarn scale. Process space serves as an intermediary between the machine andfabric spaces, and supports a concise, computationally e ffi cient evaluation approach based on on-demand, near constant-time queries. In this paper, we define the properties of the process space, and design a data structure to represent itand algorithms to evaluate it. We demonstrate the e ff ectiveness of the representation scheme by providing results ofevaluations of the data structure in support of common topological operations in the fabric space. Keywords: weft-knitted textiles, fabric modeling, process space, contact neighborhood, data structure, topologicalrepresentation
1. Introduction
Knitting has been a technique for producing versatiletextiles for over a millennium, and the knitting processwas first automated with machinery in the 16th century[1]. Knitting produces fabrics with varied mechanicalproperties that can be shaped into many forms. Knittedtextiles are increasingly important in a number of indus-tries, including consumer products, architecture, compos-ites, medical, and military. In order for these textiles to bewidely deployed and reach their full industrial potential,computer-based modeling and simulation tools must be de-veloped to support the design and optimization of knittedstructures.With this need in mind, we have developed a process-oriented representation for modeling the topology of yarnsin weft-knitted textiles. Our initial focus has been on rep-resenting fabrics that can be manufactured by weft-knittingmachines consisting of two flat beds of needles and a singleyarn. Since it has been shown that the structures formed byyarns and their interactions dominate the mechanical be-havior of knitted textiles [2, 3, 4, 5], TopoKnit representsthese types of fabrics with yarns and the neighborhoodswhere they contact each other. The goal of our work isto define a low-level representation of knitted fabrics thathas the properties of both completeness (i.e. capable ofstoring all knitted fabrics that can be manufactured froma specific set of stitches) and validity (i.e. guaranteed torepresent only physically valid states of the fabric). Addi-tionally, the representation should support e ffi cient query ∗ Corresponding author
Email address: [email protected] (David E. Breen , ) algorithms for evaluation and generation of many types ofknitted structure models.To date a variety of models have been proposed for knit-ted textiles, covering a spectrum of length scales fromloop / stitch structures, to fabric swatches and completegarments. The focus of these models range from ideal-ized purely geometric models of yarn paths, to mechan-ical models of stitches, to simulation models of fabricsand clothing. There has also been abundant work on vi-sual models for accurately rendering textiles. This assort-ment of models have not always been compatible with eachother nor have they provided a conceptual / theoretical foun-dation on which to build the consistent, robust analysistools that are essential for evaluating manufacturability andproviding predictive simulation capabilities. TopoKnit is amajor step towards an approach capable of representing thetopological structures needed for all such models.Our ultimate goal is to develop a multiscale data struc-ture that can capture the topological, geometric and me-chanical properties / behaviors of knitted textiles. Thisyarn-level representation, where mechanical behaviors arederived from robust geometric models, which in turn arebased on accurate topological structures, should supportthe simulation and optimization techniques that are essen-tial for design operations that ensure manufacturability ofthe material. The representation should capture relation-ships, structures and phenomena at a variety of spatial andtemporal scales. These features include yarn geometry,frictional contacts, and deformations occurring at the loop,stitch, pattern, swatch and garment levels.As a first step toward achieving this goal we describehere a low-level representation, and associated data struc-ture, that can be used to derive the topological relationshipsof the yarns in the various stitches that make up a knitted Preprint submitted to Elsevier January 13, 2021 a r X i v : . [ c s . G R ] J a n abric manufactured on a 2-flatbed weft-knitting machine.For a given set of stitch operations, the data structure iscapable of representing all fabrics produced by this classof knitting machines; thus endowing it with the propertyof completeness. We see this process-oriented represen-tation, which we call TopoKnit, as providing the neces-sary foundation on which to build more detailed modelsof knitted textiles that include topology, geometry and me-chanics. TopoKnit not only provides a foundational datastructure that captures the fundamental primitives of knit-ted textiles, but it also includes a rich set of access func-tions that allows for queries of the features of the topo-logical structure of the fabric. This alleviates the require-ment for an explicit representation of what could be a verycomplex topology by performing on-demand evaluation ascertain information is needed by higher-level applications.Examples of applications that require this type of e ffi cienttopological representation include simulations of electricalcurrent, water, and heat flow through textiles [6, 7, 8].
2. Related Work
The early work on modeling knitted textiles focused pri-marily on defining and analyzing the geometric structureof knit stitches [9, 10, 11]. This work was remarkably donewithout the mathematical infrastructure of splines [12],which was not widely available until the 1970s. Muchlater work did utilize splines to describe the centerlinesof yarn geometry in knitted materials [13, 14, 15, 16].Follow-on research applied minimum energy analysis todetermine the shape of relaxed yarn loops in individualstitches [17, 18, 19, 20], as well as larger bulk propertiesof plain-knitted fabrics [21, 22, 23]. This work was ex-tended by Kyosev et al. [24] to include the compressionof the yarns in the loop. Sherburn, Lin, et al. [25, 26]developed a modeling approach / system working on mi-croscopic, mesoscopic and macroscopic scales to predictthe mechanical properties of textiles. Duhovic and Bhat-tacharyya [27] simulated the knitting process in order tounderstand how each of a yarn’s deformation mechanismscontribute to the overall deformation energy / behavior of ayarn in a knitted fabric. In recent work, Knittel, Wadekaret al. [28, 29, 30, 31] investigated helicoid sca ff olds as aframework within which to study the structure of knittedfabrics.The first system to model and visualize complete knittedfabrics was developed by Meissner, Eberhardt and Strasser[32, 33]. Their system (KnitSim) accepts Stoll knittingmachine commands (knit a stitch, transfer loops betweenbeds, and rack the beds) and simulates the knitting pro-cess to produce an explicit topological representation of aknitted material. The topology consists of Bonding Points(BPs), where yarns wrap around each other, and edges,representing yarns, that connect the BPs. Yarns are definedas a linked list of BPs. By making assumptions about thelength of yarns between BPs, a relaxation process is runto produce a 2D geometric layout for the fabric. Eber-hardt and Weber [34] then applied Breen et al.’s particleapproach [35] to simulate the draping behavior of knittedfabrics.In ground-breaking work Kaldor et al. [36, 37] simu-lated complete swatches and articles of clothing consistingof knitted fabrics by modeling the geometry and physics of individual yarns in these items. The yarns in the modelare defined with cubic B-spline curves surrounded by aconstant radius to produce a swept surface with a circu-lar cross-section. Yarn dynamics are dictated by both en-ergy terms (kinetic and bending) and hard constraints toprevent yarn extension and collisions, while friction inter-actions, a critical component of correct yarn behavior, areapproximated using a velocity filter that penalizes locallynon-rigid motion. While the topological structure of thefabric is implied by yarn contacts, it is not explicitly repre-sented in their model.The Kaldor et al. work was extended by Yuksel et al.[38, 39] to produce Stitch Meshes, an approach to generat-ing Kaldor-style knitted material models of clothing frompolygonal models that represent the clothing’s surface. Ashortcoming of this approach is that it utilizes stitches thatcannot be created on a knitting machine, thus limiting itsusefulness in a manufacturing setting. This project has re-cently been enhanced to generate graphical instructions forhand knitters [40]. Aspects of this work were utilized byLeaf et al. [41] to produce an interactive design tool forsimulating swatch-level patterns for knit and woven tex-tiles. To improve relaxation time, they employ a GPU im-plementation using periodic boundary conditions to sim-ulate modeling unit cells. Stitch Meshes have also beenused to model crocheted fabrics [42].Igarashi et al. [43, 44] developed a technique for gener-ating hand-knitting patterns from 3D models, along withan interactive design and visualization system. In relatedwork, McCann, et al. [45, 46, 47, 48] have developed algo-rithms that can generate knitting machine commands basedon a variety of polygonal models as input. These algo-rithms allow for the interactive design of 3D shapes,whichcan then be manufactured on a commercial knitting ma-chine. In related work, Popescu et al. [49] describean approach for generating an automated knitting patterngiven a 3D model, without being constrained to devel-opable surfaces. Motivated by Narayanan et al. [46], Kas-par et al. [50] introduce an interactive system which al-lows users of di ff erent skill levels to create and customizemachine-knitted textiles.Cirio et al. [51] define a topological representation ofknits consisting of a limited set of stitches, in contrast tothe yarn-geometry-based approach of Kaldor et al. As withthe Yuksel et al. work, they incorporated stitches that arenot manufacturable on knitting machines. They are able togenerate geometric models for rendering from their repre-sentation and have defined simplified mechanical relation-ships on the topological structure that supports e ffi cientsimulation of the approximate physical behavior of theirvirtual knitted fabrics. Aspects of this work has recentlyincorporated yarn-level models to provide a more e ffi cientcomputational method for detailed cloth simulations [52].This work was extended by S´anchez et al. [53] to includesimulation of stacked layers with implicit contact handlingusing a Eulerian-on-Lagrangian (EoL) discretization.Similar to the Meissner et al. work, Counts [54] presentsa graph-based representation aiming to approximate the2D layout of knitted textiles. The developed algorithmsuse information from a simulation to generate a topolog-ical graph from a limited set of hand and machine knit-ting instructions. Using loops as its fundamental primi-tive, as well as the small set of supported stitches (knit and2ransfer), limits the yarn topology it can represent. Theapproach does o ff er the ability to generate machine knit-ting instructions from the graph, but its disadvantages in-clude not supporting increases / decreases and more com-plex stitches, and requiring a simulation of the knittingprocess to generate the graph.Finite Element Modeling (FEM) has been used to ana-lyze the mechanical properties of knitted fabrics. Liu etal. [2, 3, 55] perform simulations with solid yarn-level ge-ometric models [56], while Dinh et al. [57], Poincloux etal. [58] Liu et al. [59] and Sperl et al. [60] base simulationson a homogenized unit cell. All of these e ff orts simulatesimple weft-knitted textiles, i.e. their virtual fabrics onlyconsist of Knit and Purl stitches. Their approaches do notrely on an underlying topological model, which will makeit di ffi cult to extend them to more complicated knitted fab-rics constructed from di ff erent types of stitches.TopoKnit improves upon previous work by providing ageneral topological representation of fabrics that can beproduced by flatbed weft-knitting machines with a stan-dard set of stitches. Our work stands apart from the Kaldoret al. work, which simply modeled the geometry of theyarns in Knit and Purl stitches, without representing theunderlying topology of the knitted structures. Our focuson incorporating process-based features in our model pro-vides critical manufacturability properties not found in theYuksel et al. and Cirio et al. work, which describe materi-als that cannot be manufactured on knitting machines. TheMcCann et al. work does not create a model of a knittedmaterial, but instead makes assumptions about the physicalsize of a single stitch in order to generate knitting machineinstructions that produce actual fabric.While Meissner et al.’s topological model utilizes sim-ilar primitives as TopoKnit, with Bonding Points (BPs)(our Contact Neighborhoods (CNs)) connected by yarnedges, there are significant di ff erences between the meth-ods and capabilities of the two approaches. They generatea topological data structure from a limited set of low-levelmachine instructions, an approach that requires a simula-tion of the knitting process. We utilize a process-orientedapproach based on higher-level stitch commands, whichcaptures how the stitches modify an all-Knit-stitch struc-ture and does not require a knitting simulation. Their ap-proach is more limited than ours in that they assume that arow of BPs only interacts with the BPs from the previousrow. This is clearly not the case with more complicatedstitch patterns, as can been seen in some of our examples,e.g. Figures 18, 19 and 24.Meissner et al.’s results are presented in low resolutionand are di ffi cult to interpret. Some of their results appearto be topologically incorrect, unphysical and generatedfrom unexplained machine commands and stitchingscenarios. They do not provide su ffi cient evidence toevaluate the correctness of their results. For example, theydo not o ff er the input instructions and resulting topologygraphs for their geometric results. Additionally, they donot provide the technical information needed to evaluatethe generality and robustness of their approach, e.g. thedetails on how to generate the BP data structure frommachine instructions.
3. Fabrication of Weft-Knitted Textiles
Figure 1: A single stitch,with its “legs” holdingthe “head” (upper loop)of the stitch below.
The loop is the fundamentalstructural element of knitted tex-tiles. A new loop is formed whena yarn is drawn through a pre-viously existing loop, as seen inFigure 1 . When this process isrepeated across a row, and thensubsequently again in other rows,the fabric is formed [1]. Whenthe yarn is drawn through theloop(s) held on the needle fromback to front, a Knit stitch is cre-ated, as shown in Figure 2(a). AKnit stitch can be distinguishedby the small “v” shapes visible onthe fabric, formed by the verticalyarns of the stitches. When theyarn is drawn through the loop(s)held on the needle from front toback, a
Purl stitch is created (Figure 2(b)), which is dis-tinguishable by the horizontal sequence of small curvesvisible on the fabric, formed by the heads and tails of thestitches. It is important to note that Knit and Purl stitchesare structurally the same, however the side from whichthey are viewed determines their labeling in the knittedstructure.Additionally, a number of other stitches can be formed,which may be combined to produce a vast variety ofknitted textiles. These stitches include:
Transfer stitch
A Transfer stitch is produced when a Knit or Purl stitchis created and then its head loop is transferred, via asequence of needle bed transfers and rackings, to anotherneedle location. The Transfer stitch presented in Figure4(a) transfers the loop one needle to the left, however,depending on the type of Transfer stitch there can beup to three loop movements to the left or right. Whena new yarn comes to the needle holding the transferredloop, both overlapping loops will be knit together. Thetranferred loop is highlighted in magenta in Figure 4(b).
Tuck stitch
A Tuck stitch is created when a yarn is tucked onto theneedle and pulled up, instead of being pulled through theheld loop. The tucked loop is held on the needle togetherwith the loop from the previous row, as shown in Figure5(a). The needle holds both loops, which will be knittedtogether when a stitch instruction is executed above it onthe next row. The tucked loop is highlighted in magenta inFigure 5(b).
Miss stitch
Similarly to the Tuck stitch, during the execution of aMiss stitch the needle holds the loop from the previousrow, but the new yarn is not hooked by the needle. Insteadthe yarn passes by, creating a horizontal segment of yarnacross the front or the back of the held loop. The resultinghorizontal yarn is highlighted in magenta in Figure 6(b). Figures 1,2(a)(b) to 6(a)(b), 7(a) and 8(b) were partially producedwith the Shima Seiki SDS-One APEX3 KnitPaint system. igure 2: (a) All-Knit pattern. (b) All-Purl pattern. (a) (b) (c) Figure 3: A Knit stitch is created by pulling a loop of yarn through a loopheld from the previous row. (a) Row of loops. (b) Knit stitches producedfrom another row of stitches. (c) Topological representation. (a) (b) (c)
Figure 4: A Transfer stitch is created when the loop of a Knit or Purlstitch is transferred up to three needle positions away to the left or right. (a) (b) (c)
Figure 5: A Tuck stitch is created by tucking a yarn onto a loop held fromthe previous row, instead of creating a new stitch. (a) (b) (c)
Figure 6: A Miss stitch is created when the needle holds a loop from aprevious row as the yarn passes by, without knitting a new stitch.
Empty stitch
An Empty stitch specifies that no machine operation willbe executed for a specific needle. Therefore, no yarn islooped on the needle at that location.These six stitches (Knit, Purl, Tuck, Miss, Transfer andEmpty) are the fundamental stitches needed to create mostknitted textiles, and can be combined to generate com-plicated knitted patterns. TopoKnit supports all of thesestitches; thus allowing for a broad representation of knit-ted fabrics.
4. Modeling Spaces, Primitives and Mappings
When developing a model that supports the evaluationof the validity, manufacturability and structural integrityof a particular material, it is critical to define and assessthe configuration spaces associated with the material andthe expressiveness of the primitives that exist within thesespaces.When modeling knitted textiles, three spaces are avail-able for primitive definition. The first is the configurationspace of the knitting machine. This would include model-ing the needles, racking beds, carriages and yarn carriers ofthe machine, their motion and their interaction with eachother and with yarns. While the advantage of this spaceis that it can provide information about and insight intothe manufacturing process, it requires a simulation pro-cess to produce a virtual version of the material. Whilethis approach / space can be employed to produce knittingcommands for manufacturing a knitted fabric [45, 46, 47],it does not provide a representation of the material itself.Since we wish to create a representation that is machineindependent and able to model materials produced on allflatbed weft-knitting machines, this space was deemed toorestrictive for our purposes.The second is the fabric space of the material itself,which is a static fully evaluated space where the struc-tures of the manufactured fabric are directly represented.For example, a plausible topological model of any fabriccould be a cell complex where 0-cells represent all con-tacts between yarns, oriented 1-cells correspond to yarnsegments connecting adjacent contact points, and oriented2-cells could be used to represent the yarn loops. The ad-vantage of this space is that allows for validity checkingof the fabric, for example topological correctness, but thedisadvantage is that the indirect property of manufactura-bility is more di ffi cult to assess and enforce. Additionally,without modeling the manufacturing process, determiningthe relationship between machine parameters and materialcharacteristics is problematic. Given the nearly countlesspossible combinations of stitches and the complex low-level structures that these combinations can produce, it isdi ffi cult to create a single static data structure that is guar-anteed to accommodate the topology and geometry of allpossible fabrics. For example, representing topology of aKnit or Purl stitch may be straightforward, but the topolog-ical structure of the combination of other stitches, such asTransfer, Miss or Tuck stitches, is far less obvious. Our work focuses on modeling knitted textiles withina process space , an intermediate space between machinespace and fabric space. This space captures aspects of both4achine and fabric space, as it includes some structures ofthe material, as well as how those structures are manipu-lated by the machine during the knitting process. Processspace models the abstract processes that lead to the for-mation of the material. In our work we focus on the pro-cesses that locally manipulate yarn loops at the stitch com-mand level. It is the interlocking of these loops that formthe central structures that hold a knitted fabric together. Acontiguous block of stitches may be grouped together intoswatches that can be repeated to produce a whole fabric.Additionally, the loops may be moved to other needles,both on the front and back beds of a knitting machine inorder to create even more complex stitches.The two critical components of the material that playa central role in this process are the yarn and the yarncrossings where the stitches connect with each other. Ourprocess-oriented representation has the yarn crossing asits primary primitive, with the yarn being implicitly de-fined as the primitive that connects yarn crossings. Theknitting process is then described as the creation and ma-nipulation of these yarn crossings. Since the interactionof yarns at a crossing and the connections between yarncrossings may be complex, we encapsulate this complex-ity in a primitive we call a Contact Neighborhood (CN).This is a primitive which does not explicitly represent thegeometry of the crossing yarns or the adjacencies betweencrossing yarns. The manipulations / movement of the CNs,for example via a Transfer stitch, are defined via mappingsthat change their location and possibly their state in thefabric. Thus, the topological structure (a cell complex) un-derlying the fabric is constructed by specifying, transform-ing and interconnecting CNs as explained below.The process of knitting defines a natural bivariate pa-rameterization of the resulting fabric. Machine weft knit-ting uses a row of k needles. A single yarn is carried acrossthese needles in a back-and-forth fashion. Each pass of theyarn may be labeled with integer l . Therefore each stitchlies in a coordinate grid and has a unique ( k , l ) grid loca-tion. The two indices ( k , l ) produce a parameterization overthe surface of the knitted material. The definition of CNsand the way that they interconnect capture the inherent 2Dtopological structure of knitted textiles. The fabric can be described in terms of loops, but itsgeometric and mechanical properties are determined bylower-level components, yarns and their “contacts”, whichis why we chose Contact Neighborhoods (CNs) and theyarns that connect them to be the fundamental primitivesof our knitted textile data structure. Loops and stitcheswere deemed to be too coarse as primitives because cer-tain stitch operations can create structures that span severalneedle locations and yarn rows or produce non-symmetricloops. While most loops are well-defined symmetric struc-tures, there are cases where that symmetry is broken andthe four CNs that define the loop are significantly di ff er-ent. Additionally, certain stitch combinations can producecomplex structures that require more representational res-olution than is available at the loop / stitch level.While yarns come in many types, e.g. staple (twistedshort fibers), monofilament (a single extruded material),and multifilament (twisted monofilaments), our approachassumes that the yarn, as compared to its constituent fibers, (a) (b) Figure 7: (a) A single stitch is represented by the potential CNs (whitedisks) of its upper loop and the actualized CNs (grey disks) where its legscross with the previous loop. (b) Topological representation of the stitchshowing the CNs and the edges (yarns) that connect them. The actualizedCNs consist of the contact point between yarns and four incident, directededges. The potential CNs consist of two incident edges and a potentialcontact point. is the smallest physical element that needs to be directlymodeled when simulating knitted materials. Yarns mayhave complex, non-linear properties, but these may belumped without the need for modeling the individual fibersthat make up the yarn. Previous work has shown that theshapes of the yarns in stitches play a significant role inthe overall mechanical behavior of knitted materials [2, 3],irrespective of the deformation properties of the yarns.Therefore we chose the yarn as the lowest-level primitiveto provide the connection between CNs.A yarn’s direction is defined by the direction of the car-rier movement at the time of the CN instantiation. In gen-eral the direction of a yarn alternates left and right as eachrow of stitches is formed. The labeling / indexing of CNsis slightly di ff erent from the labeling of the needles andyarns. Since the loop formation process generates two CNsfor each stitch, each needle k is associated with two CNs(2 k and 2 k +
1) in the CN’s i coordinate. A yarn’s l indexmaps directly to the CN’s j coordinate. There are three types of CNs, with each CN having aunique identifier ( i , j ), the location in the CN grid whereit is first instantiated. The two main CNs are the poten-tial CN (PCN) and the actualized CN (ACN). PCNs arecreated when a yarn passes over a needle and it hooks theyarn, creating a loop. The PCNs are defined at the headof the loop and mark a location on a yarn where an ACNcould be created by intertwining with another yarn. A PCNis defined by a potential contact point and two directed in-cident edges, as seen by the white disks and two edgessurrounded by dashed rectangles in Figure 7.A PCN is actualized into an ACN when the associatedloop is used to create a stitch with another yarn, i.e. whenan actual yarn crossing is created. An ACN is defined bya contact point and four directed incident edges, as seenby the grey disks and four edges surrounded by dashedrectangles in Figure 7. CN actualization does not have tooccur at the location where the PCN is created. The PCNmay be transferred to another location and converted intoan ACN by a stitch at the new location.The CNs for a single Knit stitch are shown in Figure 7.It should be noted when a Knit stitch is executed at loca-5 igure 8: A 3x3 all-Knit stitch pattern: (a) Stitch pattern. (b) Resultingloops. (c) Corresponding Contact Neighborhoods. tion ( i , j ) it actualizes the PCN present at ( i , j ) and createsa PCN at ( i , j + × k , l ) indexing to CN ( i , j )indexing, an M × N block of stitches produces a 2 M × ( N + i , j ) its state is de-fined as Empty (E). This may occur when the needle didnot hook the yarn during the associated stitch operation,e.g. the Miss stitch, or when the yarn was not pulled overthis location, e.g. outside the boundary of the fabric. Since knitted textiles consist of more complicatedstitches than just Knit and Purl, additional information isrequired to specify how the knitting process manipulatesthe CNs after they have been created from the loop forma-tion process. For example, a Transfer stitch first producesa Knit or Purl stitch (thus creating ACNs at its legs andPCNs at its head), but then transfers, i.e. moves, the headof the stitch to a another nearby needle to its left or right.See Figure 4. These manipulations can be represented bymappings that capture the movement of the CNs and theirstate as they are transformed. The mappings that may beapplied to CNs include two pieces of information,1. an actualization value that specifies the state of theCN ( i , j ) at its final location,2. a vector that defines the CNs relative movement fromits initial location in the CN ( i , j ) grid.These mappings specify an incremental, local transforma-tion, i.e. the first immediate step in what could be a multi-step movement of the CN through the fabric. For example,a loop may be transferred to another needle, the loops at (a) (b) Figure 9: (a) Multiple consecutive Tuck stitches produce unanchored CNs(UACNs), displayed as squares. (b) Knit stitches executed on needleswith no yarn loops also produce UACNs. that needle could be tucked up to the next row of stitches,then another loop could be transferred onto the tucked des-tination. The incremental form of the mappings supportse ffi cient, on-demand queries of the model, which is an un-evaluated representation of the local processes that aggre-gate to form the final knitted textile.Tuck and Miss stitches apply di ff erent manipulations tothe PCNs, moving them vertically, rather than horizontally.The Tuck stitch (Figure 5) shifts the PCNs ( i , j ) and ( i + , j ) up to the next row of stitches and overlays them onPCNs ( i , j +
1) and ( i + , j + j (cid:48) th yarn the j + (cid:48) th CNs defined for this stitch (which areEmpty) shift down one unit into the j (cid:48) th row. Given thehorizontal and vertical shifts that may occur, PCNs mayend up at a di ff erent location and their actualization statemight change or remain the same.
5. Data Structure
We have developed a data structure based on theprocess-oriented representation of Contact Neighborhoods(CNs) and associated mappings. The data structure canbe populated with data derived from an M × N set ofstitch instructions (e.g. Knit, Purl, Tuck, etc.) and pro-duces a 2 M × ( N +
1) array of CNs. The ( i , j ) index intothe array e ff ectively provides a unique ID for the CN cre-ated at this position in the fabric and also specifies a lo-cation in the ( i , j ) grid for other CNs that move throughthe fabric. There is a direct relationship between the ( m , n )stitch instruction and the values stored at the four associ-ated (2 m , n ), (2 m + , n ), (2 m , n + m + , n +
1) CNs.See Figure 7. At each ( i , j ) element in the CN array threeparameters are stored, which fully specify the CN that iscreated by the associated stitch instruction at that parame-terized location in the knitted fabric, as well as informationabout the stitch itself.The three parameters fall into two categories, location-based and CN-based. Location-based parameters, ofwhich there is only one, store information that is specificto that ( i , j ) location. CN-based parameters provide detailsabout the CN that is created at location ( i , j ), but whichmay be shifted to another location. The three parametersare: stitch type ST, actualization value AV and the move-ment vector [ ∆ i , ∆ j ] MV. Each element in the data struc-ture therefore takes the form of (ST, AV, MV). The one location-based parameter (ST) gives informa-tion about the type of stitch to be formed when actualizingCNs that end up at location ( i , j ). For example, if a Knit6 nit, Purl and Transfer Stitch foo j CN value before stitch execution j CN value after stitch execution j + | Purl) j + | P, ACN, [0,0] null, PCN, [0,0] null, PCN, [ ∆ i ,0]null, PCN, [ ∆ i ,0] K | P, PCN, [ ∆ i ,0] null, UACN | PCN, [0,0] null, UACN | PCN, [ ∆ i ,0]null, UACN, [ ∆ i ,0] K | P, UACN | ACN, [ ∆ i ,0] null, UACN | PCN, [0,0] null, UACN | PCN, [ ∆ i ,0]null, E, [0,-1] K | P, E, [0,-1] null, UACN | PCN, [0,0] null, UACN | PCN, [ ∆ i ,0] Table 1: Values set at data structure elements ( i , j ) and ( i , j +
1) when processing Knit, Purl and Transfer stitches. stitch is to be knitted at ( i , j ), this would be specified witha ‘K’ in the corresponding element in the data structure.A ’P’ is stored for a Purl stitch. The stitch type parametervalue determines how a CN at this location is actualized,whether the yarn is drawn through the loop(s) from back tofront (Knit) or from front to back (Purl). In both of thesecases firm contacts are formed between yarns via the twist-ing of the legs of a loop with the head of another loop, asseen in Figure 7(a). Note that since two CNs are createdwhen a loop is formed, the stitch type for locations ( i , j )and ( i + , j ) will be the same. The AV parameter indicates if a CN has been definedand, if so, it specifies the state of the CN as a result of thestitches executed during the knitting process. This param-eter can take four values: PCN, ACN, UACN and E, asexplained in Section 4.2.The MV parameter [ ∆ i , ∆ j ] indicates whether the CN isbeing shifted in either the horizontal or vertical direction.In the case of a Knit or Purl stitch, ∆ i and ∆ j are both 0,but when using other stitches, such as the Transfer stitch,their values would depend on the amount and direction ofthe movement needed for that specific stitch. A “one nee-dle movement to the left” Transfer stitch (See Figure 4),has ∆ i equal to -2 and ∆ j equal to 0. Note that CNs aremoved and not loops, which is why the CN is shifted twolocations to the left rather than one. For a Tuck stitch, thevector is [0 , i , j ), a CN may already exist at this location fromthe processing of a stitch instruction at ( i , j − , i , j +
1) the yarn passes throughand the CN that was supposed to be defined at ( i , j +
1) isnow shifted downward with MV [0 , − Given an M × N array of stitch instructions, a CN gridof size (2 M , N +
1) is allocated. Each element in the gridis initialized as an Empty stitch, with the values (null, E,[null,null]), except the first row which we assume containPCNs due to “cast-on” stitches that stabilize the bottom ofthe fabric. The stitch instructions are processed and CNvalues are assigned in a row-by-row, alternating left-rightthen right-left order, similar to the knitting process theyrepresent. In general the data is written to these CNs inpairs, the lower pair, then the upper pair. The pre-conditionstate of the lower pair of CNs depends on the stitch instruc-tion executed below them in the n − m , n ) stitch instruction currently being executed,determine if and how the lower and upper pairs of CNs willbe modified. Table 1 details how information related to Knit, Purland Transfer stitch instructions is written into the CN datastructure, depending on the pre-condition parameter val-ues for the associated ( i , j ) element. When modifying thelower CNs (the j cells) two actions are consistently appliedto the data structure values: A Knit or Purl stitch type iswritten in the ST parameter and the MV parameter is leftunchanged. The AV parameter remains unchanged for a K K K K n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0]K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0]n, PCN, [0,0] n, PCN, [0,0] n, UACN, [0,0] n, UACN, [0,0] n, UACN, [0,0] n, UACN, [0,0] n, PCN, [0,0] n, PCN, [0,0]K, ACN, [0,0] K, ACN, [0,0] n, PCN, [0,1] n, PCN, [0,1] n, PCN, [0,1] n, PCN, [0,1] K, ACN, [0,0] K, ACN, [0,0]K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0]
K T T KK K K K n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0]K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K , UACN, [0,0] K , UACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0]K, ACN, [0,0] K, ACN, [0,0] n, ACN, [0,1] n, ACN, [0,1] n, ACN, [0,1] n, ACN, [0,1] K, ACN, [0,0] K, ACN, [0,0]K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0]
K K K KK T T KK K K K oT pqqTaTE as qy f Figure 10: Determining if a UACN is anchored. (top) A row of Knit(K) stitches is written to the data structure. The resulting topology graphis on the upper right. (middle) Two Tuck (T) stitches are executed inthe next row. This tucks up the CNs in the second row and creates fourUACNs in the third row. The changes to the data structure are highlighted.(bottom) Another row of Knit stitches are written to the data structure.The outer UACNs are changed to ACNs, because they are connected toACNs one row down and one column over. The tucked up loops areactualized (converted to ACNs) by the Knit stitches. uck and Miss Stitch oo j CN value before stitch execution j CN value after stitch execution j + + ∆ i ,0] null, PCN, [ ∆ i ,1] null, UACN, [0,0] null, E, [0,-1]null, UACN, [ ∆ i ,0] null, UACN, [ ∆ i ,1] null, UACN, [0,0] null, E, [0,-1]null, E, [0,-1] null, E, [0,-1]* null, UACN, [0,0] null, E, [0,-1] Table 2: Values set at data structure elements ( i , j ) and ( i , j +
1) when processing Tuck and Miss stitches. *Writing a Tuck and Miss stitch above a Missstitch requires special processing away from the j cell, as described below. transferred PCN (a PCN with a non-zero ∆ i ) and an Empty(E) CN state. AV is modified to ACN for a stationary PCN(a PCN where ∆ i = j + j cell is an ACN or if another CN is moved to the j cell. Otherwise, no CN exists at the j cell, which is one ofthe conditions for being unanchored; thus the j + ∆ i , ∆ i canhave the values ± , ± , ±
6, depending on the direction andmagnitude of the specified horizontal shift. See Figure 4.Figure 10 details how UACNs are written and possiblymodified while the CN data structure is being populatedwith Knit and Purl stitches. It consists of a stitch pattern,the associated topology graph and data structure elements.The top diagram shows the state of the data structure andthe topology graph after four Knit stitches are processed.Given that the data structure is initialized with a row ofPCNs, the Knit stitches actualize them and PCNs are writ-ten in the next row up. The Knit stitches in the secondrow produce the same result. The two Tuck stitches write‘1’ to the ∆ j component of the associated CNs and createUACNs above them.Note at this point there are two sets of CNs at the fourinterior CN locations along the top of the structure. FourUACNs (designated with squares) from the teal yarn go-ing right-to-left and four PCNs (designated with circleswith white centers) from the two magenta loops that weretucked up one row. When the top row of Knit stitches arewritten to the data structure, the UACNs in the j row areexamined to determine if they might be anchored. TheUACNs in the 3rd and 6th columns are anchored becausethey are connected to a local ACN one row down and onecolumn over. The Knit stitch therefore actualizes them andtheir state is changed to ACN. The interior UACNs arenot directly attached to ACNs in a lower row and there-fore do not change their state. The PCNs tucked up from alower row intertwine with the top yarn and are actualizedto ACNs.For more complex stitch patterns changing the state ofan UACN to anchored and then actualized can require non-local information. For example, an UACN may be con-nected to an ACN in a lower yarn row, but several needle positions away, which can be seen in Figure 24. The lowerACN does anchor the upper CN. Determining this config-uration and change of status requires tracing the yarn fromthe UACN to a possibly faraway CN, a non-local opera-tion. Wanting the process of initially populating the datastructure to be based on local information only, we decidedto determine the final state of these UACNs at a later time,during the yarn tracing procedure. Table 2 details the parameter values that are written tothe CN data structure for Tuck and Miss stitches. In thelower CNs ( j cells), the ∆ j component of the MV param-eter is set to 1, except for the Miss stitch precondition( ∆ j = − ff ected by each stitch instruction. Since Tuck andMiss stitches e ff ectively pull up the yarns held on the nee-dle, a column of these stitches will pull the yarn up multi-ple rows. In order to capture this behavior, when writing aTuck or Miss stitch above a Miss stitch, we move down thecolumn looking for the first cell with a positive ∆ j value.Once found, this cell’s ∆ j value is then incremented by 1,indicating that associated CN has been pulled up one morerow.The j + i , j ). Thus the j + j +
1, since the needle does not hook thetraversing yarn. Thus the AV value is set to E (Empty) andthe ∆ j is set to -1, signifying that the yarn that should havepassed through this location can be found in the next rowdown.The special processing needed for Miss stitches is fur-ther explained in Figure 11. First, a row of Knit stitchesare written to the data structure. The next row has a Missstitch surrounded by Knit stitches. The Miss stitch changesthe PCN’s ∆ j to ‘1’ and writes “(null, E, [0,-1])” to thecell above. The next row has the same stitches. In thiscase, the cell values of the j cell are left unchanged, andthe CNs above the Miss stitch are also set to “(null, E, [0,-1])”. Note though that the ∆ j values of the CNs that arepulled up another row have been set to ‘2’. The top row ofKnit stitches actualize the two exterior sets of PCNs fromthe third row Knit stitches and the PCNs created by theKnit stitch at the center of the first row.8 , PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0]K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0]n, PCN, [0,0] n, PCN, [0,0] n, E, [0,-1] n, E, [0,-1] n, PCN, [0,0] n, PCN, [0,0]K, ACN, [0,0] K, ACN, [0,0] n, PCN, [0,1] n, PCN, [0,1] K, ACN, [0,0] K, ACN, [0,0]K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0]n, PCN, [0,0] n, PCN, [0,0] n, E, [0,-1] n, E, [0,-1] n, PCN, [0,0] n, PCN, [0,0]K, ACN, [0,0] K, ACN, [0,0] n, E, [0,-1] n, E, [0,-1] K, ACN, [0,0] K, ACN, [0,0]K, ACN, [0,0] K, ACN, [0,0] n, PCN, [0,2] n, PCN, [0,2] K, ACN, [0,0] K, ACN, [0,0]K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K M KK M KK K K n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0] n, PCN, [0,0]K, ACN, [0,0] K, ACN, [0,0] K , E, [0,-1] K , E, [0,-1] K, ACN, [0,0] K, ACN, [0,0]K, ACN, [0,0] K, ACN, [0,0] n, E, [0,-1] n, E, [0,-1] K, ACN, [0,0] K, ACN, [0,0]K, ACN, [0,0] K, ACN, [0,0] n, ACN, [0,2] n, ACN, [0,2] K, ACN, [0,0] K, ACN, [0,0]K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0] K, ACN, [0,0]
K K KK M KK M KK K KK M KK K KK K K
Figure 11: Updating ∆ j of a Miss stitch. (top) A row of Knit (K) stitchesis written to the data structure. The resulting topology graph is on theupper right. (middle top) A Miss stitch is executed in the middle of thepattern in the next row. This pulls up the held yarn and the traversingyarn crosses to the next stitch. An Empty stitch is written at j +
1. (middlebottom) Another Miss stitch is executed above the previous one. The heldloop is pulled up another row. Note that its ∆ j has been incremented to2. (bottom) A final row of Knit stitches actualizes the held loop. Figure 12: CNs processed in a square wave order for a 3x3 all-Knit pat-tern. The highlighted CNs are described Section 6.1.2.
6. Topology Graph Algorithms
Given a stitch pattern, the TopoKnit data structure andassociated algorithms can generate a topology graph of aknitted textile created with a single yarn. See Figures 15 to23 for examples. The graph specifies how the yarn flowsthrough the fabric and how points on the yarn contact otherpoints on the yarn as it travels through the various stitches.The nodes in the graph, Contact Neighborhoods, representyarn crossings / intertwinings and the edges of the graphrepresent the yarn segments that connect the yarn cross-ings. The nodes of the graph are located at discrete ( i , j )locations in a 2D grid, which are related to the k (cid:48) th nee-dle that created the associated stitch with the l (cid:48) th row ofthe yarn. Zero, one or multiple nodes can be located at asingle ( i , j ) grid point. Once populated with local stitch information, algo-rithms may be applied to the TopoKnit data structure tocompute a variety of yarn-level topological data about thefabric produced by a given stitch pattern.
The main algorithm for extracting the yarn topology iscalled FOLLOW THE YARN and produces a sequentiallist of ( i , j ) locations that the yarn passes through as itcourses throughout the fabric. More specifically, each el-ement in the yarn path list is a location that contains anACN, i.e. this is a location where two or more yarns in-tertwine, with these ACN locations being sequentially or-dered along the length of the yarn. An integer that iden-tifies the current stitch row number, an important piece ofinformation needed when determining the connectivity ofan ACN, is also stored with the grid location.The algorithm starts at location (0 ,
0) (bottom left) inthe data structure and processes the CNs in a square-wavepattern as seen in Figure 12. The locations and associatedCNs are processed along this path because it captures theorder in which CNs are created and modified by the knit-ting process. The arrows on the sides of the figure indicatethe direction that the yarn is carried for that row of stitches,first left-to-right (magenta arrow), then right-to-left (tealarrow), and so on. The square-wave pattern defines whatwe call leg nodes and head nodes. In this pattern a legnode CN is first processed (node ( i , j ), assuming that theyarn direction is from left-to-right), followed by two headnodes (( i , j +
1) and ( i + , j + i + , j )). Note that with this pattern, twoyarns flow into and out of each CN (except at the top andbottom rows, which can be stabilized with “cast-on” and“bind-o ff ” stitches), once as a head node and once as a legnode. When representing an all-Knit pattern, all grid loca-tions will be added to the yarn path, which makes its topol-ogy match the square wave (See Figure 12). Therefore themappings for the other stitches e ff ectively encode the localtopological modifications that make the associated loopsdeviate from the default all-Knit structure. Algorithm 1
FOLLOW T HE Y ARN ( DS ) i , j , legNode , currentS titchRow ← , , T rue , yarnPath ← [] while There are CNs to process doif
ADD T O LIS T ( i , j , legNode , yarnPath , DS ) thenif legNode then locIn f o ← ( i , j , currentS titchRow ) else (cid:46) Head node locIn f o ← (FINAL LOCATION(i,j,DS),currentStitchRow) yarnPath . append ( locIn f o ) i , j , legNode , currentS titchRow ← NEXT CN ( i , j , legNode , currentS titchRow ) return yarnPath As seen in Algorithm 1, the ADD TO LIST algorithmis invoked for each CN processed in the square wave order,and determines if the CN should be added to the yarn path.If the ADD TO LIST algorithm returns True, the legNodestatus of ( i , j ) is checked. If it is a leg node, the ( i , j ) gridlocation of the CN is added to the yarn path list. Sinceonly head nodes are moved in the fabric during the knittingprocess, a leg node’s final location matches the location( i , j ) being processed. The FINAL LOCATION algorithmis called to determine a head CN’s final location in the ( i , j )grid.Once a CN is processed, the NEXT CN algorithm com-putes the next ( i , j ) location in the square wave, alongwith the leg node status of CN ( i , j ), and updates the currentS titchRow index if necessary. The two factors that determine whether a CN( i , j ) shouldbe added to the yarn path list are the CN’s leg node statusand its AV parameter. See Algorithm 2. Leg node CNsare processed first. The algorithm returns T rue if thereexists at least one actualized CN at location ( i , j ). Thissignifies that the upper yarn was intertwined with anotherlower yarn at this location. Head nodes require examiningthe CN’s AV parameter. Empty CNs (E), which can be partof a Miss stitch or outside the boundary of the fabric, arenot included in the yarn path list.UACN head nodes require additional inspection to de-termine if they have been anchored by another CN furtheraway along the yarn. This determination is performed byeither looking back to the previous element in the yarn pathor looking forward to find the next ACN to be inserted inthe yarn path. The direction of the inspection is based onthe structure of the square wave pattern and the paritiesof the i and j variables. The parity of j indicates if theyarn is going from right to left (even) or left to right (odd) Algorithm 2
ADD T O LIS T ( i , j , legNode , yarnPath , DS ) if legNode then numberO f ACNs ← LENGT H ( ACNS AT ( i , j , DS )) if numberO f ACNs > then (cid:46) Anchored CN is here return
True elsereturn
False else (cid:46)
Head node actualizationValue ← DS [ i ][ j ] . AV if actualizationValue == “ E ” thenreturn False else if actualizationValue == “ UACN ” thenif EVEN ( i ) == ODD ( j ) then (cid:46) Look backward( m , n ) ← Last ACN in yarn path else (cid:46)
Look forward( m , n ) ← Next ACN to be added to yarn pathf inalI , f inalJ = FINAL LOCAT ION ( i , j , DS ) if n < f inalJ then (cid:46) This CN is anchored DS [ i ][ j ] . AV ← “ ACN ” (cid:46) Update CN’s state return
True elsereturn
False else (cid:46)
An ACN or PCN return
True
Algorithm 3
FINAL LOCAT ION ( i , j , DS ) if j == lastRow then (cid:46) CNs in the last row don’t move return i, j else if DS [ i ][ j ] . ∆ i ! = then (cid:46) Move CN horizontally return
FINAL LOC RECURSIVE(i + DS[i][j]. ∆ i , j,DS) else (cid:46) Move CN vertically return
FINAL LOC RECURSIVE(i, j + DS[i][j]. ∆ j ,DS) across the head of the loop, thus determining if the previ-ous CN is at a lesser or greater i value. For example, thefirst processed head node of a stitch is connected to a legnode “behind” it along the yarn. The second head nodeis connected to a leg node “in front of” it along the yarn.The parity of i and j values captures this first / second rela-tionship, as seen in Figure 12. The lower circled CN hasan ( i , j ) value of (2 , ff erent theanchored check looks backwards. The upper circled CNhas value (2 , j value.The final block of the AV check returns True, becauseall ACN and PCN head nodes are added to the yarn pathlist. Head node CNs can move within the ( i , j ) grid, withtheir local movements encoded in the MV parameter.The FINAL LOCATION function aggregates the move-ment information to determine the final location of theCN( i , j ) in the ( i , j ) grid. Since a Transfer stitch actual-izes two leg nodes (by creating a Knit or a Purl stitch)and then shifts its newly created head nodes left or right,a held loop (represented by two CNs) cannot be shiftedvertically and then shifted horizontally; nor do horizon-tal CN shifts accumulate. Therefore, as seen in Algo-rithms 3 and 4, FINAL LOCATION first applies horizon-10 lgorithm 4 FINAL LOC RECURS IV E ( i , j , DS ) if DS [ i ][ j ] . S T == ( K | P ) then (cid:46) CN is actualized here return i, j else (cid:46)
Recursively accumulate vertical movements return
FINAL LOC RECURSIVE(i, j + DS[i][j]. ∆ j , DS ) Algorithm 5
ACNS AT ( i , j , DS ) ACNList ← [] for all CN ( i (cid:48) , j (cid:48) ) in the local 13 × doif ( FINAL LOCAT ION ( i (cid:48) , j (cid:48) , DS ) == ( i , j )) &&( DS [ i (cid:48) ][ j (cid:48) ] . AV == “ ACN ”) then ACNList . append (( i (cid:48) , j (cid:48) )) return ACNList tal movements, if any exist, before recursively calling FI-NAL LOC RECURSIVE to aggregate any possible ver-tical movements. See Figure 24. The final location isreached at a location where a Knit or Purl stitch is exe-cuted, which actualizes the CN moved to this location.
ACNS AT (Algorithm 5) determines which ACNs areultimately positioned at location ( i , j ) in the CN grid, af-ter the knitting process is complete. It computes in nearconstant time, since it executes the FINAL LOCATIONalgorithm on a small finite set of CNs in a local neighbor-hood of ( i , j ). It is only necessary to examine the localCNs because a loop of yarn can only be stretched a limitedamount before it or the needle holding it breaks. Conven-tional knitting wisdom holds that a loop of yarn can only bestretched / moved away three needle positions horizontallyor three yarn rows vertically. Additionally, since knittingis a sequential process, a loop at row j + × i − → i + j → j − i , j ). FINAL LOCATION is called foreach CN( i (cid:48) , j (cid:48) ) in the neighborhood, and if this CN’s finallocation is ( i , j ) and its AV state is “ ACN ”, it is added tothe returned ACN list.
After each CN is processed in the FOL-LOW THE YARN algorithm, the next CN in the squarewave is generated by the NEXT CN algorithm (Algorithm6). This algorithm usually invokes the SQUARE WAVEalgorithm, which in turn uses logic based on the values of i , j and legNode to compute nextI and nextJ . This logicwas determined by studying the path the yarn follows inan all-Knit pattern. Algorithm 6
NEXT CN ( i , j , legNode , currentS titchRow ) if BORDER CN ( i , j , legNode ) thenreturn i, j +
1, True, currentStitchRow + (cid:46) Go up 1 row else nextI , nextJ = S QUARE WAVE ( i , j , legNode ) legNode = ( nextJ == currentS titchRow ) return nextI, nextJ, legNode, currentStitchRow Algorithm 7
DRAW T OPOLOGY GRAPH () CNList = FOLLOW T HE YARN () n ← len ( CNList ) (cid:46) Draw the first disk if DS [0][0] . S T == K then DRAWDIS K (0 , , gray ) else (cid:46) Stitch type is P
DRAWDIS K (0 , , green ) (cid:46) Loop through the yarn list CNs for
CNIndex ← to n − do currentI , currentJ , currentS titchRow ← CNList[CNIndex] nextI , nextJ , nextYarnRow ← CNList [ CNIndex + (cid:46) Draw graph node if DS [ nextI ][ nextJ ] . AV == “ PCN ” then (cid:46) Last CN row
DRAWDIS K ( nextI , nextJ , white ) else (cid:46) Draw ACN disk if DS [ nextI ][ nextJ ] . S T == K then DRAWDIS K ( nextI , nextJ , gray ) else (cid:46) Stitch type is P
DRAWDIS K ( nextI , nextJ , green ) (cid:46) Draw graph edge legNode = ( currentJ == currentS titchRow ) if ODD ( currentS titchRow ) then yarnColor ← teal else yarnColor ← magenta if BORDER CN ( currentI , currentJ , legNode ) then DRAWLOOP ( currentI , currentJ , nextI , nextJ , yarnColor ) else DRAWARROW ( currentI , currentJ , nextI , nextJ , yarnColor ) if currentJ == nextJ then (cid:46) Checking for UACNs for testedI ← currentI to nextI doif DS [ testedI ][ currentJ ] . AV == “ UACN ” then DRAWS QUARES T ROKE ( testedI , currentJ , gray ) The new location is a leg node if nextJ equals currentS titchRow . If ( i , j ) is on the border of the stitchpattern, the j index, which identifies the row of the CN,and currentS titchRow are incremented and the leg nodestatus is set to True. This encodes that a yarn loops up tothe next row to a leg node position when it reaches the endof a row of stitches. The topology graph information extracted from the al-gorithms described in Section 6.1 can be visualized us-ing Algorithm 7. This algorithm iterates through the listof locations returned by Algorithm 1 and invokes di ff er-ent drawing routines to draw the nodes and edges of thegraph. To more easily identify the path of the yarn throughthe graph, two di ff erent line colors are used to representthe yarn. When knitting an even row, when the yarn flowsfrom left to right, the yarn / edge color is magenta. Whenknitting an odd row, when the yarn flows from right to left,the yarn / edge color is teal. The graph contains di ff erenttypes of CNs, and icons with di ff erent shapes and colorsare used to distinguish them from each other. Colored11attern Size ×
10 100 0.44330 ×
30 900 5.5140 ×
40 1,600 8.8150 ×
50 2,500 14.875 ×
75 5,625 29.0100 ×
100 10,000 48.0125 ×
125 15,625 71.6150 ×
150 22,500 111175 ×
175 30,625 142200 ×
200 40,000 240225 ×
225 50,625 307
Table 3: Computation times (in seconds) needed to generate and evaluaterepeating blocks of the stitch pattern in Figure 15. The first column con-tains the dimensions of the stitch pattern. The second column containsthe total number of stitches in the swatch and the last column containsthe time needed for the computation. disks are used for ACNs and PCNs, gray for knit ACNs,green for purl ACNs and white for PCNs. UACNs thatlie along horizontal yarns are detected by Algorithm 7 andgray squares are drawn to represent them at their grid lo-cations. Currently, we only display a single disk at anylocation ( i , j ), even if more than one CN ends up at the lo-cation. However, the total number of arrows going in andout of a node can provide information about the number ofCNs at a given location.Algorithm 7 loops through the locations of the ACNs,generated by Algorithm 1, that are sequentially orderedalong the yarn that courses through the fabric defined bythe given stitch pattern. At each iteration of the loop, thealgorithm draws an arrow from the current CN locationto the next CN location in the list. The arrow representsthe yarn that connects the two CNs and the direction ofthe arrow corresponds to the direction of the yarn duringthe knitting process. The arrow color is determined by theyarnColor variable, which is based on the parity (and direc-tion) of the current yarn row. When the current list elementis on the border of the fabric, three arrows are drawn whichloop the yarn around to the next row being visualized. Thefirst two arrows have the same color as the yarnColor valueand the last arrow has the other color, to show that a newrow is beginning.It is important to note when the current location and nextlocation in the yarn list have the same j value there mightbe UACNs existing between them. The algorithm checksall CNs between the current CN location and the next CNlocation and draws squares for CNs with actualization val-ues equal to UACN. A slightly modified version of Algo-rithm 7 can be used to generate row-by-row topologicalgraphs for a given stitch pattern as seen in Figure 16. Thisallows us to view the state of the topology graph as the fab-ric is being constructed and helps to highlight how the CNactualization values change during the knitting process.
7. Results
The TopoKnit representation and associated algorithmswere tested with 100 5 × ff ectiveness of our ap-proach to evaluating the topology of knitted fabrics. The Figure 13: Teal and magenta stitch pattern templates. C o m pu t a t i o n T i m e ( s e c . ) Number of Stitches
Computation time vs. Stitch number
Figure 14: Plot of timing values from Table 3 that demonstrates the lineartime complexity, as a function of the number of stitches, of TopoKnit’sevaluation algorithms. test patterns were generated by randomly selecting stitchesfor each cell in the teal and magenta areas in the gridspresented in Figure 13. The set of selected stitches in-cluded Knit, Transfer right, Transfer left, Tuck and Missstitches. All of the white cells were defined as Knitstitches. TopoKnit generated 100 correct topology graphsfrom these 100 stitch patterns. The correctness of our re-sults was confirmed by comparisons with graphical out-puts from the Shima Seiki SDS-One APEX3 KnitDesignsystem.Figures 15, 16 and 17 use the magenta template andFigures 18 and 19 use the teal template and produce com-plex yarn topologies from relatively simple combinationsof Knit, Transfer, Tuck and Miss stitches. Additionally anumber of other patterns were tested that included emptystitches around the pattern border to produce increases anddecreases in the fabric, as well as a set of (light green)3-level patterns, such as the ones in Figures 22, 23 and24. These additional tests also produced correct topologygraphs of the resulting fabrics.Figure 15 presents an example stitch pattern that in-cludes Knit, Transfer, Tuck and Miss stitches. The (a) fig-ure is the stitch pattern for this swatch. The (b) figure isgraphical output from the Shima Seiki SDS-One APEX3KnitDesign system for the stitch pattern. . The (c) figureis the topology graph of the resulting fabric automaticallygenerated by our algorithms.Figure 15(d) presents the initial populated data structureand 15(e) presents the state of the data structure after theupdates executed in the FOLLOW THE YARN algorithm. The (b) portions of Figures 15 to 27 were produced with the ShimaSeiki SDS-One APEX3 KnitDesign system.
Figure 15: Stitch pattern with a combination of Knit, Transfer, Miss and Tuck stitches: (a) Stitch instructions. (b) Simulation of stitch pattern. (c)Topology graph. (d) Corresponding data structure before evaluation. (e) Modified entries (highlighted in teal) in data structure after evaluation.
Note that UACNs have been updated to PCNs in the toprow and an ACN in the third row by Algorithm 1. Cells(4 ,
4) and (5 ,
4) in the data structure have a non-zero ∆ i ,which means that these two CNs have been shifted to theright as can be visually seen in the topology graph. Twointeresting locations in the diagram are locations (5 ,
3) and(6 , n × m stitch pattern, we canevaluate and visualize the topology of the pattern startingwith the first row, followed by the first 2 rows, and so on.This visualization allows one to see the intermediate statesof the data structure and the topology graph as the fabric isbeing knitted.Figure 17 presents a stitch pattern that creates a “hole”in the swatch with transfer stitches that shift stitch loopsaway from each other. As the head nodes of the stitches areshifted to the left and right, the knit stitches above them are not properly formed and produce a “ladder” of unanchoredCNs. These examples demonstrate that our approach is ca-pable of generating unusual and possibly challenging yarntopologies by representing and aggregating local CN mod-ifications.Figures 20 and 21 present stitch patterns that includecombinations of the Empty stitch (shown as an emptywhite cell) and transfer stitches in order to realize increases(widening) and decreases (narrowing) in the fabric. Thisallows TopoKnit to represent fabrics defined by more gen-eral, non-rectangular stitch patterns. Figures 22, 23 and 24present slightly larger stitch patterns that include 3-leveldeep combinations of Knit, Tuck and Miss stitches, whichdemonstrate TopoKnit’s ability to determine non-local CNconnectivity through the aggregation of local changes toCN state information. Figure 24 contains a pattern thattransfers CNs to the left and then shifts them upwards tworows with recursive calls to FINAL LOC RECURSIVE.Figure 25 presents two larger stitch patterns (19 × igure 16: The topology graph produced from a stitch pattern that includes Knit, Transfer, Miss and Tuck stitches. The descending diagrams present thetopological state of the fabric as it is knitted row by row. Figure 17: Stitch pattern with a combination of Knit and Transfer stitches: (a) Stitch instructions. (b) Simulation of the pattern. (c) Topology graph.The pattern creates a “hole” in the fabric and an ascending “ladder” of unanchored CNs. demonstrate that TopoKnit is capable of rapidly process-ing stitch patterns for larger fabric swatches. Additionallywe performed timing tests on a swatch that contains re-peating blocks of the stitch pattern in Figure 15 in orderto study the time complexity of TopoKnit’s evaluation al-gorithms. The values in Table 3 and the plot in Figure 14demonstrate that the computation time needed to generateand evaluate the TopoKnit data structure increases linearlywith the number of stitches in the modeled fabric. Thislinear behavior verifies that the individual evaluation algo-rithms execute in near-constant time.As for handling the edges of the fabric in all of the ex-amples, the CNs on the left and right boundaries are con-nected to the CNs either above or below them, dependingon the parities of their ( i , j ) IDs. For example, boundaryCNs whose ( i , j ) parities are the same, e.g. (odd,odd) or(even,even), connect to the CN above them in the grid withan outgoing yarn. CNs with di ff ering ( i , j ) parities are con-nected to the CN below them by an incoming yarn. As forthe top and bottom boundaries, when a pattern is actuallyknitted cast-on and bind-o ff stitch combinations are addedto the fabric to prevent the top and bottom edges from un-raveling. TopoKnit includes the topology for these special-ized stitches, but for visual simplicity they are not includedin our graph visualizations.
8. Discussion
It should be noted that TopoKnit’s algorithms arebased on several assumptions about the stitch patternsthat define the analyzed fabric. Applying a few simplerules / constraints on a fabric’s stitch pattern guarantees thestructural integrity (soundness) of the resulting fabric, andadditionally ensures that our algorithms execute correctly.A structurally sound knitted fabric is one where all of itsloops have been intertwined with another yarn. This prop-erty defines a knitted fabric that will not unravel. UsingTopoKnit terminology, all CNs that define the head of a loop must eventually be actualized in a structurally soundfabric.The restrictions imposed on the stitch patterns processedby TopoKnit are the following. 1) The stitches along theboundary of the pattern should be Knit or Purl stitches, orthe increase and decrease combinations in Figures 20 and21. 2) Empty stitches should only be defined on the “out-side” of the stitch pattern, i.e. an Empty stitch should notbe surrounded by non-Empty stitches. Note that an Emptystitch is di ff erent from an empty CN state, which can besurrounded by non-empty CNs, for example from a Missstitch. 3) Transfer stitches should not shift their head nodes(their loops) outside of the boundary of the stitch pattern,i.e. to an Empty stitch. An example of a stitch pattern thatis structurally unsound, violates the stitch rules and leadsto an incorrectly evaluated topology is one with a Tuckstitch along the side boundary. This creates an unanchoredCN along a side edge of the fabric, a situation that leadsto stitch unraveling. While the rules limit which stitch pat-terns may be represented and evaluated by TopoKnit, theystill allow for the modeling and analysis of a broad varietyof structurally sound knitted fabrics.We have described the query algorithms FINAL LO-CATION (Algorithm 3) and ACNS AT (Algorithm 5).These queries are central to the new TopoKnit query al-gorithms currently under development, which include de-termining the topological connections between CNs, theconnections between locations, as well as the ordering ofyarns at a certain ( i , j ) location and at arbitrary spatial yarncrossings. CN and location connectivity is important to allflow simulations (heat, water and electrical current) con-ducted on a fabric substrate. Yarn stacking informationwould be additionally informative to electric circuit simu-lations over a knitted fabric, assuming that di ff erent yarnsections could have di ff erent conductivity / resistance.For example, to compute the flow of water, heat or cur-rent through the yarns of a fabric, one needs to know howthe yarn is in contact with itself. The exchange of heat, wa-14a)(b) (c) Figure 18: Stitch pattern with a combination of Knit, Tuck and Transfer stitches: (a) Stitch instructions. (b) Simulation of the pattern. (c) Topologygraph. (a)(b) (c)
Figure 19: Stitch pattern with a combination of Knit, Miss and Transfer stitches: (a) Stitch instructions. (b) Simulation of the pattern. (c) Topologygraph.
Figure 20: An increase of the fabric using Transfer and Empty stitches: (a) Stitch instructions. (b) Simulation of the pattern. (c) Topology graph. (a)(b) (c)
Figure 21: A decrease of the fabric using Transfer and Empty stitches: (a) Stitch instructions. (b) Simulation of the pattern. (c) Topology graph.
Figure 22: Pattern with a 3-level combination of Knit and Tuck stitches: (a) Stitch instructions. (b) Pattern simulation. (c) Topology graph. (a)(b) (c)
Figure 23: Pattern with a 3-level combination of Knit, Miss and Tuck stitches: (a) Stitch instructions. (b) Pattern simulation. (c) Topology graph. (a)(b) (c)
Figure 24: Pattern with a combination of Knit, Transfer, Tuck and Miss stitches: (a) Stitch instructions. (b) Pattern simulation. (c) Topology graph.
Figure 25: Samples of larger stitch patterns and their corresponding topology graphs: (a) Simulation of a lace pattern. (b) Topology graph of the lacepattern. (c) Simulation for a cable pattern. (d) Topology graph of the cable pattern. ter, and current occurs where the yarn intertwines. The al-gorithm ACNS AT and FINAL LOCATION together pro-vide the list of locations of these yarn intertwinings. Theunder-development CONNECTED TO algorithm wouldprovide the connections between the contacts needed tocompute flow over the whole fabric. We also intend to in-tegrate TopoKnit’s topology and yarn ordering informationwith the work of Wadekar et al. [30] to extend their yarn-level geometric models to complex knitted fabrics. Thesemodels support rapid evaluation of the mechanical proper-ties of knitted fabrics.It is important to note that the data structure and algo-rithms presented in this work have been based on high-level stitch commands that encapsulate multiple lower-level machine commands, thus, the space of knitted struc-tures supported by TopoKnit is smaller than the space ofstructures generated from an arbitrary set of knitting ma-chine commands (e.g. rack a needle bed, move a loop be-tween beds, knit or drop a loop). These actions could beadded to the data structure, but would require modifica-tions of the algorithms. Also, initially we focused on stitchcommands that create CN pairs only in one of the needlebeds, thus, leaving out stitches that require CNs to be de-fined on both beds, such as the split stitch.
9. Conclusions and Future Work
In this paper we have proposed a process-oriented repre-sentation, TopoKnit, that defines a foundational data struc-ture for representing the topology of the yarns in weft-knitted textiles. We have defined a process space that in-cludes commonly used yarn-level operations, abstractedas mappings on yarn contact neighborhoods, produced bya weft-knitting knitting process. This space captures theessence of knitting processes in terms of their actions onyarns, but is independent of a particular machine architec-ture. In contrast to fabric space, the process space rep-resents the structure of the fabric implicitly, eliminatingthe need for an explicit, fully-evaluated representation ofits topology. Process space supports a concise, computa-tionally e ffi cient evaluation approach based on on-demand,near constant-time queries. We have defined the importantfeatures of this process space and designed a data struc-ture to represent it and algorithms to evaluate it. Throughthe testing of more than 100 stitch patterns, we demon-strate the robustness and e ff ectiveness of this representa-tion scheme.Work is underway to expand the scope, utility and ap-plicability of TopoKnit. Given the information in the data18a)(b) (c) Figure 26: A closer view of the lace pattern: (a) Stitch instructions. (b) Simulation of the pattern. (c) Topology graph. (a)(b) (c)
Figure 27: A closer view of the cable pattern: (a) Stitch instructions. (b) Simulation of the pattern. (c) Topology graph. i , j ) locationon a single needle bed. However, the data structure canbe extended to allow for creation of CNs on both beds at aspecific ( i , j ) location by including a separate CN array foreach of the beds. This would also allow us to extend theset of stitch commands supported by TopoKnit. Our futurework will also include algorithms to determine the stack-ing order of CNs at a specific ( i , j ) location, as well, as theordering of yarns where they cross in the fabric away fromCN locations. Acknowledgements
This work was partially supported by a National Sci-ence Foundation Graduate Research Fellowship underGrant No. DGE-10028090 / DGE-1104459 and NSF grantsCMMI-1344205 and CMMI-1537720.
References [1] D. J. Spencer, Knitting technology: a comprehensive handbook andpractical guide, Pergamon press, 1983.[2] D. Liu, D. Christie, B. Shakibajahromi, C. Knittel, N. Castaneda,D. Breen, G. Dion, A. Kontsos, On the role of material architecturein the mechanical behavior of knitted textiles, International Journalof Solids and Structures 109 (2017) 101–111.[3] D. Liu, B. Shakibajahromi, G. Dion, D. Breen, A. Kontsos, A com-putational approach to model interfacial e ff ects on the mechanicalbehavior of knitted textiles, Journal of Applied Mechanics 85 (4)(2018) JAM–17–1584.[4] E. Tekerek, D. Liu, B. Wisner, M. Matthew, D. Breen, A. Kontsos,Integrated investigation of the role of 3D architecture in the me-chanical behavior of knitted textiles, in: Proc. 18th European Con-ference on Composite Materials, 2018, pp. 2.15–10.[5] C. Knittel, D. Nicholas, R. Street, C. Schauer, G. Dion, Self-foldingtextiles through manipulation of knit stitch architecture, Fibers 3 (4)(2015) 575–587.[6] R. Vallett, C. Knittel, D. Christe, N. Castaneda, C. Kara, K. Mazur,D. Liu, A. Kontsos, Y. Kim, G. Dion, Digital fabrication of tex-tiles: An analysis of electrical networks in 3D knitted functionalfabrics, in: Micro-and Nanotechnology Sensors, Systems, and Ap-plications IX, Vol. 10194, International Society for Optics and Pho-tonics, 2017, p. 1019406.[7] C.-J. Hong, B.-J. Kim, Model-based simulation analysis of wickingbehavior in hygroscopic cotton fabric, Journal of Fashion Business20 (6) (2016) 66–78.[8] H. Shen, K. Xie, H. Shi, X. Yan, L. Tu, Y. Xu, J. Wang, Analysis ofheat transfer characteristics in textiles and factors a ff ecting thermalproperties by modeling, Textile Research Journal 89 (21-22) (2019)4681–4690.[9] F. Peirce, Geometrical principles applicable to the design of func-tional fabrics, Textile Research Journal 17 (3) (1947) 123–147.[10] G. Leaf, A. Glaskin, The geometry of a plain knitted loop, Journalof the Textile Institute Transactions 46 (9) (1955) T587–T605. [11] D. Munden, The geometry and dimensional properties of plain-knitfabrics, Journal of the Textile Institute Transactions 50 (7) (1959)T448–T471.[12] E. Cohen, R. Riesenfeld, G. Elber, Geometric Modeling withSplines, A K Peters, 2001.[13] A. Demiroz, T. Dias, A study of the graphical representation ofplain-knitted structures part I: Stitch model for the graphical repre-sentation of plain-knitted structures, Journal of the Textile Institute91 (4) (2000) 463–480.[14] A. Kurbak, O. Ekmen, Basic studies for modeling complex weftknitted fabric structures part I: A geometrical model for widthwisecurlings of plain knitted fabrics, Textile Research Journal 78 (3)(2008) 198–208.[15] A. Kurbak, O. Kayacan, Basic studies for modeling complex weftknitted fabric structures part II: A geometrical model for plain knit-ted fabric spirality, Textile Research Journal 78 (4) (2008) 279–288.[16] A. Kurbak, Geometrical models for balanced rib knitted fabrics parti: Conventionally knitted 1 × ff ord, Auto-mated geometric modelling of textile structures, Textile ResearchJournal 82 (16) (2012) 1689–1702.[27] M. Duhovic, D. Bhattacharyya, Simulating the deformation mech-anisms of knitted fabric composites, Composites Part A: AppliedScience and Manufacturing 37 (11) (2006) 1897–1915.[28] C. Knittel, Tools to predict and understand the self-folding behaviorof knitted textiles, Ph.D. thesis, Drexel University (2019).[29] C. Knittel, M. Tanis, A. Stoltzfus, T. Castle, R. Kamien, G. Dion,Modelling textile structures using bicontinuous surfaces, Journal ofMathematics and the Arts 14 (4) (2020) 331–344.[30] P. Wadekar, P. Goel, C. Amanatides, G. Dion, R. Kamien, D. Breen,Geometric modeling of knitted fabrics using helicoid sca ff olds,Journal of Engineered Fibers and Fabrics 15 (2020) 1–15.[31] P. Wadekar, L. Kapllani, C. Amanatides, G. Dion, R. Kamien,D. Breen, Geometric modeling of complex knitting stitches usinga bicontinuous surface and its o ff sets, Under review.[32] M. Meissner, B. Eberhardt, The art of knitted fabrics, realistic &physically based modeling of knitted fabrics, Computer GraphicsForum (Proc. Eurographics) 17 (3) (1998) 355–362.[33] B. Eberhardt, M. Meissner, W. Strasser, Knit fabrics, in: D. House,D. Breen (Eds.), Cloth Modeling and Animation, AK Peters, 2000,Ch. 5, pp. 123–144.[34] B. Eberhardt, A. Weber, A particle system approach to knitted tex-tiles, Computers & Graphics 23 (4) (1999) 599–606.[35] D. Breen, D. House, M. Wozny, A particle-based model for simulat-ing the draping behavior of woven cloth, Textile Research Journal64 (11) (1994) 663–685.
36] J. M. Kaldor, D. L. James, S. Marschner, Simulating knitted cloth atthe yarn level, ACM Transactions on Graphics (Proc. SIGGRAPH)27 (3) (2008) 65:1–65:9.[37] J. M. Kaldor, D. L. James, S. Marschner, E ffi cient yarn-based clothwith adaptive contact linearization, ACM Transactions on Graphics(Proc. SIGGRAPH) 29 (4) (2010) 105:1–105:10.[38] C. Yuksel, J. M. Kaldor, D. L. James, S. Marschner, Stitch meshesfor modeling knitted clothing with yarn-level detail, ACM Transac-tions on Graphics (Proc. SIGGRAPH) 31 (3) (2012) 37:1–37:12.[39] K. Wu, X. Gao, Z. Ferguson, D. Panozzo, C. Yuksel, Stitch mesh-ing, ACM Transactions on Graphics (Proc. SIGGRAPH) 37 (4)(2018) 130:1–130:14.[40] K. Wu, H. Swan, C. Yuksel, Knittable stitch meshes, ACM Trans-actions on Graphics 38 (1) (2019) 10:1–10:13.[41] J. Leaf, R. Wu, E. Schweickart, D. L. James, S. Marschner, Interac-tive design of periodic yarn-level cloth patterns, ACM Transactionson Graphics (Proc. SIGGRAPH Asia) 37 (6) (2018) 202:1–202:15.[42] M. Guo, J. Lin, V. Narayanan, J. McCann, Representing crochetwith stitch meshes, Proc. ACM Symposium on Computational Fab-rication (2020) 4:1–4:8.[43] Y. Igarashi, T. Igarashi, H. Suzuki, Knitting a 3D model, ComputerGraphics Forum (Proc. Pacific Graphics) 27 (7) (2008) 1737–1743.[44] Y. Igarashi, T. Igarashi, H. Suzuki, Knitty: 3D modeling of knittedanimals with a production assistant interface, in: Annex to Euro-graphics 2008 Proceedings, 2008, pp. 187–190.[45] J. McCann, L. Albaugh, V. Narayanan, A. Grow, W. Matusik,J. Manko ff , J. Hodgins, A compiler for 3D machine knitting, ACMTransactions on Graphics 35 (4) (2016) 49:1–49:11.[46] V. Narayanan, L. Albaugh, J. Hodgins, S. Coros, J. McCann, Au-tomatic machine knitting of 3D meshes, ACM Transactions onGraphics 37 (3) (2018) 35:1–35:15.[47] J. Lin, V. Narayanan, J. McCann, E ffi cient transfer planning for flatknitting, in: Proc. 2nd ACM Symposium on Computational Fabri-cation, 2018, pp. 1:1–1:7.[48] V. Narayanan, K. Wu, C. Yuksel, J. McCann, Visual knitting ma-chine programming, ACM Trans. Graph. 38 (4) (2019) 63:1–63:13.[49] M. Popescu, M. Rippmann, T. Van Mele, P. Block, Automated gen-eration of knit patterns for non-developable surfaces, in: Humaniz-ing Digital Reality, Springer, 2018, pp. 271–284.[50] A. Kaspar, L. Makatura, W. Matusik, Knitting Skeletons: Acomputer-aided design tool for shaping and patterning of knittedgarments, in: Proc. ACM Symposium on User Interface Softwareand Technology, 2019, pp. 53–65.[51] G. Cirio, J. Lopez-Moreno, M. A. Otaduy, Yarn-level cloth simula-tion with sliding persistent contacts, IEEE Transactions on Visual-ization and Computer Graphics 23 (2) (2017) 1152–1162.[52] J. J. Casafranca, G. Cirio, A. Rodr´ıguez, E. Miguel, M. A. Otaduy,Mixing yarns and triangles in cloth simulation, Computer GraphicsForum (Proc. Eurographics) 39 (2) (2020) 101–110.[53] R. M. S´anchez-Banderas, A. Rodr´ıguez, H. Barreiro, M. A. Otaduy,Robust eulerian-on-lagrangian rods, ACM Transactions on Graph-ics 39 (4) (2020) 59:1–59:10.[54] J. Counts, Knitting with directed graphs, Master’s thesis, Mas-sachusetts Institute of Technology (2018).[55] D. Liu, S. Koric, A. Kontsos, Parallelized finite element analysis ofknitted textile mechanical behavior, Journal of Engineering Materi-als and Technology 141 (2) (2019) MATS–18–1132.[56] P. Wadekar, V. Perumal, G. Dion, A. Kontsos, D. Breen, An op-timized yarn-level geometric model for finite element analysis ofweft-knitted fabrics, Computer Aided Geometric Design 80 (2020)101883.[57] T. Dinh, O. Weeger, S. Kaijima, S.-K. Yeung, Prediction of mechan-ical properties of knitted fabrics under tensile and shear loading:Mesoscale analysis using representative unit cells and its validation,Composites Part B: Engineering 148 (9) (2018) 81–92.[58] S. Poincloux, A.-B. Mokhtar, F. Lechenault, Geometry and elastic-ity of a knitted fabric, Physical Review X 8 (2) (2018) 021075.[59] D. Liu, S. Koric, A. Kontsos, A multiscale homogenization ap-proach for architectured knitted textiles, Journal of Applied Me-chanics 86 (11) (2019) JAM–19–1125.[60] G. Sperl, R. Narain, C. Wojtan, Homogenized yarn-level cloth,ACM Transactions on Graphics 39 (4) (2020) 48:1–48:16.cient transfer planning for flatknitting, in: Proc. 2nd ACM Symposium on Computational Fabri-cation, 2018, pp. 1:1–1:7.[48] V. Narayanan, K. Wu, C. Yuksel, J. McCann, Visual knitting ma-chine programming, ACM Trans. Graph. 38 (4) (2019) 63:1–63:13.[49] M. Popescu, M. Rippmann, T. Van Mele, P. Block, Automated gen-eration of knit patterns for non-developable surfaces, in: Humaniz-ing Digital Reality, Springer, 2018, pp. 271–284.[50] A. Kaspar, L. Makatura, W. Matusik, Knitting Skeletons: Acomputer-aided design tool for shaping and patterning of knittedgarments, in: Proc. ACM Symposium on User Interface Softwareand Technology, 2019, pp. 53–65.[51] G. Cirio, J. Lopez-Moreno, M. A. Otaduy, Yarn-level cloth simula-tion with sliding persistent contacts, IEEE Transactions on Visual-ization and Computer Graphics 23 (2) (2017) 1152–1162.[52] J. J. Casafranca, G. Cirio, A. Rodr´ıguez, E. Miguel, M. A. Otaduy,Mixing yarns and triangles in cloth simulation, Computer GraphicsForum (Proc. Eurographics) 39 (2) (2020) 101–110.[53] R. M. S´anchez-Banderas, A. Rodr´ıguez, H. Barreiro, M. A. Otaduy,Robust eulerian-on-lagrangian rods, ACM Transactions on Graph-ics 39 (4) (2020) 59:1–59:10.[54] J. Counts, Knitting with directed graphs, Master’s thesis, Mas-sachusetts Institute of Technology (2018).[55] D. Liu, S. Koric, A. Kontsos, Parallelized finite element analysis ofknitted textile mechanical behavior, Journal of Engineering Materi-als and Technology 141 (2) (2019) MATS–18–1132.[56] P. Wadekar, V. Perumal, G. Dion, A. Kontsos, D. Breen, An op-timized yarn-level geometric model for finite element analysis ofweft-knitted fabrics, Computer Aided Geometric Design 80 (2020)101883.[57] T. Dinh, O. Weeger, S. Kaijima, S.-K. Yeung, Prediction of mechan-ical properties of knitted fabrics under tensile and shear loading:Mesoscale analysis using representative unit cells and its validation,Composites Part B: Engineering 148 (9) (2018) 81–92.[58] S. Poincloux, A.-B. Mokhtar, F. Lechenault, Geometry and elastic-ity of a knitted fabric, Physical Review X 8 (2) (2018) 021075.[59] D. Liu, S. Koric, A. Kontsos, A multiscale homogenization ap-proach for architectured knitted textiles, Journal of Applied Me-chanics 86 (11) (2019) JAM–19–1125.[60] G. Sperl, R. Narain, C. Wojtan, Homogenized yarn-level cloth,ACM Transactions on Graphics 39 (4) (2020) 48:1–48:16.