flockThumb

Generative Bracelets

This was a quick project for Golan Levin’s Interactive Art and Computational design class that explored generative algorithms. I created a series of bangles produced by a user interactive particle system. The particles move according to flocking/swarming rules that the user can manipulate to shape the final form as it grows. A magnetic force constrains the system to a cylinder shape, allowing for wear.  After completion, the mesh can be iteratively smoothed or subdivided and exported from Processing as an .STL,  for further manipulation in Rhino or SolidWorks or 3D printing.

The most appealing part about creating a wearable using this system is that each user can generate an infinite number of completely unique piece, while still maintaining the feel of a cohesive collection.

[Created in Processing with Toxiclibs + OpenGL]

[final mesh, rendered first in Processing using OpenGL and then in Rhino using the vRay renderer]

Here is a video of the underlying flocking simulation. The particles on display here are replaced with hollow spherical mesh “brushes” that leave behind trails of mesh in the final application instead of ombre quadstrips.

[finished bangle before and after using iterative laplacian smoothing to clean up the mesh]

rdKnitThumb

Reaction Diffusion Knits

At its most basic level, knitting is a method of transforming one continuous line into a three dimensional flexible form. It is possible not only to work with color and pattern, but also to create texture and volume seamlessly, a feat impossible through any other method of rapid prototyping.

For this project, my final for Golan Levin‘s Interactive Art and Computational Design class, I wanted to explore knitting as a way to fabricate generative textiles. Hand Knitters have been using mathematical algorithms to produce forms for a very long time, though usually on a relatively small scale for use such as scarves or collars. I wanted a way to generate a really large amount of fabric for any purpose so that no sections of it are ever repeated.

I decided to use Reaction Diffusion as a base for the system since it seemed rather fitting given its loose ties to the fashion industry. Reaction Diffusion is a process that can be expressed with two equations where two chemicals mix in order to produce an infinite number of forms, which are commonly used in nature for animal pelts/patterns. Robert Munafo does an excellent job explaining the process here

Unfortunately, since the patterns produced are so rare and beautiful, we tend to kill millions of animals in order to harvest them and turn them into rather fetching jackets. Animal cruelty asides, this process is made even more inefficient by the fact that, animal pelts are expensive, difficult to work with, and produce a number of design limitations due to their unusually shaped pelts. With this application, it is possible for the user to create their own unique design in a similar fashion to any size requirement with tweaking.

I began with Karsten Schmidt’s Toxiclibs library for Processing with the intent of creating “swatches” of reaction diffusion to work with

However, Processing became frustratingly slow and unwieldy, especially when it came to seeding the diffusion off an underlying layer of the reaction. So I switched over to C++ and Cinder, building off of the experiments created by Robert Hodgin.

Here are some sample swatches that illustrates the range of patterns that the application could be used to create

[poster created for the final show displaying the process of converting a rD swatch to a knit pattern]

The finished swatch was thrown back into Processing and converted to a knitting pattern based on the color values that fell into each grid of a typical knitter’s cabling grid.  I then constructed the final knit swatch using a knitting machine to create an intricate lace like fabric.

I also experimented with the scale of the textile for my collection, Kitsune. By blowing up the cables and yarn overs to a much larger size, it made the random organic looking patterns more dramatic and visable in a runway setting.

[strips of Reaction Diffusion patterns used for cinching the waistband and finishing the hem]
[finished garment using an oversized RD pattern to determine cabling crossovers and yarn overs in the sleeves and bodice]

waterbombThumb

Waterbomb | Kinetic Dress

Waterbomb was a study of the kinectic properties of soft origami created in collaboration with Mahvish Nagda. Kinetic wearables are often bulky, with incredibly complex mechanical systems driving them. We wanted to create a simpler lightweight system without sacrificing the drama of global movement, by capitalizing  on the innate transformative qualities of the waterbomb fold and its variations.

We developed several methods of creating tessellations that cut normal folding time in half, and were simple to create in bulk and at a huge scale. These included scoring with a laser cutter, creating stencils to use the fabric itself as a flexible hinge, and heat setting synthetics between origami molds. We also examined the folds themselves, writing scripts in Processing to generate crease patterns that either focused on kinetic properties or being able to control the curve and shape of the final form.

(for the full writeup check out the iacd blog)

[early prescored lasercut prototype][folding patterns were created for the laser cutter using processing, and tested using Tactom‘s freeform origami simulator]

[synthetic heat set using a prescored lasercut mold.]

[stenciled waterbomb set with thermochromatic ink]

These studies culminated in a dress that took advantage of the innate kinetic properties of the waterbomb fold to display global movement over the entire skirt structure with a relatively lightweight mechanical system. The dress moves in tandem with a breath sensor, mimicking the expanding/contracting movements of the wearer.

[monofilament was threaded through eyelets connected to the peaks of the waterbomb fold that compromised the skirt]

[Global movement was controlled using a lilypad arduino, and several hobby servos hacked for continuous rotation. The thermochromatic ink used for the construction of the skirt served as a breath sensor when combined with a light sensor on the collar of the dress. The ink turns translucent when heated by the wearer's breath, allowing light to shine through and triggering movement in the skirt.]

blogthumb

kinectFlock | xBox Kinect Hack

Another quick project I did for Golan Levin’s Interactive art and computational design studio that was featured in the New York Times Tech Section. Along with Ray Lin, I created a particle system that exhibits flocking and swarming behaviors when the user is moving, and flocks to the participant’s depth field when they’re standing still. The resulting simulation ebbs and flows between the recognizable and the abstract.

[Developed using Cinder + OpenNi + NITE + Xbox Kinect]



Each point generated by the kinect’s depth map that comprises the user’s body has a gravitational pull on one particle in the simulation. The strength of this force is inversely related to how fast they are moving, so when the user stands perfectly still the particle zooms to the point it corresponds to, and when they move it is free to wander and behave on its natural flocking tendency. Thus you get these really smooth flowing visuals as the silhouette breaks and reforms.

And lastly, here’s a short video on two small apps I wrote in processing in order to study the flocking and perlin noise flow fields I used to generate the particle movement in the final product that are quite beautiful in their own right.

Read even more about the project and others at the interactive art + computational design blog!

blog thumb

Growing Tree Meshes

Processing application that generates 3d meshes of trees. This kind of geometry would be horrifying to sculpt by hand, and is handled much better with code. The skeleton is created recursively, with magnetic forces at each level pushing apart each limb in order to create an attractive shape. The mesh is then “grown” from node to node to create the final tree.




Paul Miller and I worked on a modified version of this code to create a larger world tree for a short animation. I exported the final mesh to Z Brush for cleaning and texturing, and Paul did some lovely renderes in Maya.

faceMorphthumb

Face Morphing

An algorithm for smoothly morphing two faces together, created in MatLab.

A morph is a simultaneous warp of the image shape and a cross-dissolve of the image colors. The cross-dissolve is the easy part; controlling and doing the warp is significantly more difficult. The warp is controlled by defining a correspondence between the two pictures. These are done by hand for this example and include important facial features that should be aligned/preserved in order to facilitate the illusion. (i.e. eyes, mouth, chin).

Correspondences + Triangulation

First we calculate the Delaunay triangulation for each of the user supplied points. In order to ensure the most even morph, the set of control points we use is actually the average of the ones for the two images. Since Delaunay only associates vertices with triangles, this can be applied to both images.

Affine Transformation

The next step is to cacluate a transformation matrix to transform the triangles from the first image into those of the second. An Affine transformation matrix preserves the collinearity relation between points and contains skew, scale and aspect ratio changes.

Cross Dissolve + Morph

Lastly, we cross dissolve the two faces morphed to a warped average while slowly increasing the warp factor, generating a smooth animation. I was surprised how much power the Cross Dissolve algorithm I chose had over the final image, since it was such a small part of the overall code (literally one line!). After several failed attempts, the one that looked the nicest followed the form of Img1 + (some cross dissolve factor)*(Img2-Img1).

lunarGalaThumb

Kitsune | Lunar Gala Collection

Kitsune is a collection of generative clothing that I designed and created over a course of two months for the Carnegie Mellon student fashion show Lunar Gala. The collection focused on using generative strategies I’ve employed in past projects in order to create pattern and texture. I learned an incredible amount about fit and pattern making. Check out the process work on the blog.