Quantitative Stretching

Welcome to my new Stitching Blog. It's like my regular blog except all about quilting and embroidery. I've separated the two, because I get the feeling that people interesting in my science writing and app-making activities may find all the stitching a bit tedious, and vise-versa. Also, I have taken the liberty of using the same list of subscribers to my stitchcam as the list to be notified (via rss feed) when there's a new post on this blog. I figure if you're interested enough in stitching to get real-time notifications of a quilting machine running, you're probably interested enough to hear about an occasional blog post.

So without further ado, my first new stitching-related blog post. I'm afraid it's a rather technical one....

One of the big problems with fabrics and quilting is that fabric is not a proper engineering material. It's stretchy and sloppy and never goes exactly where you want it to. The situation only gets worse when you add batting to the equation. 

We've been experimenting with extra-thick batting, as much as two inches thick, and have had a problem with the resulting "quilts" not lying flat, because some parts of the pattern shrink the dimensions of the fabric more than other parts, resulting in a sheet that is internally stressed. 

You might think it's a simple case of more stitches equals more shrinkage (as it more or less is with embroidery), but this is not the case. 

To see why, consider a cross section of a quilt with different spacings between the quilting lines. When there are no lines, the fabric on the top and bottom are flat, and the piece overall will be just as long as the fabric originally was. As you add more lines, the fabric is forced to go up and down, so even if the fabric isn't physically compressed, the piece overall will get shorter.

Here is a schematic illustrating this fairly obvious fact. Clearly if the lines (the top and bottom fabric) stay the same length, the overall length of the quilt must get shorter.

But what if you keep going? There is a fallacy in this drawing: The thickness of the quilt is staying the same. Clearly the following is NOT what happens if you add even more lines:

These diagrams get more and more absurd, because of course what actually happens is that the batting gets hammered down, the piece gets thinner overall, and the fabric goes back to being flatter. And that means the overall piece should start getting LONGER again, at a certain point. That's what I wanted to confirm and quantity, so I had Behemoth stitch twelve different test strips like these, each about a meter long:

Here is the diagram again, except this time the widths shown are real, measured widths from my experiment. (In the diagram below, the number of humps is real and the relative lengths are real, but the thicknesses are schematic, because I didn't measure the actual thicknesses):

As you can see, there is a minimum length around 30 humps, and by the time you get to 200 humps (0.5cm line spacing) the thing is well on its way back to its original length.

Here is a plot of the lengths as a function of line spacing (the right-most data point represents infinite line spacing, in other words the original fabric length):

The interesting fact about this is that, because there's a minimum, there are going to be two ways to get any given amount of shrinkage, a large-spacing way and a small-spacing way, one on either side of the valley. In order to get a quilt that lays flat, you don't have to keep all the spacings the same, you can have zones of stitching width spacings on either side of the minimum.

These tests were all with lines in only one direction, but what if you add crossed lines in the other direction? I did a second set of twelve test strips with lines going in both directions, like these:

The following graph is a bit harder to read. The horizontal axis represents the line spacing in the direction of shrinkage (just like in the graph above). The vertical scale is again overall length of the piece. The lines connecting data points represent sets of similar spacing in the lines going the other direction. The bottom set has no cross-lines (i.e. it's the same data points as the graph above, except a smaller number of them shown). As you go up, each line represents more and more closely spaced cross-lines. The data points are labeled with the line spacing in the shrinkage and crossed directions respectively.

The result is as expected: The more closely spaced the crossed lines are, the less shrinkage there is, regardless of how closely spaced the lines are in the shrinkage direction.

Now all we need to do is actually use this information to make something pretty that doesn't warp.... In the mean time, we've been experimenting with the other solution: Stretching on a frame.

This quilt is "double-quilted", using the term Nina invented for a thing I decided to try because why not. It's basically a quilt on top of a quilt, so we can have a secondary level of relief that isn't hammer down overall. I'll write a full blog post about this technique later, but here's a closeup that gives an idea of what it looks like:

Was all the quantitative measuring useful? Maybe.... So far I've used it only to create an interpolating function that I have used in some calculations involving how wide to make flaps that wrap around the wooden frame holding up stretched quilts like this. Hm, that's probably another blog post too.

Quilting Around the Birds

Sorry if you're a chemistry fan, I'm afraid this is another quilting post... I promise to go back to elements and molecules and reactions soon. In the mean time, I tried another experiment over the holiday weekend: Using image processing and Mathematica to create a quilting pattern that outlines the figures on a piece of printed fabric.

I clamped the fabric (with extra-thick batting under it) to the quilting frame, and then photographed it from directly above (see photo). Using some index marks I placed at the four corners of the fabric, I used PhotoShop to straighten up and clip the image so I had an image that exactly corresponded to an identifiable space within the frame. (In other words, I could determine the exact coordinates to send the machine to so it would reach each of the four corners of the image.)

Then I used PhotoShop to select and blank out the background, leaving just silhouettes of the birds, which I expanded using Mathematica's Erosion and Dilation functions, resulting in outlines a bit larger than the actual birds. Nina kindly used Flash (which has good auto-tracing features) to convert the silhouettes into polygons, and fixed up some missing bits. (Yes, I probably could have done all of this in Mathematica, except that the automatic MorphologicalComponents function couldn't actually get the objects right, and there's no automatic outline tracing that works well enough.)

Next it was back to Mathematica, where I added a set of parallel lines and masked them out where the birds were (using the excellent new Region features in V10). Finally I used the ever-useful FindPostmanTour function to generate a single-line path through the entire pattern. (Which took maybe 10 minutes: It's a big pattern, but nowhere near as complicated as our currency designs.)

And here's the result: semi-3D birds popping off a lined background:

The big question I was trying to answer is whether it's practical to quilt around pre-printed designs on fabric. This would be a very cool thing to be able to do in an automated way. The problem is that it's difficult to get the fabric into an exactly known location in the quilting frame, and it might be distorted in different ways each time, making it difficult to use a fixed pattern multiple times. By taking a photograph of the fabric after it's already stretched into the frame, all these problems are eliminated.

But, it's a kind of a pain to do so much processing for a single piece: It all has to be repeated for the next piece of fabric, even if it's exactly the same pattern. The experiment worked (and if I'd been less sloppy with my PhotoShop scaling, it could have come out quite a bit more perfectly aligned). But in retrospect, I think a better system would be to make fabric with printed reference marks that allow it to be positioned very consistently in the hoop. I already know that's possible from my previous project, where I was able to put a piece of fabric back into the hoop and have it align nearly perfectly with how it was previously mounted. (See previous blog post.)

Holiday Quilting, now with Live Stitchcam

(NOTE: After writing this blog post I re-did exactly the same designs in the same fabric, but with much thicker batting in the second stage. This came out a lot better, so I've replaced most of the photos in the blog post with the new version. There's a gallery at the end with all of both versions.)

About a year ago my girlfriend Nina Paley got a giant robotic quilting machine, which she named Behemoth. We've been doing various projects with it, which you can read about at PaleGray Labs and Quilt Bank. For example, here it is stitching a 10x$1000 quilt. 

Sometimes it runs for hours at a time without attention, but at any moment the thread may break. To avoid having to be there all the time watching for problems, we installed a webcam pointed at it, so we can check any time whether it's still going. And now you too can watch the PaleGray Labs Stitchcam any time you like! (There's nothing running at the moment this was posted, but we'll be starting a new quilt tonight or tomorrow. There's an email list on the Stitchcam page you can sign up for to be notified of impending stitching action.)

Mostly Behemoth has been a Nina project, with me just being the lowly stitchcoder who turns her dreams into sequences of base-3 encoded (x,y) coordinate pairs to be fed to the machine. (Also I oil it.)

But sometimes I do my very own projects, and I'm very pleased with the one I just did over the New Year's holiday. I had a sudden notion that it might be possible to do something you can't do with our smaller embroidery machine: Take the fabric entirely out of the frame, do something with it, then put it back in exactly the same position, so new stitches can be added in near-perfect alignment with the old ones.

I decided to try doing this by tracing the outline of each of the few dozen camps that hold the fabric in place (you can see the clamps and outlines drawn on the fabric on the right side of this photo). My reasoning being that the position of the fabric in these clamps is the only thing that determines its location within the machine, and there's no reason I shouldn't be able to line up the marks and get it back to within a couple of mm of its original position.

This turns out to be correct! Alignment between old and new stitches is never quite perfect because the fabric inevitably stretches as stitches are added, but between the oldest and newest stitches I got alignment over the whole field within 4mm, and in many places within 1-2mm. With as many stitches as this project had, that's as good as it can do even if you don't take the fabric out in-between.

What makes this quilt different from a regular one is that some parts of it are lofted over others, because it has two separate layers of batting, and some parts are stitched through only the top layer, meaning they puff up higher than the parts that are stitched through both layers.

The wavy ribbons look like they're popped above the rest of the quilt even in the flat pattern file, but in the real thing they actually are popped up, as you can see from the side view.

I loaded the machine with a standard sandwich of fabric-batting-fabric, then stitched the two rings (and the disk in the middle). Then I took that half-finished quilt entirely off the frame and added a new layer of fabric and a layer of batting on top of that, then put the quilt back on top of those, creating a Big Mac stack of fabric-batting-fabric-batting-fabric. I stitched the three in-between zones through all of those layers. That way the two rings and the disk float above the background.

Here's a second pattern I did the same thing to, except here all of it is floating, with just a few rings of stitching separating each zone.

By the way, needless to say, these designs were made in Mathematica. I created a little nested-braids editing tool to pick the specific parameters:

Here's a gallery of all the pictures of the new, thicker version:

And here's a gallery of all the pictures of the old, thinner version: