Puckey Portrait Machine

May 18th, 2010 · 2 Comments

When I first started writing generative graphics code as a student, I spent hours trying to decipher existing work, I wanted to understand how certain mechanics were built, simple things like attractions, avoidance, movement along a curve, simple physics… etc. The list seems endless and I have from time to time found myself back in the mindset of my student days, trying to work out how existing code pieces are built to then add this particular technique to my toolset. In a way it’s similar to the way much design was taught in the old days, you study with a master of the field and in due time, you move on and create your own footprint.

This brings me to Delaunay (and of course, Voronoi - but I’ll get to that in more detail in another post).

Jonathan Puckey has been making amazing work with Jürg Lehni’s Illustrator plugin Scriptographer. In particular I have been (for a while now) fascinated with the Delaunay Portraits series. With a custom Scriptographer script, you can create simplified renderings of an underlying image.

So I built the ‘Puckey Portrait Machine’ in Processing.

demo_in_progress_500×500.jpg

I wanted to understand the dynamics of the Delaunay-Voronoi relationship and I wanted to learn to control it - there’s a certain beauty in exploring mathematics from a naive standpoint, poking at it, changing variables adding bits to see if it breaks. I still do this some times. But in this learning exercise I wanted to gain control and be specific.

I made it a point to try and hit Puckey’s style and aesthetic as close as I could to ensure I was harnessing the mathematics correctly (and not just blindly creating some random, accidental experiment). So far the software has two main drawing modes.


Manual Drawing

monroe_manual_control_500×500.jpg

In this mode, you manually place each point with the mouse, this adds the control needed to get to the aesthetics that Jonathan Puckey has in his work, and this was my initial aim.

Following this, I wanted to experiment with more automated renderings, so I wrote a mode to automatically fill the screen with points. This saves a lot of mouse clicking, but complete takes away the ability to control the output. As expected a series of random points on a screen are distributed fairly evenly which results in a muddy and not too interesting result.


Automated Drawing

monroe_automatic_500×500.jpg

I wanted to have the ability to add more detail to certain places of the geometry while keeping the overall randomly generated state mesh. This would allow me to add detail to iconic parts of the face, like eyes and lips.


Adding Detail

monroe_added_detail_500×500.jpg

All of these can of course be exported out as Illustrator vector files and printed in huge formats and in such, they very much relate to the original software piece by Puckney.

Tags: experiments · processing · code driven graphics

2 responses so far ↓

  • 1 Kasper Kamperman // May 19, 2010 at 3:45 pm

    Was just doing some research on this and did some experiments in processing. Saw already some great examples from Quasimondo with this technique.

    Is the application and/or processing source somewhere available ? Or did you create it for your own use ?

  • 2 Mikkel // May 19, 2010 at 3:52 pm

    Not quite sure where this is going at the moment. I built it for myself and wasn’t planning on releasing any of it besides the process of making it - the idea was to get to know Delaunay/Voronoi and then do something of my own with it.