WEEK 4: Testing Minim for Audio Reactivity

This week I started exploring the possibility of incorporating audio into a processing sketch. There are many challenges that come with audio reactivity, for it is CPU intensive. Therefore, it is important to make sure that the code is lean and simple. The Minim library is based on JavaSound API, Tritonus and JavaZoom’s MP3SPI that provides an easy to use audio library for developers in the Processing environment. This library is included with Processing once downloaded, along with examples of most of its basic functions.

My goal this week was to test audio reactivity and how it would perform with the sketches that I am working on from the Daniel Shiffman book (The Nature of Code). From the Minim library, I touched upon its ability to monitor live input signal and use audio signal from the computer. However, using live monitor input isn’t useful for my purpose with regards to my directed studies project. Since I want to perform my compositions only in Ableton Live, I will not be using any live input signal. That being said, both are great ways to achieve audio reactivity for they both work equally well.

My first test with the Minim library was to include live monitor input to one of my sketch, based on the monitor input example from the library examples folder included with Processing. The result was not impressive and perhaps a much leaner algorithm is needed to make this work. Here is a video of the result of this test.

Further adaptations of the same sketch proved to be more fruitful in terms of reactivity. Drawing shapes such as circles and rectangles is much more CPU intensive than it is to draw points and lines with vertices. This is an a video of the improved sketch with Minim implementation featuring Daft Punk’s “Game of Love” 🙂


Week 3: Exploring Processing

This week I continued to learn tricks and techniques in programming animations by using laws of physics. I went through a few chapters of the Daniel Shiffman book (www.natureofcode.com), and got a few interesting results out of it.

Here is an example of how I can program a gravitational force of attraction and trace paths out of that force. The first example shows only one object tracing a path.

This example shows multiple object affected by the force of gravity.

Here is a picture of the kind of design I got out of this program.


With the same gravitational force, adding a vector for object’s direction of rotation can trace beautiful designs. Here is an example.

This following example uses multiple forces of attraction located in random spots of the screen.

In this final example, all the objects are attracting each other simultaneously. The particles form interesting patterns as a result.

Week 2: Basic MidiBus Implementation

With the MidiBus library, written by Small But Digital (http://www.smallbutdigital.com), I am able to control my Processing patch with MIDI messages from any external device or from a virtual MIDI port using any DAW of my choosing.

For this week’s experiment, I picked out a sketch from the Generative Design book, modified it and implemented MidiBus to it. The result allows me to basic control of the patch using MIDI Note on messages and Controller messages.

Here is the result of this week’s experiment:

Week 1: Learning Processing

For my EP491 project I’ve decided to create a VJ system controlled by midi using Processing and the MidiBus library. For this week I began learning the basics of Processing from three main sources which are The Nature of Code by Daniel Shiffman, Processing: A Programming Handbook for Visual Designers and Artists by Casey Reas and Ben Fry, and Generative Design by Hartmut Bohnacker, Benedikt Grob, Julia Raub and Claudius Lazzernoi (editor).

With Shiffman’s book, I am learning about object-based programming and how to program animations. The results for this week are as follow:

This example demonstrates how I can use a Gaussian function to populate objects in a certain area. In the case, the objects are distributed around the centre of the screen.  

This example uses the random function to create a random XY coordinate as well as the colours moving the object in steps and changing the colours each step it takes.

This example demonstrates how I can use the noise function (Perlin Noise) included in the processing library to trace a path for an object. 


During my previous semester at Berklee College of Music I began learning about interactive visual programming using MAX/MSP Jitter which inspired me to continue on this path for my EP491 Directed Studies. Here are some of my work using MAX/MSP Jitter.