This is a representation of the 180,000+ points of data that were captured during the processing of making my last drawing. They’re quick sketches done with Processing and the toxiclibs Processing library (specifically for the Verlet physics engine).

The first step here was to create something cumulative, just so I could see the data over time. The end goal (originally) was to create a data renderer that created a static piece (or pieces) that could stand side-by-side with the original drawing, like a diptych. But embedded in that goal is an attempt to bring forth the energy and motion that went into the original drawing. That’s why I created this whole system in the first place.

I’m not there yet, but I think you need to swim in the data for a little bit before you can get a sense of what it really is.

Well, that itch has resurfaced, and I realized I was making things way too complicated. This time, I’ve turned to using some open source tools for the data capture portion of the project. Components include:

• Computer
• Webcam
• Community Core Vision (CCV)
• Color Tracking Patch for CCV
• Processing TUIO Client API

It’s actually really simple to get set up. Here’s a little demo of how it all comes together.

Next steps include making a client to listen for the TUIO data generated by CCV. I’m probably going to opt for an AS3 AIR client, since it’ll be fastest for me to create. Then create a web application that captures and stores this data. This I’ll build in CodeIgniter, again, since it’ll be fastest for me to create in this environment.

I’ve got a lot of stuff on my plate this month, and I want to participate in this month’s NaNoDrawMo on top of it. So, we’ll see where things net out.

I’m continuing the Perlin noise saga. The last thing I did was port the Noise Column project over to Processing and openFrameworks.

This time I wanted to add some actual volume — not just perceived volume — to the form. These are just some initial tests that you see above. I’ve got a ton to learn about lighting and optimization and matrix transformations. Robert says I need to use “per-vertex normals”. I say “OKAY!” Hopefully I can start adding some of these things over the next couple weeks and really use this project as a general learning tool.

For now, I’m developing all this in Processing using the PGraphicsOpenGL renderer. I’m not using any actual OpenGL calls directly; I’m only using the Processing API. One little discovery I made yesterday: PeasyCam turns out to be a really sweet little camera library for Processing. Adds mouse control over the camera with a single line of code.

The ultimate goal of this is to create two different pieces. One will be a rendered motion piece. It probably won’t have any audio and will function as an ambient looping video. It will be submitted to this call for entries: Flow Interrupted.

The second piece would actually be interactive. I’m going to toy around with camera, audio, and touch as discreet inputs (all separately). This will give me a chance to play with the new HP TouchSmart PC I got. So you could consider the second execution to be more of an interactive installation piece. And that’s going to be submitted to this call for entries: FLUID Interactive Digital Art.

Check out some of the stills:

+ View larger Image.

+ View larger Image.

+ View larger Image.

+ View larger Image.

For my friend Nate‘s 30th birthday, I created a one-off set of prints based on the Noise Column and Noise Column Wallpaper Generator mini-projects. It was largely an exercise in creating something with OpenGL.

Thus began the effort to port a bunch of ActionScript 3.0 vector drawing commands over to line loops in OpenGL. I used Processing as my framework since I’m used to it, and it gave me a 1:1 mapping of the OpenGL API. I was able to use various C++ OpenGL tutorials and books to accomplish my goals. I used the super-helpful TileSaver classfrom Marius Watz to generate hi-res renders.

Now after all this, I realized that it was time to take the plunge and start getting closer to the metal. Thus began the next port of Noise Column; this time I went to C++.

I’ve been reading Stephen Prata’s C++ Primer Plus for the last couple months on and off. For me, learning from books makes sense. Moreover, learning the reasons for writing the code you write is so essential for retention for me. This book is simply great.

So for the C++ port, I moved over to openFrameworks as my C++ framework. OpenFrameworks is great, but there’s still a long way to go before it becomes the Processing of C++. Regardless, I had learned just enough C++ to figure out how to port all this stuff over. Two days later, I was able to generate a moving version of Noise Column:

Now it’s time to start doing stuff with “real” 3D in OpenGL — a dimension I’ve got nearly zero experience with.

It’s written in Processing, uses the WiiuseJ open source Java library (which I highly recommend, at least on the Windows side), and leverages the “Warper” class from Johnny Chung Lee’s Interactive Whiteboard project for mapping the x,y position of my hand on my desk to the correct x,y position in my Processing sketch.

I ended up moving the contraption that holds the Wiimote up as high as I could, since the FOV was definitely cramped (and still is). I think I need to open up the hole in the cardboard holder a bit so the FOV gets extended even more.

I ran into an issue with the tracking becoming very unreliable if the IR LED wasn’t pointed directly at the Wiimote up above. To compensate, I created a little cone out of aluminum foil and wrapped it around the LED. It has a wedge that’s open and faces the general direction of the Wiimote. This definitely did the trick as the light from the LED reflects off the foil and creates a much bigger target for the Wiimote to see.

Now I can start moving onto the other physical components of this piece.

So lame that I haven’t posted since December. Seriously.

Above, we’ve got a variation on a Processing sketch I made at work last week when I realized I needed a new desktop. That sketch was used to create the desktop pictured below (with some help from Photoshop for gradients and drop shadows):

Okay, so back to the actual Processing sketch. Is it just me, or is it completely unsettling that the sketch looks like it’s dancing? Maybe it’s just getting late.

Note: Just take those lines out of the sketch that refer to QuickGrab or Grab if you’re confused about them. They’re there so I can grab screen captures of the Processing output and dump them straight to file. Thanks to Ryan Alexander for the QuickGrab library.

I’ve decided to spend some time again with Processing after all this work with Flash, Flex, and ActionScript 3. Much of tonight dealt with exploring the Processing 3D-related syntax and making tools for working in the environment. Took me a very long time to correctly position a spotlight. But, now I’ve got some code for shifting things like that around with keys at runtime.

This sketch is the first of what will be many iterations, I’m sure. The next step is hooking this visual up to some audio — specifically an audio map — and affect values of position / height based on that map. I want to create a concrete image of the entire snapshot of a song or a specific chunk of it. I like the idea of making a “tangible” object out of something that so clearly lives in temporal space. Hopefully this will bring some new meaning to audio artifact.

I’m not going to go into too much explanation just yet. This is just a hint of what might be to come. And I’ll post some source code so that you too can do this with your favorite video clips.

What started as a way to generate interesting compositions for real paintings that I would paint for my baren walls, turned into an afternoon of fooling around in 3D in Processing. I’m working on some sort of algorithm that makes use of real image data to generate a topographic map. I’m blending that data with some perlin noise to get more natural sweeps and undulations in the form itself.

Here are some more of the results:

Note: These aren’t really renders. They’re just screen dumps from Processing using real-time OpenGL with hardware anti-aliasing turned on. I can manipulate the camera with basic keyboard commands to try and find a nice composition.

View NoiseBreather.

I started today wanting to make something in Processing. So, I headed over to Daniel Shiffman’s The Nature of Code online courses. I had been wanting to play with Perlin noise for some time now and just started sketching with the newest version of Processing (0118 beta).

What came out was quite the accident. So, I present NoiseBreather (that’s where you can get the source code as well). All it does is use the built-in Perlin noise generator to 1) select a position on the y-axis to draw, 2) adjust the size of the screen-captured area, and 3) pick a color from a randomly generated pallete.

While I really like the granularity of detail as the piece draws, I’m really more interested in the motion itself. So, I think I’ll play with this some more later.