processing

p5.js

I’m excited to have discovered p5.js, the recent implementation of Processing in JavaScript. Kadenze is currently running a free UCLA introductory course in it, which I’m enjoying. The prospect of using Processing in a browser environment is great. It would have made the interactive elements of the Erasure exhibition at The Potteries Museum & Art Gallery much easier.  I haven’t signed up for the paid version of the course, so I have less direct access to tutors. Nonetheless, I’m looking forward to the sessions that cover the elements that p5.js can do that Processing can’t, though with the recent introduction of Processing 3 I’m slightly out of touch with its newest capabilities.

I still have the mandala project ticking away in the back of my head, and the possibility of achieving it online may be sufficient stimulus for me to make some real progress at last, but while writing this very paragraph, an e-mail arrived from Kadenze informing me of a new course starting on graphic illustration. I succumbed and am now enrolled. There was no session this week on the p5.js course so  I thought ‘why not?’ Of course, there are lots of reasons why not, most of them listed on cards on my Trello boards, but it could be interesting and useful. There’s nothing to lose if it doesn’t work out as long as I keep focused on the other things I want to achieve.

Tags: ,

Thursday, November 12th, 2015 coding No Comments

changing horses mid-stream

Yesterday was the first day of Week 1 of Creative Coding offered by Monash University through Future Learn. The free course introduces complete beginners to Processing, taking a fascinating visual and philosophical approach to the subject. It offers great resources as supporting material, so although I’ve already completed the tasks for week 1, I’m already impatient to get started on the remaining five weeks.

Coincidentally, yesterday was also Apple’s Worldwide Developers Conference in San Francisco, where the company announced a new language for creating apps: Swift.

On first inspection, Swift appears, at least to an innocent like me, to be far more approachable, like Processing, than Objective C, on which it’s built. I can see that while battle-weary developers may groan at yet another proprietary language, this could be a good time for a beginner to get to grips with Swift.  I’ve looked round to investigate some of the options for creating apps such as Appcelerator , but I remain unconvinced.  I’m still keen to learn more about Processing, but perhaps I’ll hop on board Swift, though it feels like I would be committing myself to a life-changing decision, like someone deciding which football team to support.

Tags:

Tuesday, June 3rd, 2014 coding No Comments

‘i’ve been a miner for a heart of gold’ – neil young

After yesterday’s post about my version of the 1975 work ‘Shutter Interface’ by Paul Sharits, I’ve been inspired to resume work on another generative piece I started last year, and thinking about it last night kept me awake for several hours. Eventually I had to get up to make some notes before I forgot my solution to the problem I was struggling with.  i remember this pattern of disturbed sleep from the days of my coding sessions with Ollie Glass, which, in turn, reminded me of my genetic algorithm coding. Food for future projects perhaps.  To keep me awake today I’m listening to ‘Here Come The Warm Jets’ and ‘Taking Tiger Mountain by Strategy’ by Brian Eno, no doubt the consequence of reading ‘Brian Eno: Visual Music’ by Christopher Scoates. Ah the 1970s, derided by many for their excesses, but I see them as a rich mine of inspiration.

I can’t remember when I first visited the turf maze at Saffron Walden, but it may well have been the 1980s. Anyway, no matter which decade it was,  it’s still part of the relatively distant past to be mined,  because it was on that first visit that I ‘saw’ the image of the pattern that would be created by people traversing the different sections of  concentric loops when seen from above. And that’s the starting point for my latest project: blobs revealing a pattern by following an otherwise invisible path. It’s been lurking at the back of my head ever since. Which means devising a path-following algorithm, and that’s where I stumbled when I worked on it before. I’m convinced the solution is within my grasp. Last night I struggled with the code to control the ‘release’ of blobs at random intervals but I have an idea how to do it now.  So simple once inspiration strikes! A mere matter of interpreting my late-night scribbles and testing them. I’ve also thought of ways to test a path-following algorithm. So much to do, but fun. Now, on with the digging!

Tags:

Thursday, February 6th, 2014 coding, generative art 1 Comment

flicker

Yay! It’s complete!

I’ve finished writing my first piece of generative art for a long time.  I wrote about my plans recently.

Not surprisingly, I used Processing, and took an OOP approach (Object Oriented Programming), to represent four loops of film, each projecting a square of colour, slightly overlapping with the next one,on a blank wall, and with each loop containing only plain coloured frames, but with one frame in each loop a pure black to create a flickering effect.

I call it Flicker, and it’s based on the 1975 work ‘Shutter Interface‘ by Paul Sharits, as described in ‘Brian Eno: Visual Music’ by Christopher Scoates:

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.”

I’d like to post the sketch so you can see it running, but it doesn’t work in Javascript mode, so here’s a still from my sketch, though, being a still image, it entirely misses the point of the flickering. You’ll just have to image a brief interruption of each square at random intervals:

flicker

Tags:

Wednesday, February 5th, 2014 generative art No Comments

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

harmonograph004a

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

resuming normal service

A lot has happened in the long interval since my previous post, and I’m referring not just to my stroke- induced temporary paralysis or my permanent partial blindness, but to the continuing rise of Facebook that dented my once-confident conviction that blogging is a valuable and relevant platform.

Recently I attended a couple of drawing and painting workshops at The Art Barn in Gamlingay, the first on portraits and the second on flowers.  This follows my unsuccessful partaking in a Watercolours for Beginners class in my local village college.  It occurred to me that I wanted to share my thoughts and experiments in a longer and more permanent way than Facebook or Twitter. I’ve also recently ventured into the world of generative art, resuming my use of Processing, to create a mandala based on the turf maze at Saffron Walden. I suspect that this will be the subject of future posts so I won’t pre-empt those, only to say that it involves developing a path-following algorithm, which is a new one for me.

Tags: ,

Thursday, November 14th, 2013 drawing, generative art No Comments