TODAY, CREATE. » Processing

Line Topography Update

Mike Creighton — Sat, 29 Oct 2011 22:04:57 +0000

I spent some time earlier in the week refining the drawing algorithm even further, focusing on color palette selection and line weight distribution. I think I’m getting closer to something the produces pretty consistent results.

My next step — or perhaps experiment — will be to create some color palettes based on actual color fields that I produce using real paint or some other image source. I want finer control and intention over the possible color palettes, and while toxiclib’s color utilities are pretty amazing, I’m finding that the ColorRange constraints produce less-than-desirable results most of the time (too much or too little saturation and brightness at undesirable moments).

Here’s a demo of the Processing app so you can see the renders in realtime:

And here is some more hi-res output from the app:

+ View hi-res.

Line Topography

Mike Creighton — Wed, 19 Oct 2011 22:20:06 +0000

+ View it large!

Here’s a continuation of the Line Sketching post I did last week. What you’re seeing here are larger, higher-resolution renders that use a further-tweaked drawing algorithm, concentrating more on form and color.

The key to these pieces is seeing them in their native resolution. There’s so much texture and pseudo-form that emerges from subtle shifts in a single line over time. Here’s an example:

Full View

+ View it large!

Detail View

I need to continue tweaking the drawing routine and color choices before I’ll be happy enough to take these to a printer. Also, I’m going to be sticking any additional interesting output from this thing into a Flickr set called “Line Topography”.

In the mean time, here are some interesting ones that came out of the last 50 renders I did yesterday:

+ View it large!

Line Sketching

Mike Creighton — Mon, 10 Oct 2011 23:15:57 +0000

So I’ve been feeling less than creative and less than productive for the past 45 days or so. Yesterday I realized I needed to make something even if it was crappy.

Examining some of the recent things I’ve been inspired by and even some of my older posts here, I drew upon the following line-heavy references as my starting point:

visp Output Sample 001 (from 2007)
“flow” from Merdan Agayev
“line drawing, unstable/uneven surfaces: carpet”
All the work of Jean-Pierre Hébert

I’m in love with line. I’m especially in love with really dense linework that yields faux-3D forms and false topographies.

So I jumped right into Processing with a simple idea:

Let the user pick a horizontal line of pixels from camera input.
Analyze those pixels, deriving an array of values based on pixel brightness.
Create a vector line whose peaks and troughs are based on this array of values.
Use a bunch of Math.random() and Perlin noise and magic to draw this line on the screen from top-to-bottom.

Four hours later, interesting stuff started coming out. I’m making heavy use of GSVideo for camera input and toxiclibs for Perlin noise and color.

My goals for the end of the week will be to finesse the color logic, have the “input” line morph through two or three forms throughout the process of the render, and do some post-processing in Photoshop to get the colors to unify even further. I want to make some large prints. I think I also want to do a couple hand-drawn renditions based on some of the digital output.

Here are some more Instagram’ed crops from the first wave of output:

The Mode7 “Dusk Drops” EP Album Art

Mike Creighton — Thu, 14 Jul 2011 21:28:43 +0000

+ View the piece on Flickr.

Finally we’ve arrived at the final image to be used for the album art of Mode7‘s upcoming EP “Dusk Drops” (see above). There were a lot of contenders, but in the end, this image satisfied a certain visual balance and the general feeling of ominousness that we were looking to convey.

For these final renders, 2850×2850 images were generated by Sunflow, using the special Thinlens camera which allowed me to simulate a shallow depth of field. Each image took about 12 hours to render on a quad-core Intel i5 Windows 7 box.

Further post-processing was done in Photoshop to simulate things that we’d see in traditional photography: vignetting, chromatic abberation, and a subtle level of visual noise. Some color tweaking and other manipulations were done as well just to make the images a bit richer.

For the CD label itself, we’re going to use the following image:

+ View the piece on Flickr.

And then there were a few more images that I decided to render and treat, just because they were compelling to me and I wanted to see what they’d look like if I took them through the entire process.

+ View the piece on Flickr.

I’ll be following this post up with a video demoing the Processing app that I created for generating these compositions once they EP has been officially released in a few days.

Reducing 3,500 to 29

Mike Creighton — Sat, 02 Jul 2011 04:52:32 +0000

Back from the Eyeo Festival in Minneapolis, I’ve taken a stab at making my final set of selects from the numerous compositions I generated last week.

After the last post, I went in and tweaked a couple of parameter ranges and how the noisy terrain was rendered and generated another 3,500 compositions, which you can see here:

+ See it super large on Flickr.

After the computer churned these out, I spent a few hours looking through them and managed to cull the set down to an even 350. But as I mentioned before, the next step was to render these using Sunflow, which I did right before I left for Minneapolis. Rendering the 350 images at 1280×1280 with no anti-aliasing and a very low sample setting took about 29 or so hours on a quad-core Intel PC. I had it dumping the output into a Dropbox folder so I could check on the progress on my phone during my trip.

Tonight, I took the next step and chose a final set of 29 images that are contenders for the final render. In that render, the visual noise will fall away considerably, and I’ll be generating a 2850×2850 image suitable for a 300dpi CD cover print.

You can see the 29 images I picked in this Flickr set. As of right now, these are my five favorite renders:

+ View the piece on Flickr.

10,000 Choices

Mike Creighton — Thu, 23 Jun 2011 20:35:05 +0000

You know what computers are good at? Being creative.

That is, they’re amazing at working tirelessly and generating variations, given the proper constraints.

I’m in the process of creating some album art for a friend of mine, Mode7, for an upcoming EP release. I wanted to create something that was simultaneously intentional (i.e. I had ideas for an image) and generative (i.e. I’d let the computer make stuff up too). For the last couple weeks, I’ve been slowly building a Processing app that helps me generate compositions given a curated range of possible random values.

Last night, I asked my app to show me 10,000 variations on a theme. Here’s what it came up with:

+ See it hi-res on Flickr.

And here’s a zoom of a 6×6 grid from that output:

And here are some random selects that I never would have come up with on my own:

These images are rendered in an OpenGL context, so the lighting is basic and even throughout. But this is only the first step in the process of creating the final image. The Processing app is a tool for creating compositions and color schemes. In the end, my selects are saved out as Sunflow scene files and rendered in Sunflow with global illumination at a super-high resolution. Here are a couple test renders to give you an idea of the end possibilities:

There are a couple things I want to note about this whole process.

Symbiosis

What has happened in this process of creation is the emergence of a symbiotic relationship between me and the computer. I started with clear intention for the type of image I wanted to create. As I began programmatically building the structures of the elements I wanted to use in the composition, it wasn’t until I saw the way the computer rendered my forms that I would continue moving forward. These renders influenced my direction and provided a sort of course correction.

The same happens when I ask the computer to provide me with a series of choices. I become the curator and the computer becomes the creator. It seemingly influences me as much as I influence its output. This is especially true when you introduce Math.random() into the relationship. That singular function is the computer’s very powerful voice.

This whole process is like a dance or a dialogue. And I’m beginning to learn how powerful this can be in discovering possibilities for creative output that I wouldn’t have been able to achieve on my own.

Discovery

When I tell the computer to give me 10,000 choices, the process of reviewing those choices makes me feel like I’m a scientist or an archaeologist exploring unseen worlds or newly revealed information. I’m seeing something wholly new. A world that had the possibility of existing, but only up until last night, never actually existed. And here I get to discover that new world.

There’s something so utterly enchanting and delightful about this. Flipping through these images brings me closer to some level of innocence and awe that I simply don’t encounter very often in my life. And now I’m hooked.

Exploring the Data

Mike Creighton — Tue, 06 Apr 2010 16:09:50 +0000

This is a representation of the 180,000+ points of data that were captured during the processing of making my last drawing. They’re quick sketches done with Processing and the toxiclibs Processing library (specifically for the Verlet physics engine).

The first step here was to create something cumulative, just so I could see the data over time. The end goal (originally) was to create a data renderer that created a static piece (or pieces) that could stand side-by-side with the original drawing, like a diptych. But embedded in that goal is an attempt to bring forth the energy and motion that went into the original drawing. That’s why I created this whole system in the first place.

I’m not there yet, but I think you need to swim in the data for a little bit before you can get a sense of what it really is.

Flow Lives, but Now with No Glove

Mike Creighton — Mon, 02 Nov 2009 20:16:21 +0000

Last year, I started a pet project called “Flow“. The point of the project was to find some intersection with more traditional art-making techniques and my interests in the digital realm.

Well, that itch has resurfaced, and I realized I was making things way too complicated. This time, I’ve turned to using some open source tools for the data capture portion of the project. Components include:

It’s actually really simple to get set up. Here’s a little demo of how it all comes together.

Next steps include making a client to listen for the TUIO data generated by CCV. I’m probably going to opt for an AS3 AIR client, since it’ll be fastest for me to create. Then create a web application that captures and stores this data. This I’ll build in CodeIgniter, again, since it’ll be fastest for me to create in this environment.

I’ve got a lot of stuff on my plate this month, and I want to participate in this month’s NaNoDrawMo on top of it. So, we’ll see where things net out.

Noise Tube: The First Renders

Mike Creighton — Mon, 31 Aug 2009 23:02:04 +0000

I’m continuing the Perlin noise saga. The last thing I did was port the Noise Column project over to Processing and openFrameworks.

This time I wanted to add some actual volume — not just perceived volume — to the form. These are just some initial tests that you see above. I’ve got a ton to learn about lighting and optimization and matrix transformations. Robert says I need to use “per-vertex normals”. I say “OKAY!” Hopefully I can start adding some of these things over the next couple weeks and really use this project as a general learning tool.

For now, I’m developing all this in Processing using the PGraphicsOpenGL renderer. I’m not using any actual OpenGL calls directly; I’m only using the Processing API. One little discovery I made yesterday: PeasyCam turns out to be a really sweet little camera library for Processing. Adds mouse control over the camera with a single line of code.

The ultimate goal of this is to create two different pieces. One will be a rendered motion piece. It probably won’t have any audio and will function as an ambient looping video. It will be submitted to this call for entries: Flow Interrupted.

The second piece would actually be interactive. I’m going to toy around with camera, audio, and touch as discreet inputs (all separately). This will give me a chance to play with the new HP TouchSmart PC I got. So you could consider the second execution to be more of an interactive installation piece. And that’s going to be submitted to this call for entries: FLUID Interactive Digital Art.

Check out some of the stills:

+ View larger Image.

Porting Noise Column

Mike Creighton — Sat, 25 Jul 2009 23:47:54 +0000

+ See the full Noise Column Triptych Flickr Set.

For my friend Nate‘s 30th birthday, I created a one-off set of prints based on the Noise Column and Noise Column Wallpaper Generator mini-projects. It was largely an exercise in creating something with OpenGL.

Thus began the effort to port a bunch of ActionScript 3.0 vector drawing commands over to line loops in OpenGL. I used Processing as my framework since I’m used to it, and it gave me a 1:1 mapping of the OpenGL API. I was able to use various C++ OpenGL tutorials and books to accomplish my goals. I used the super-helpful TileSaver classfrom Marius Watz to generate hi-res renders.

Now after all this, I realized that it was time to take the plunge and start getting closer to the metal. Thus began the next port of Noise Column; this time I went to C++.

I’ve been reading Stephen Prata’s C++ Primer Plus for the last couple months on and off. For me, learning from books makes sense. Moreover, learning the reasons for writing the code you write is so essential for retention for me. This book is simply great.

So for the C++ port, I moved over to openFrameworks as my C++ framework. OpenFrameworks is great, but there’s still a long way to go before it becomes the Processing of C++. Regardless, I had learned just enough C++ to figure out how to port all this stuff over. Two days later, I was able to generate a moving version of Noise Column:

Now it’s time to start doing stuff with “real” 3D in OpenGL — a dimension I’ve got nearly zero experience with.