kniterate notes 9

This is the ninth in a series of blog posts about the Material Programming Project. We are developing malleable knitting software for the Kniterate, a semi-industrial knitting machine. This post is about Auttoman, a new tool for structural knitting. The first post, on the Knitout project, is available here.

Annoyingly bad photo of B’s ottoman sample made with the Kniterate software (back, dark blue + yellow) and the equivalent sample made using Auttoman (front, bright blue + bright green). See how the fabric bulges in the middle where the elastic isn’t knit on the front bed.

B and I have been back at Chelsea this past week playing around with the Kniterate. There’s a sample that B has on the wall that I’ve always loved, which is made with a dense yellow elastic on one side, and a ridged, deep-blue mohair on the back. It has this amazing structure, and behaves in a really interesting way when you stretch it – the parallel columns of elastic give a really strong resistance, and it bulges in the center where they’re not present.

This style is called Ottoman, and is part of a family of techniques called ‘lifted stitch methods’, where stitches from lower down in a sample are lifted up the bed and hooked into later rows. The core technique is achieved quite simply: for every six rows of the mohair yarn knitted on the back bed, a row of elastic yarn is knit on the front and back beds, with the stitches held on the front needles in between rows. (this can also be done with non-elastic yarns, though the back bed yarn needs to be finer weight). This creates a kind of pleated texture horizontally in the fabric that’s densely elasticated in the vertical direction. By varying the placement of the front bed stitches, the density of the fabric can be changed significantly, and it can create some really compelling structures.

The first structure we made was the simplest possible – just using all the front bed needles, with no transfers between rows. Even this produced a really exciting material – there’s something really modern-feeling about it, and it was really satisfying to see how well it came out on the machine.

The first test of a basic ottoman. I really like the way that the colour on the front side changes subtly as the sample is stretched.

Programming Auttoman

A set of three ottoman samples (top, bottom right), and one plating sample (bottom left)

Building on the code from the Plating-Patternwitch demo we made for the Ink+Switch conference, I started prototyping a small tool that would allow someone to sketch an Ottoman pattern in Patternwitch, and have the code generated automatically. The main thing the code needs to do is recognise when to transfer a stitch that’s been on the front bed onto the back, which involves scanning the next row and finding which stitches need to be passed over.

prototyping the Auttoman code -- the section that handles the transfers outlined in red

The first test of the Patternwitch->Ottoman code, with a wavy, organic structure

We got this working pretty quickly, which is great – this kind of transfer planning on the Kniterate software is very laborious and manual, so getting this to work automatically feels like a really great example of how specialised software can really lend itself to fast prototyping of specific techniques.

Once I’d made a local version that I was happy with, I wanted to make the tool work end-to-end in Patchwork. After a slightly chaotic attempt to use the experimental tiling window manager for Patchwork (which was great but also broke a bunch of stuff), I decided to test this for now using parallel browser tabs.

Using a trick that I got from Chee, I made Auttoman into a separate script that can be called in the main one. This makes for much more succinct code, and starts to modularise variables that might later be varied using the interface, like changing the number of back bed rows per row on the front bed, or alternating different colours for the stripes. In some ways there’s nothing revolutionary about this – it’s just modular javascript – but something about the file-agnostic way of passing information back and forth between Automerge files is still really exciting to me.

Ottoman Samples

With the tool working, we spent some time rapidly making a set of different samples based on changing different variables in the ottoman. I was really excited by how expressive this technique was, even with quite simple variations.

The same sample from the front, back, and folded down the main axis. The denser central section creates a natural curve when folded.

My favourite so far is one made using overlapping squares, which creates a really beautiful puckered texture. Varying the carrier for the back bed really acccentuates the effects of the different distributions of front and back bed stitches: I really like the way that the orange back rows (where the elastic is stitched on all front bed needles) start to crinkle more as the sample is stretched, while the green rows open up to reveal the elastic.

The same sample from the front, back, and when stretched from the back. When it's stretched, you can see the rows of elastic on the back bed, which are otherwise concealed by the folds.

One thing that did keep happening with the samples was that they would often trigger the sensor on the rollers as they moved through the machine, particularly when there were larger areas of knit on the edge where the front bed wasn’t knit. The solution to this was to add weights during the knitting process, which pulled the fabric down – it might be worth experimenting with how to load them initially so this is less likely to happen.

Next steps

figure from Carrie’s thesis, demonstrating different loading behaviour of ‘elemental patterns’

Structural Questions

One of the really cool things about ottoman is how much variation it’s possible to get in the tensile behaviour of the fabric. I’ve been reading Carrie McKnelly’s thesis Knitting Behaviour, on the characterisation of knit textiles in an architectural context. She experiments with different lace patterns to vary the behaviour of samples under load, with the aim of making tensile architectural forms.

Carrie used an Instron machine to properly characterise the behaviour of her samples, which I’d really like to find a way to access: especially for making furniture, being able to understand the loading behaviour of samples feels like an obvious next step.

Investigating Partial Knits

Sample by Suzanne Oude Hengel and Drew McKevitt, which combines partial knit and ottoman techniques to create a fan structure

One of the designers B showed me when she was explaining the ottoman technique was Suzanne Oude Hengel, who . In particular, this project on experimental structural knit with Drew McKevitt made some really inspiring and beautiful forms using the technique.

One thing I noticed is that her samples often complement the structure of the ottoman with fanned structures, where the number of rows that are knit increases in select portions of the knit. This is done using a technique called partial knitting, or short-rowing, which is also used to do things like shaping the heels of socks. This isn’t fully possible on the kniterate, though there is some possibility, and it’s apparently more feasible on the edges of the sample (which could be enough for us to create these fanned structures).

Another technique B mentioned, which is sort of possible but a bit tricky is cording, where additional, thicker yarns are woven between the front and back beds as the sample is knit. This is something she uses really beautifully in her manual processes, and can produce really amazing, complex fabrics.

Better Cast-off

casting off in the Kniterate editor, showing the rear-to-front ‘rack left’ stitch (the down-left-pointing arrow with a ‘1’ above).

Another outstanding task is to make a better cast-off – we’ve been using an adapted version of the cast-off process in the Knitout code, and it doesn’t always work very well, sometimes breaking the yarn and dropping stitches, probably because it’s still Shima-flavoured. This is mostly just laziness on our part – casting off is really tedious and takes the longest, so testing it to get it looking really nice is a bit of a pain. A clue is that the kniterate editor version only racks once, and by a full needle, where the original knitout version uses a half-rack as well, which might be a good place to start. I’m not sure how the ‘rack left’ stitch in the Kniterate editor translates into knitout operations, so the next step is to compare the .kc files these different processes generate.

The other thing I want to do is investigate split stitches – these are possible both in the Kniterate editor and in Knitout code, but I’m not so sure what they do – I think pushing a stitch that was on one bed onto both.