For this project I experimented with computerized plotting on T-shirts using Micron brand drawing pens. To date this has been the most fun thing that I’ve made on my Multifab personal fabricator . I’m starting to think that fashion might be the under-explored killer app for personal fabrication.

A Three-Color-Process Face

Step 1: Start with an Image

Step 2: Decompose into Three Colors

Step 3: Apply Charcoal Filter in Photoshop

Step 4: Convert to Black and White

Step 5: Trace Images and Generate Toolpath using Prof. Gershenfeld’s FAB Modules

Note: I adjusted the tracing parameters so that the green layer appeared dominant with the greatest level of rendering.

Step 6: Load a T-Shirt into the Multifab

Step 7: Load a Pen and Run Toolpath

Step 8: Repeat for Red and Blue

T-Shirt Typing

Algorithmic Generation of Toolpaths: The Dragon Curve

With a color change every 1024 segments:

Several re-draws with different colors:

This toolpath was generated in real-time as it was drawn, using an L-system algorithm called the “Dragon Curve”. I learned about the algorithm from the Wikipedia page on L-Systems. The basic rules to generate the pattern (from the Wikipedia page) are:

Actions: F, +, and -

F: draw forward

+: turn right 90 degrees

-: turn left 90 degrees

Functions: X and Y

X -> X+YF

Y-> FX-Y

Starting Function Call: FX

Because the rules are recursive, the functions can call themselves. I recursed 11 calls deep to generate the first pattern, and 10 calls deep for the second pattern.

The algorithm was written in python, and was run within the Multifab control system to generate motion:

I wanted to write a program that would generate different faces. I have started with the “tree” source code that Leah has provide for the embroidery machine toutorial. I was changing the properties untill I found the result close enough my idea. I picked up three random face-bases and  I added the eyes in Adobe Illustrator.

The embroidery machine was quite nice to me, however I needed some help to tame the bobbin. Sheralyn gave me her great support today, (Thank you!). My first version on a white fabric was a faces trial. I wasn’t satisfied  with the scale and composition so I adjusted my pattern in Illutrator and tried the second time on the pink fabric.

Most surprinig for mye was the machine’s “embroiding concept”. As I am used to the pronters I expected the same linear movement of the needle. It was interesting to see (and hard to understand) why the machine chose some pieces to draw first even if they were away from each other. I appreciate that we had an opportunity to lear this new technique in combination with programing in Processing.

Processing Code:

8 bit Angle Fish made in Processing

I struggled  on what to do for this project as I kept considered doing a 3D print fabric. However, I’m somewhat satisfied with my experience on the embroidery machine as it did give me some ideas on how to tackle my final project.

Through Processing, I made a (8 bit) Angel fish by using overlapping triangles. It’s a small tribute to early computer graphics.

In the embroidery software, I learned that there were 26 shades of blue. Obviously, I didn’t have 26 shades of blue embroidery thread, so I choose to combine similar colors into 5 groups…

…On the embroidery machine, however, I learned that my 5 groups weren’t 5 groups as I ended up having the option to change the color some ~15+  times.

Embroidery machine showing sections to be embroidered with thread installed on machine (for lack of better words).

In addition to not having as man groupings as I thought, I also had difficulty with tension and as a result, the bobbin thread made a random appearances and the sewing thread kept accumulating into messy tangles

Initial embroidery completed until I changed the bobbin

Tension on the new bobbin is too tight...

...bobbin tension still too tight...

Snag

Final Result

Following another student’s example, I decided to switch to a thicker fabric. The final embroidery still has the bobbin thread showing, but I suppose that this project was an experiment as I did switch threads several times and as a result, found by trial and error different tension settings for the threads as the automatic tension setting didn’t diminish the appearance of the bobbin thread.

Some things I learned and that I should keep in mind for my final project:

• I should use a bobbin thread whose color is close to the fabric, which is something that’s similarly done in quilting.
• I also learned that for embroidery that has adjacent different colored sections, it’s NOT a good idea to cut the thread when the machine gives the option because as I learned at the very end, previous embroidery can become undone.
• Pre-test the tension settings for the thread and fabric I plan to use.

Angle Fish

Code:

int x=0;
int y=0;
int a=50;
int b=0;
int e=0;
int f=50;

void setup()
{
size (500,500);
translate(200,200);
background(255);

for (int i=0;i< 10;i++)
{
for (int j=0;j< 10;j++)
{

int colort = round(random(100+i*15));
fill (colort, colort, colort*5);
noStroke();

int sizet = 300/(40-i+1);

triangle (x+i*sizet,y+j*sizet,a+i*sizet,b+j*sizet,e+i*sizet,f+j*sizet);

}

}
x=50;
y=50;
}

I have always been interested in patterns that were capable of change. For my Computational Design Project, I chose to design a circular pattern that could deform in shape and size. Using Grasshopper, which is a plug-in for Rhino, I used pre-determined values and a code to generate a 3 dimensional cylinder that expands and contracts at its center. I then used the top views of the cylinder’s deformed surface to capture different radial shapes for laser cutting and embroidery design.

Grasshopper plug-in with Slider to adjust radial shapes

Shapes generated by moving the slider

Below is an image of one of the shapes imported into Ilustrator as a 2 dimensional vector file for use on the laser cutter and embroidery machines. When I imported the file, many layers of lines were produced as a result of the 2d image being a projection of a 3d object. I had to delete any duplicate lines in order to prevent the laser cutter from over etching a single line, and to prevent the embroidery program from crashing. Over etching in areas did produce some nice results as well however. The darkest lines seen in the design below (creating a circle) were over etched and caused the center circle to fall away from the etched border. This allowed me to mix and match different patterned/colored circles for the center of the design.

Once imported into the laser cutting program, I used felt as the base for the design to be etched onto.

Various shapes were pieced together with a fabric adhesive

Finished laser etched designs

Embroidery

Finished embroidery

Rhino/Grasshopper C# code

For this computational textile assignment I want to try the 3D printing textile. It is a good experience of learning!

It is my first time to do 3D printing, and I am a new hand in Grasshopper. So the work is challenging. I started from studying the basic structure of weaving, and then tried my best to build it in Grasshopper in Rhino, and managed to make a structure similiar to the textile weaving. The basic method is to build U-V grids on both sides of a surface, connected the points by nurbs, flattened them and deleted some points by “cull”, and finally “pipe” the curves.

After spending long time on learning the software and building the model, I could not catch up the deadline to send the file to shapeways. So I went to the Edgerton Student Center for 3D printing. However, since I do not have enough 3D printing experience, I did not “cap” the ends of pipes and the model printing totally failed.

Then I rebuilt the model and printed it again, which took an terrible long time of 24 hours…

Finally I got the model printed. However, the result is not ideal. Several parts are broken. Before going there, I did not know that there are many kinds of 3D printing and each has different characteristics. The 3D printer in Edgerton is based on FDM which is when the plastic gets squirted out in a bead. I did not realize it was too low resolution for my delicate model.

It is a very interesting process of learning! I want to thank Ilan Moyer, who is an expert in mechanical techniques and helped me a lot with the 3D printing!!

The pattern that I used to generate this code was a old data set that I modified to allow the results I wanted. The data set is a text file that is read by processing though the help of tabs. I acquired the data from a questioner I sent out to friends. Each anwser corresponded to a letter and the letter a value. After I visualized the file with processing I played around with he data to make the visual out put more desirable. When I was satisfied with the results I clicked on the window and close it to save a PDF of the pattern.

After creating the PDF I knew I wanted to use the knitting machine to realize the pattern as fabric. Once bringing the file into the embroidery software, I wanted to use texture  and stitch pattern to create different topographies. The first time I embroidered the patter I used black thread for both the top and bottom threads. It was very simple to use the machine and i did not encounter manny problems. After on pattern was completed I decided that I would like to add to it by embroidering a second pattern. This time I wanted to change the color of the thread. I left the bobbin thread black and changed the top thread to blue. This created a nice affect allowing the textures to become more visible.

The second pattern caused me more problems but allowed me to lear a lot about the machine though the encounters. First the bobbin was not wound correctly causing the a massive tangle. I had to stop the machine and rewind the bobbin (with Hanna’s help). Next the paper separated from the fabric and I need to iron a new piece on. Lining up the first pattern with the begging of the second was also a challenge. The next issue I encountered was the embroidery attachment, though the vibrations and maybe the prqsserfoot hitting the hoop, knocked itself off where it sits and though the pattern of. I had to pause the machine and move it back to where it belonged. I am guessing this occurred because the scaling of the pattern was a tiny bit off allowing it to be slightly bigger than what actually fits in the hoop with the presser foot inside at all times.

In all, I found this process very enjoyable and exciting to see the translation from screen to tactile fabric. Though the issues I encountered I learned a great deal about the machine and could now used it for more complex things.

See a video of the machine working on my pattern HERE:

Inspired by the rotational artwork that I used to do when I was a kid, I wanted to create curves that could be rotated about a center point to form a piece of unique art.

I experimented with the various types of curves and random functions in processing until I came up with a set of randomly generated curves that looked satisfactory. The next challenge was to make the curves link up and form interesting arcs that did not repeat. Finally, I wrote some mathematical functions that would create a set of 4 curves rotated equally around the center axis. I wanted the user to have some input into the generation of the pattern, so I included the keyboard as a form of user interface so that the user could control when each new set of curves was generated, and change the color of the curves when desired to have a pattern with multiple colors.

Subsequently, embroidering was relatively straightforward. I didn’t run into trouble translating my pattern into the format that the embroidery machine required, although I didn’t attach the embroidery arm of the machine properly the first time, which caused the red and black pattern to shift out of place. The second time around, I experimented with a thicker stitch, but got stuck at the machine for an hour troubleshooting when it would start and seemingly stop randomly, telling me that the thread was broken when it was not. After rethreading the top thread and checking the bobbin at least 7 times while toggling with the tension, it magically finished the pattern. (yes!) I suspect the tension was the culprit, combined with the thicker stitches layering on top of each other to form a thick wad of thread. I am pretty satisfied with the designs, and I intend to make them into mats for holding hot pots eventually.

Processing Code:

]]> http://newtextiles.media.mit.edu/?feed=rss2&p=2569 0 http://newtextiles.media.mit.edu/?p=2470 http://newtextiles.media.mit.edu/?p=2470#comments Mon, 25 Apr 2011 13:43:59 +0000 Sheralyn Woon http://newtextiles.media.mit.edu/?p=2470

I focused on the motif of a button because firstly I thought it was a simple object to work with and secondly I wanted it to appear as if one was continuously pulling open a drawer with loads of buttons shifting about inside. In the first version of the program, I had problems representing this shifting motion. The buttons were actually stuck in place because I couldn’t figure out how to make the small button holes follow the big button. This is also why the rest of the smaller circles moving randomly have no button holes.

After some intensive coaching from Leah, the next few “improved” versions actually had buttons moving about. Playing about with sizes and numbers of buttons, I had a variety of densities to choose from. The final one I used has some density but does not seem overwhelmingly crowded (pictured above). I waited for the right composition and just clicked the mouse to save the image as a Tiff file.

Using the DRAWings program, I turned the tiff file into an embroidery file. I played around with the density of stitches and way the program translated the Tiff file into vector. I found that the accuracy could be adjusted for different effects. In my first piece because the accuracy wasn’t set high and the stitch density is too high, the distinct look of the buttons has changed. It looks more like a diagram in a biology book about cells and amoebas. The second piece with a lower stitch density and higher accuracy, the original look of the buttons is retained.

The sewing machine was generally ok to me. I found it very engaging to play with alternating the thread colors and getting the machine to sew over bits that had already been done to blend colors or create more texture and depth. I also tried both cotton and felt as an embroidery backing. I prefer the look of the felt because it is more robust and doesn’t pucker as much. The back and the front of my designs are of different colors because I changed the color of the thread on the bobbins to experiment with different color schemes.

I really appreciated having more time to work on this assignment, in spite of spending most of that time staring at the Programming screen wondering what I could change or rectify. Without the time I don’t think I would have been able to be really make the movement of the buttons seem random.

This is the video of the random patterns made:

The code for the final pattern is:

void setup() {
size(600,400);
frameRate(1);
}

void draw() {
background(0);
color c1 = color (255, 0, 200);
drawButton1 (50, random(width),random(height), c1);

int x=0;
while (x<8)
{
drawButton1 (int(random(80, 120)), random(width),random(height), c1);
x=x+1;
}

color d1 = color(50,0, 255);

int y=0;
while (y<30)
{
drawButton2 (int(random(40, 75)), random(width),random(height), d1);
y=y+1;
}

}

void drawButton1 (int sizeOfCircle, float centerX, float centerY, color c)
{
int bigCircleDelta= sizeOfCircle/2;
int buttonDelta = 5;
int sizeOfButton = 3;
fill(c);
ellipse ( (centerX), (centerY), sizeOfCircle, sizeOfCircle);
fill (0);
ellipse ( (centerX-buttonDelta), (centerY+buttonDelta), sizeOfButton, sizeOfButton);
ellipse ( (centerX+buttonDelta), (centerY+buttonDelta), sizeOfButton, sizeOfButton);
ellipse ( (centerX-buttonDelta), (centerY-buttonDelta), sizeOfButton, sizeOfButton);
ellipse ( (centerX+buttonDelta), (centerY-buttonDelta), sizeOfButton, sizeOfButton);
}

void drawButton2 (int sizeOfCircle, float centerX, float centerY, color d)
{
int bigCircleDelta= sizeOfCircle/2;
int buttonDelta = 3;
int sizeOfButton = 1;
fill(d);
ellipse ( (centerX), (centerY), sizeOfCircle, sizeOfCircle);
fill (0);
ellipse ( (centerX-buttonDelta), (centerY+buttonDelta), sizeOfButton, sizeOfButton);
ellipse ( (centerX+buttonDelta), (centerY+buttonDelta), sizeOfButton, sizeOfButton);
ellipse ( (centerX-buttonDelta), (centerY-buttonDelta), sizeOfButton, sizeOfButton);
ellipse ( (centerX+buttonDelta), (centerY-buttonDelta), sizeOfButton, sizeOfButton);
}

void mousePressed()
{
save(“line.tif”);
}

With a combination of tactile textile sensing and computational embroidery, there is now a way.  Building off of the images that I created from tapping my fingers to “Raise Your Glass” by the Glee Warblers, I decided to translate those images into an actual textile using computational embroidery.  The process was certainly not as easy as I hoped (I used the embroidery machine on 4 separate occasions and unfortunately broke the machine once!) — but it was rewarding once I got closer to translating my tactile design into something that was woven into a jacket that I am planning to wear.

Embroidery Process

Original Tactile Design in Processing - Created by Finger Tapping to Raise Your Glass

My First Embroidery Try

Embroidering on an Old Gray Shirt - The Embroidery Machine Ate My Shirt

Video of Computational Embroidery Process

Raise Your Glass on Blue Sweater

Modeling the Bedazzled Blue Sweater

For this assignment you will create a computationally generated textile pattern. You’ll write a program that generates a pattern and use the embroidery machine, laser cutter, knitting machine (or another CNC device, ie: a CNC loom or a 3D printer) to automatically produce the pattern.

Create a post that documents your project and add it to the Computational Design category. Your page should include pictures of your finished textile, the code you wrote to generate the pattern, a few photographs of the construction process, and a paragraph about your experience.

Something to think about…You have three weeks to finish this assignment. This would give you time to order fabric from a service like Spoonflower (custom fabric prints) or Shapeways (3D printed fabrics). A 3D printed fabric:

Tutorials, including sample code are available in the Machine Tutorial category of the HLT wiki.

Bring your projects to class on April 19 for demonstrations.