Yes, I know, pretty useless . But I like the results :

How Does it work?

In short, make an isosurface of the depth output from the Kinect and calculate the normals.

Then calculate points on the triangles where a hair starts. Now, start growing the hair in the direction of the normal in that point. Add some random and gravity to the growing direction of the hair. And to finish it of, calculate the lightning on every hair segment for a more realistic effect.

Of course, you can also use the pixel data of the Kinect webcam to make hairs in the original object colours. But I liked the black images more.

It’s uses openFrameworks + it needs the ofxKinect addon.

Source code is a real mess, so at your own risk : Kinect Hair.

                          

But recently I did a nice project for Little Miss Robot. They asked me to make an Air application that generates images with code. At that point the code didn’t really mater. The only thing that counted was the result.

Some of the type of pictures the application creates (click to enlarge):

(no source code for now, but think Perlin Noise and Delaneay triangulation ) Ill update this post when the app is available. In the meantime, there is a video.

This whas a big difference in mindset for me. The code was just the medium, not the goal, and I actually liked the approach of making interesting images instead of making interesting code.

I looked around on the internet to see what was actually going on in the generative art scene. And one thing I noticed is that a lot of people use photos to extract colours and/or shapes for there art (I also did it).  Which makes a lot of sense, photos always have a nice natural colour scheme. But with everything I saw that uses this technique, the source pictures got somehow lost.  So this gave me the idea to extend the original pictures instead of just using them.

Some results of exploring that concept (click to enlarge):

Original (public domain) pictures:
http://www.flickr.com/photos/library_of_congress/2179909780/
http://www.flickr.com/photos/library_of_congress/2179146618/

Source code:  generative_art_source

An other thing I saw where beautiful 3d structures (mostly made with structuresynth and rendered with sunflow) So I thought it would be nice to make stuff like that in Flash.

Creating 3D structures ain’t a problem, but two things I really wanted for my renders where depth of field and ambient occlusion. So I messed a round with depth-maps to create screen-space ambient occlusion and custom blur filters for the depth of field. But the result wasn’t really satisfying. To get a good result I had to ray trace my structures.  Creating a ray tracer in ActionScript seemed like an interesting challenge, so that’s what I did…

Some of the ray traced images (click to enlarge) :



Making a ray tracer is quit addictive, and soon I wasn’t satisfied with my limited feature set and at this point I don’t feel I have explored those 3D structures enough. So in the next post (coming very soon…) some more renders and more about the ray tracer + the ray tracer source code. So, stay tuned

And finally, a little preview of things to come ( I admit, the shading is a little bit overdone :p ):

                          

Source code: blowing_up_src

The result of a Sunday afternoon rendering:

Update:

Ronny Welter used my source code to make a cool video of the rendering process. Now you really see how its created and why I called this post “Blowing Up Images” . I also love how he added the shadow so it look like its 3D. Great job Ronny!

                          

It’s dynamic, but it needs some pre-rendering. so the sliders update in the next animation sequence.

In short, I create particles of every pixel. I pre-render the out animation of the in and out bitmap with the same Perlin Noise. Then I animate them over each other.

Check the source code for the details

Source code: ParticleTrans_src

Edit: sometimes the example  doesn’t work in the browser (blame twitter, and there ever changing crossdomain policy )

                          

I didn’t feel much for creating an other flat Mandelbrot set. So I decided to make it a little more challenging for myself and try something in 3D.

There are already  many amazing renders out there. But instead of copy/pasting formulas, I tried to find my own. And to my surprise, I found some very strange and interesting stuff, especially if you consider they are just mathematical defined volumes.

To render those volumes I made a very simple (and very slow) ray-tracer which follows the ray and start checking points to see if they are in the fractal. A normal ray tracer would just calculate the intersection of the ray and the volume, but I don’t know if that is even possible with this kind of stuff?

If I found a point, I looked near that point for 2 other points so I could calculate the normal and ‘setPixel’ a normal map of the volume.

» a live example (low quality)

After that, I used a Pixel Bender filter (from Stok3D by David Lenaerts) to add phong shading to the renders.

Some of the renders (click to enlarge):

I found a lot of these things and I should have made more images,  but it takes many hours to render them in a high quality. I guess I really should start learning C++…

I included the source code so you can start looking yourself for those amazing volumes out there. If you find something cool, let me know
source code: fractal_raytracer_src

                          

Alice’s Adventures in Wonderland. Written in 1865 by Lewis Carroll.
The full story, 12 chapters, more than 25000 words, all crammed in one Bitmap

» View in high resolution

Detail:

The text “fitting” algorithm isn’t perfect yet, but hey, it did the trick.

Source code: Alice_src_FDT
FDT Air project + I lowered the input bitmap size and quality for this download

                          

Since I had the normals, I also added some very simple shading. You can view the fur shading process here (Click to start rendering. Update your FlashPlayer if you don’t see anything or when the model is very small ). The rendering is very slow, the Santa is created with more than 10 million line-segments and I didn’t really optimise the code. So have some patience.

Source code: Fur_3D_source

                          

I managed to extract some sort of direction vectors for the pixels:

Source code (with spaghetti example below): Image_vector_source

It still is quite useless at this point, but with that vector info you can create some pretty cool effects. For example, something similar like the Quasimado Spaghetti Incident pictures: (Click on the image to see the drawing in action)

                          

Click on the image to see the drawing in action. The source: generative_art_source

                          

My first experiment is some kind of painting tool, it uses the Wiimote to control the position and the ‘line’ thickens. It gets his colors from a random flickr photo.

Some of the things I “painted” with the app:

The tool in action: