television as controllable light source

Last night I read more of ‘Brian Eno: Visual Music’ by Christopher Scoates and came across Eno’s use of televisions as light boxes and looping recordings of music with Daniel Lanois. There was also a description, photograph and diagram of ‘Shutter Interface’ , the 1975 work by Paul Sharits, which involved four projectors each showing a loop of single- colour frames that overlapped on the wall, creating a mix of hues. Each loop had one black frame to introduce a flicker that interrupted at different moments in the four cycles.

The films are all out of phase/sync and therefore a multitude of variational states of interactions between them is set in (potentially perpetual) motion. For Sharits, the fades and dissolves were “‘active’ punctuation for the ‘sentences’ being visually enunciated” and in their variable syntax recall a Chomskyan notion of grammar.”

The reference to Chomsky may seem high-falutin’ but it refers back to an earlier passage which discussed the linguist’s theory of

“…linguistic competence in which he argued that language has an infinite set of sentence combinations, which became known as ‘generative grammar.'”

It occurred to me that creating an equivalent work in Processing would be very simple, so I immediately started writing one, though my initial thought of using an OOP approach may have been slightly over the top, but that depends on how far I might want to take this. In these days of Processing, Arduino, LEDs and ubiquitous computers, it seems odd to think of Eno regarding television to be “.. the most controllable light source that had ever been invented…”, but the availability of simple alternatives doesn’t diminish his work.

Furthermore, this nocturnal burst of programming spurred me on to resume work on my abandoned path-following Saffron Mandala sketch and my as-yet unstarted slitscan sketch. From past experience I’m wary of promising imminent future posts on these sketches, because there are other things to deal with such as work, family, food and house but I also need to catch up on sleep too. But these are now my projects to focus on.

Tags: , ,

Saturday, January 4th, 2014 coding, generative art No Comments

further harmonograph tweaks

Continuing the theme of harmonographs, I tweaked one of the weights in my ‘back to basics’ harmonograph, and got this result:

Again, there were slight differences each time the cycle appeared, so this image would have had many more lines in it had I left the sketch to run for longer. In contrast to the previous version (see yesterday’s post), there is an additional ‘level’ becoming apparent in the image, which is an additional level of complexity that has resulted from a minor change in value of one variable (from 0.005 to 0.01).

Making the two weights close in value gave rise to a simpler image:

Again, there is slight variation on each cycle, so the image would have had more lines had it run for longer. I prefer it as it is, however, looking like a complicated knot in ribbon. The differening distances between lines gives it a graceful feel.

Tags: ,

Monday, November 18th, 2013 coding No Comments

‘back to basics’ harmonograph tweaked

Yesterday’s image was simple, partly because the values of variables quickly led to the same output values. Dividing both of the weights, however, leads to slight changes each time the cycle occurs. As a result, what starts as a similarly simple image:

becomes more complex merely by letting the sketch continue to draw for about ten minutes:

It was exciting to see this pattern emerge from a formula that I’d created on my own!

Tags: ,

Sunday, November 17th, 2013 coding No Comments

‘back to basics’ harmonograph

After yesterday’s unsatisfying complexity, I decided to start afresh.

I started with the basic formula for a circle: x = r*sin(theta) and y=r*cos(rho), where r is the radius of the desired circle and theta start starts at 0.0 and is gradually incremented, to provide each point on the circle’s circumference. I gave theta a different to calculate x and y, and added a different weight to each of these formulae, to become x = r*sin(thetaX) + sin(Wx) and y = r*sin(thetaY) + sin(Wy). Note that at this stage, unlike theta, Wx doesn’t vary over time, nor is there a damping effect. This produced the following simple image:

The pen started to repeat itself very quickly, going over exactly the same lines.

Tags: ,

Saturday, November 16th, 2013 coding No Comments

harmonograph in processing

In resuming this blog, I’ve discovered a few draft posts that I first wrote a couple of years ago. Here’s the first in a series on harmonographs:

My first memory of harmonographs, although I didn’t realise at the time that that’s what they were called, is of watching Tony Hart on Vision On, using cones filled with either paint or sand and suspended from a pendulum that he would set swinging in two dimensions. (Unfortunately, I can’t find any video of that on the internet to show you what I mean.)

I was reminded of this a couple of years ago when I followed a link from William Latham‘s website to Karl Sims (though the link now seems to have changed to a visual effects software site), who has instructions on how to build a harmongraph. It’s a more complicated version than Tony Hart’s, but the principle is the same, and the sample images he provides are similar.

That got me wondering how to simulate a harmongraph in Processing. There are lots of simulations available on the net, but I wanted to create my own. I found the formula for one version at Paul Bourke’s amazing website, which has lots of information on things like Lorenz Attractors, which I’ve created here and here.

Here are a couple of images from my first attempt. I like the nearly-but-not-quite symmetry:

harmonograph002a harmonoharmonoharmonograph004aharmonograph004a


The concentration of lines towards the centre is the result of damping, which is a simulation of the pendulum gradually slowing down.

The main difference between virtual and physical harmomographs, of course, is that in the former you can note the values of variables that lead to particularly interesting results, and if desired repeat them. In contrast, the latter is completely hit-and-miss. Whether you think that’s a disadvantage or not depends on your point of view.

In my simulation, despite tweaking the values of the various parameters, I can’t find a set that results in anything wildly different. Strangely though, when I used very small values, I came up with this next image, which appears to have a wobbly, hand-drawn feel to it. I suspect this is the result of the relatively low resolution of the work, so that the plotted points are forced steps from one whole number to the next.

Tags: ,

Friday, November 15th, 2013 coding No Comments

back to processing

I’ve been creating some rudimentary experiments in Processing, to get back into the way of coding.

First, there was my attempt to create a portrait from short, straight lines. The sketch is given a high-key, close-up photograph of a face. It picks random points below a certain level of brightness then draws short lines between them:

There are three main variables: the cut-off level of brightness, the number of random points picked, and the maximum length of line allowed. It would be possible to add sliders to the sketch, so that these variables could be controlled by the viewer. I looked at the ControlP5 library for use in the Erasure exhibition (which incidentally ended yesterday), but decided against using it for the interactive elements. I might try it for this exercise though.


Tuesday, May 3rd, 2011 coding No Comments

on display

I rarely mention my work here, but a strange thing happened there recently.

I frequently walk past the interactive I created for the ceramics gallery, and even though it’s four years since it was finished, I always get a pleasant feeling when I see someone using it.

Yesterday, however, I saw some more of my work on display, and it felt far more significant. A frame from my animated logo for the Erasure exhibition is on the large banner at the entrance to the white gallery, and an advert for the exhibition has been put on display in the passenger lift. These promotional items have both been created by the museum’s designer, so they feel separate from me, as though they have an independent existence with an identity of their own.

That’s why they feel more significant than watching my animated logo at the start of the two looping DVDs I edited for display in the exhibition. That seems more directly connected to me, and therefore less interesting.

So how will it feel when the long version of the banner goes up on the railings outside the museum?

Saturday, January 22nd, 2011 coding No Comments

cracked it

Another good Skype session with Ollie on Monday. We started to develop the previous session’s particle system into a smoke simulation.

I couldn’t get to sleep that night, and lay in bed wondering about using Perlin noise in the smoke simulation when I suddenly realised I’d found a solution to some code I’d been struggling with a few weeks ago. (OK, it took a while, but I got there in the end). I’d been trying to write code to simulate cracks, and had used Perlin noise to give them a natural look. It worked, but what I’d been unable to do (until my belated Eureka moment) was specify exactly where the crack should start.

Now I can do precisely that, so the way is open to write the code as a function that accepts parameters, which means I could call the function from within itself to get smaller, branching cracks. Yay, me.

Still got a long way to go with the smoke simulation, though.


Thursday, October 21st, 2010 coding No Comments

useful particle system

Another fascinating Skype session with Ollie on Monday evening when we set up a basic particle system. I’ve explored these before, but what was different was the creation of a Force class as well as the particle class. Instances of the class can be created as many times as you like within each particle. By passing different parameters during the creation of each force, you can specify how they act. It’s so simple, but very useful.

I’ve since created lots of different types of particles just by changing a few parameters: fireworks, fountains, sparks, and balls, with forces of momentum, gravity, wind and air resistance.

I’ve still to get the rebound right when particles bounce off the floor, but after that, my goals are to explore mass and smoke.


Wednesday, October 6th, 2010 coding No Comments

variations on a theme

I’ve been spending a lot of time coding recently, which has been great. Mostly I’ve been writing short sketches that take an image and do different things. In doing this, I’ve learned a few new techniques.

They’re designed to be flexible, so that they’ll work with any image. but really, in their current form, they would work best with images that have large areas of well-defined darks. I could add an interactive control for the user to select the cut-off level, so that it can be adjusted to a more appropriate setting for each image they’re applied to.

In the meantime, here are a few examples. Some are stills from animated sequences.


Sunday, October 3rd, 2010 coding No Comments