[Flash 9 is required to listen to audio.]

“1923”

This piece is from my set in Korea, performed at Kunsthalle. It’s the first work I’ve generated using the musical notation system I’ve been (sporadically) developing, called Braid. The software outputs OSC, which here I’m converting to MIDI and routing to a MeeBlip synth. Other than a bit of EQ and reverb, you’re hearing the raw output.

It’s not fully realized by any means (neither technically nor compositionally, and the eventual intent is to play this music instrumentally), but I’m happy with this first step. I takes me somewhere else, emotionally, than I can get to when writing on the bass. In general, it sounds very different than anything I’ve ever produced, save my early pieces at the CMC, and in fact this is a return to some of those interests.

The formal thrust here is about processes, a la Steve Reich, which are a part of the DNA of so much of the music I love, from Glenn Branca to Liturgy, Harmonia, or Oval, or Tristan Perich or Florent Ghys, or Zs, Live Footage, or … This kind of thing hasn’t shown up too much in Multitudes (but it’s definitely in there). But with Braid, I’m embedding it into the bias of the notation itself.

This summer back at Eyeofestival, I had the pleasure of talking with Casey Reas. The formalism in his work owes an acknowledged debt to process-oriented visual artists like Sol Lewitt, but he said Reich was just as much an influence. Processing is, among other things, a powerful realization of the ideas born in this aesthetic.

What’s the musical equivalent? I get into trouble here, because of course there are a trove of amazing audio software platforms. Most are elaborate visual interfaces with a set of biases I’m not interested in conforming to. The great code-based environments, SuperCollider, ChucK, RTcmix, etc, including Max/MSP and PD, are primarily concerned with timbre these days (is that fair to say?), as are hardware hacking / circuit-bending noise-centered operations. But is there something to be said for Max without MSP? I think I’m moving backwards in my software interests, or at least it’s been kind of challenging to round up MIDI gear. In any case, Braid is to be my personal Processing for musical processes. If it gets mature enough, it could be a public project down the line. (Props to Tristan for solving this with his chips.)

#meeblip #braid #midi #synth #composition #reich #reas #process #processing #perich
→ 2011-11-20         

A SIMPLE PROCESSING-INSPIRED DRAWING INTERFACE FOR PYTHON

[code] Python (2.6), GPL

In my recent work at the lab, I’ve been doing some simple datavis to make sense of the various biometrics I’ve been gathering. I’m committed to python for this sort of thing, but I’ve found it wanting for a dirt simple drawing library, absurd as it may seem given the number of available graphics packages. The power of Processing / processing.py, Nodebox, Field, matplotlib, etc, mean that they end up imposing on, if not dictating, the flow of a program. I wanted a single import that gives me basic, pythonic drawing commands and which can show me the result in as lightweight a way as possible.

I ended up putting together my own, which is a wrapper for PIL and aggdraw.

The idea certainly wasn’t to match the drawing capabilities of Processing et al, and the interface has some serious limitations (there’s no animation, no context stack, performance is questionable, etc). But it does succeed in letting me take a chunk of data from numpy, normalize it, and feed directly to drawing commands with only a single line of setup.

For instance, to just graph a time series and check it out:

    data = normalized numpy array at a given sampling rate
    ctx = drawing.Context(1024, 768, relative=True, flip=True)
    for x, y in enumerate(data):
        ctx.line(float(x) / len(data), 0, float(x+1) / len(data), y)
    ctx.show()


This is a work in progress, and I may develop it further as requirements arise, but it will remain simple! Minimal documentation and a few easy examples are present in the sourcecode.

Edit: example of the module in action, visualizing fitbit data.

Update (11-07-13): animation

Thanks to built-in event capabilities of OpenCV, I’ve grafted on the ability to work with animation. ctx.frame() outputs the current canvas to a window. ctx.clear() clears it. Put those in a loop and off you go.

Random accumulating squares:

    ctx = Context(640, 480)
    while True:
        x, y = random() * ctx.width, random() * ctx.height
        width, height = random() * 200, random() * 200
        fill = random(), random(), random(), random()
        ctx.rect(x, y, width, height, fill=fill)
        ctx.frame()
#code #drawing #processing #python #datavis
→ 2011-06-23