Method Art

2011-11-18T13:20:00.000-08:00

I put together a quickie portfolio site, which should make it easier to find the good stuff on this blog.

2011-11-15T10:11:00.000-08:00

I've started a new blog about compressive structures. Bit of a niche thing, but an abiding fascination, so I thought it deserved its own dedicated corner of the internet.

2011-11-08T09:20:00.000-08:00

The Kinect: A Camera that Gives Good Zed

Earlier this year, Monique Priestley interviewed me for my thoughts on the Kinect as part of a project for her Master of Communication in Digital Media program. She was interviewing developers who had produced notable kinect demos. My replies to her questions are pretty well-trodden ground by now, but I thought I'd share anyhow. For them what's innerested, you can see a video of the demo I wrote here.

What is the Kinect allowing you to do that you weren't able to before?

I usually say, the Kinect: finally a camera that gives good zed.

When you do computer-vision, you at first always have to remind yourself that you only have two dimensions. Depth information is not available. Our own depth-perception is so instinctual that you actually have to become habituated to not having it available when you do computer vision.

But the kinect changes all that.

[Later thought: For most of us in machine vision, the arrival of the Kinect was rather like this moment from the Simpsons.]

It bears mentioning that depth information actually could be had before the Kinect came along; only the solutions tend to be expensive (both in money and CPU cycles), or pain to set up, and they didn't work very well; there was dense stereo, various types of structured light, and then very nice but exceedingly expensive things like time-of-flight sensors.

As for what having fast, accurate depth information allows, we're all still figuring that out, and expanding our imaginations into the new dimension.

What uses do you see for the Kinect?

I suspect the technology will find many, many practical uses that none of us even suspect. I, unfortunately, appear to only be able to think of completely useless but hopefully amusing and surprisingly software toys.

Where is it the most groundbreaking?

Again, it's simply the fact that we have fast, accurate, inexpensive, and invisibly acquired depth information.

What would you change? Why?

I would like there to be a model that worked at closer range. The current kinect doesn't work for distances closer than a meter or so. The designers apparently had full-body tracking in mind for their target applications. But it would be lovely to be able to get more detailed information up close.

What would you like to see in v2?

See my last comment, but finer detail would be sweet as well. You know: more, better, faster, cheaper.

How would you like MS to support you?

In general I aim to have as little to do with MS as possible, personally and professionally. I'm mostly a Linux guy, though I have a windows box and a mac as well.

The Kinect is the first cool MS product I've ever wanted to have anything to do with. MS's lurching and conflicted response to news of the hacking of the kinect shows me that the company leadership really didn't really grok what it was they had on their hands, and just as well: if they had known of its susceptibility to cracking, I have little doubt that Steve Ballmer would have insisted it be encrypted.

Indeed, that's one of the most intriguing things about the way this all came about: MS could trivially have made it more or less impossible to hack, and in fact, under the DMCA, a crime to even try. But for some reason, the technologists creating the kinect declined to do so. I like to think it was a mischievous sense of rebellion on the part of the kinect team, or perhaps it was just their instinct as geeks to share the coolness of what they did.

So I don't want libraries, SDKs, training videos, any of that nonsense. No ghastly "community" website featuring all those tone-deaf ideas of what the marketing department thinks hackers like. I would like them simply to decline to rescind the access we already enjoy.

Do you expect/need Microsoft to open up a set of developer tools to make tweaks/hacks easier to create?

My feeling is that nothing more is really required from them, at least as far as software is concerned. I certainly don't need anything else. I have the image and the depth map. The body-tracking code might be nice, but I think there is an open-source library that works fine.

They could make the next version twice the resolution, say, and I would be happy.

I would love to have the kinect integrated into some PTAM/VSLAM stuff -- i.e., dense 3D reconstruction along with online bundle adjustment. That would be seriously kick-ass. But MS doesn't have to implement it. I have no doubt whatsoever that people are busily working to incorporate the kinect into PTAM and similar.

What do you see as "next" after this?

I'm still grappling with the implications of what the current one makes possible. Hm, what's next....

What was the inspiration behind what you've tried?

I work full-time at Weta Digital, where we work long hours, so I had very little time to work on Kinect hacking. So my aim was to simply make something, anything, as quickly as possible, and get a video out there. There was a real gold-rush mentality for a few crazy weeks there, everybody doing exciting new things.

For a while I could only watch with my nose pressed to the glass, since it wasn't available for sale in New Zealand until well after it was released in North America. I bought mine on the first day they went on sale here.

Have you tried similar stuff with previous tech? If so, what made the Kinect different?

I've done a lot of experimentation with real-time interactive video over the past several years. I used to work in computer vision and vision-guided robotics, which gives me a lot of skills that are useful for interaction design. There are all kinds of nifty things you can do with current tools and techniques. Here's an overview of the stuff I did pre-kinect:

http://methodart.blogspot.com/2009/06/engine-room-audition.html

Good depth information makes a huge difference, makes things that are hard easy, and makes things that weren't possible doable.

A specific example: One trick that you frequently have to do when designing an interactive video installation, is figuring out what is foreground and what is background. For instance, people walking in front of the camera are foreground, and the wall behind them is background.

There are a couple ways to do this. One is to use background subtraction techniques, but they are computationally expensive, sensitive to changes in lighting, and overall, they just don't work that great. Another way is to use an infrared light source and blast it on the scene, along with a separate IR camera, and segment the foreground based on what is bright in the IR image.

But with the Kinect, you simply use the depth map. Anything closer than some threshold is foreground. Done. Easy-peasy.

Do you expect to take what you've learned over to another platform/tech?

Unlikely. There just isn't any comparable tech out there, unless you count time-of-flight sensors, which are low-res and fabulously expensive.

What is your favorite part about developing different tweaks using the Kinect?

The greatest thing is just the sense that we have a whole new blank canvas to work on. Interactive video was starting to get a bit stale -- everyone had basically done everything.

What is the most frustrating part - biggest drawback?

It feels like a quibble, but the fact that the camera and the depth sensor are slightly offset from one another causes a "shadow" effect along one side of object when you project the colour info onto the depth map. But that is a mere quibble.

2011-10-20T23:10:00.000-07:00

Interpolative Dance

I wrote a paper about six months ago on, ahem, "RBF Interpolation as a General Architecture for Expressive Middleware". It was written great haste -- I had 12 days to 1) write it, 2) write the software demoing the concept, 3) find a dancer to work with and 4) move house from New Zealand to Canada. Oh, and I had a bad cold as well. And all for nought: the paper was rejected -- a rookie effort, after all, and, as it turned out, I could only offer a tantalizing but null-ish result. Basically, if you have good mocap data, the approach works a treat; but the OpenNI pose tracking isn't quite ready for this type of application (there has been another release of the SDK since I wrote the paper, and it's probably worth taking another kick at the can). I was invited to resubmit it as a two-pager, but I ran out of time.

But whatever. I still think it's a very good idea, and I really think someone should make a system that works like this, and I think RBF interpolation is an intuitive and powerful tool for media arts applications. If anyone is interested in the source code, drop me a line. If I have time to clean it up a bit (not likely any time soon, since I'm up to my eyeballs in a very tricky consulting gig), I'll post it here on the blog.

So here's the paper. Let me know what you think. I'll write more later to explain the concept, which is simple and elegant. I can say so since it's not particularly original -- it just adapts J.P. Lewis' notion of pose space deformation to media arts applications. The pun in the title is mine, though. I'm not sure JP would want to take credit for that one.

I should point out what this approach is not: it is not simply mapping individual inputs to individual outputs. That is exactly the sort of crabbed, awkward, inflexible approach that I am proposing an elegant alternative to. Instead it is keyframing an arbitrary number of inputs to an arbitrary number of outputs all at once. Read the paper for details.

2011-08-26T07:53:00.000-07:00

I'm working a variety of tools right now. One is a vector field design tool, and another is a tool for doing region-growing/clustering on mesh faces and vertices. So now I can design an embedded field on a mesh, and then create a cluster error measure that is aware of that field to do field-aware clustering, so the resulting tiling flows very naturally along the field direction.

Nuther one, with denser clusters:

There's a field source at the center:

Slightly more elaborate field:

2011-08-02T17:11:00.000-07:00

Another experiment with generating semi-regular planar tilings of surfaces. The previous post featured meshes which were convex, which makes things much easier. I wanted to extend the technique to surfaces that have negative curvature, which is a trickier problem. There is a lovley paper from 2007 ("Constrained Planar Remeshing for Architecture" by Barbar Cutler and Emily Whiting) that I read a while ago that I couldn't find a copy of, and my recollection was that they do VSA, as I do, and then follow up with some kind of local tweaks of vertices to get the polygons to be planar. I decided instead use nonlinear optimization to tweak all the vertices to make the polygons planar, while remaining as close as possible to the original surface. It's similar to what Yang Liu, Helmut Pottman and the rest do in a paper from 2006 ("Geometric Modeling with Conical Meshes and Developable Surfaces"), except they are concerned with quad-dominant meshes.

The video makes it appear as though the optimization is essentially instantaneous, but it actually has to crank away for about 20 seconds. It generally gives good results, though sometimes it results in a few nasty looking polygons with long slivery bits, or interpenetrating polygons. Fiddling with the cost function would probably fix that.

Negative curvature will result in concave polygons. I wasn't sure if I liked the look of them at first, but they've grown on me.

2011-07-18T21:35:00.000-07:00

Some experiments using clustering on meshes to create semi-regular planar tilings of surfaces. I use a variant of a technique called Variational Shape Approximation (VSA), from one of the most cited papers published by the Caltech Applied Geometry group. The algorithm is simple, and moreover has the nice property that it's easy to retrofit with new error functions. The so-called L2,1 metric that they use in the paper, which is based on similarity of normals, resulted in too many long, skinny regions, and gave tilings which differed considerably from the clusters. After a bit of experimentation I came up with a cost function which favours compact regions, along with similarity in normals, and it works really well, resulting in planar regions which are very close indeed to the clusters.

It works well on a big range in numbers of clusters. The above example uses 300; this one uses 50 (the first frame is mostly blank due to an ffmpeg glitch):

2011-07-12T21:17:00.000-07:00

The link to the jskFx code broke a while ago because I changed hosting. For those who are interested, you can download it here.

You can use it to do stuff like this:

I've been dragging my heels in fixing the link since the code, while mostly not bad, is frequently kind of crap. I'm very interested in dataflow programming, and the implementation in jskFx is reasonably solid and flexible, but it was written in the spirit of doing the simplest thing that could possibly work (which actually turned out to work pretty well), and I fancy that I could do a lot better second time round.

Also, I've been meaning to switch the license from GPL to something less restrictive -- LGPL, or BSD or some such. The code in the download link above is still GPL, but stay tuned, something friendlier is coming soon.

2011-07-07T16:24:00.000-07:00

Fast Image Cloning Library

I've written a fast image cloning library which you can download here. MIT license. It's loosely based on this paper. It differs from it in a couple interesting ways which you can read about in the readme file.

When I saw image cloning for the first time, the only explanation I could come up with was that it must be magic. I subsequently learned that there are a situations where it works beautifully, and many other situations where it falls over. Nonetheless, when it works, it's lovely. My fond hope is that someone will use it for some cool interactive application.

A couple things I didn't mention in the video: 1) transformations can be any combination of scaling, translation and rotation; 2) it's only Linux and Mac so far (gts is the only potential problem for Windows). If anyone ever gets it going on Windows, I'd love to hear from you.

Drop me a line if you find it useful or have questions. kevin dot atkinson at gmail dot com.

[Update] Or how about this: if you like the library, send me a Google+ invite!

[Update 2] Google+ invite sorted! Thanks Nick!

2011-07-05T15:26:00.000-07:00

Paper Beats Rock, But Rock Beats Titanium

John Ochsendorf, a civil engineering professor at MIT and masonry enthusiast has really made me reconsider Frank Gehry. His buildings sometimes seem like monstrous frivolities to me now, like giant fabergé eggs, or like spending a hundred million dollars on cotton candy.

And as structures, they're frequently junk: leaky, high-maintenance, outrageously expensive. They defy gravity in a breath-taking way, but at enormous cost. Beneath the swooping, graceful forms is the brute force of massive quantities of structural steel. Structures at that scale don't want to do those things -- which is why his buildings are spectacles, I suppose. With enough structural steel, you can do just about anything, but that's not necessarily admirable.

And then there's the fact that he seems to be edging into self-parody, with buildings like this.

What Ochsendorf and Peter Rich Architects did with the Mapungubwe Interpretive Center -- turning the dirt under their feet into those gorgeous, vaulting forms, and with vanishingly small energy costs -- that's elegance. That's magic.

2011-07-01T12:20:00.001-07:00

Found this while going through an old hard drive -- some art for a flyer for a show I did 3 years ago. Isocontours of sparse convolution noise.

2011-02-22T00:08:00.000-08:00

Wave equation on a bunny.

2010-11-28T01:53:00.000-08:00

silly kinect thing from Kevin Atkinson on Vimeo.

I got a kinect last week (the first day they went on sale in New Zealand, as a matter of fact!). This is a first little hack to get my feet wet.

[Update]For them what's innerested, here's the source.

[Update 2]This effect was featured on New Scientist TV!

[Update 3]A few download links on the site are broken since I recently got some new hosting. I'll have them fixed in a day or two.

2010-11-07T13:34:00.000-08:00

CONNY GROENEWEGEN CATWALK SHOW 2010 from Duy Quoc Vo on Vimeo.

Duy Quoc Vo is a very gifted fashion photographer based in Amsterdam and London. He used my wobble effect in this seductive, surreal film he created for Dutch Designer Conny Groenewegen's recent catwalk show in Amsterdam. Both are exciting talents to watch.

I had to substantially rewrite the effect to support offline rendering at HD resolutions, and it was a bit of a challenge to get it ready in time, but I'm very glad it all worked out. My friends will be once again tickled that I worked on a fashion event, since I usually dress like a flood victim.

2010-05-25T02:36:00.000-07:00

Nuther twist on the idea of novel means of depicting an image using lines (click on the pic for a larger version). The lines in this image actually form a tree. It looks to my eye like cracks in a surface, and if I had time, I'd work up a rendering which brought that out.

This is actually a portrait of Katherine Mansfield. I had a small literary crush on her in my bookish youth. It was faintly odd to discover upon moving to New Zealand that I was actually living in her home town.

2010-04-05T02:51:00.000-07:00

Gray-Scott Reaction-Diffusion on a Sphere from Kevin Atkinson on Vimeo.

Gray-Scott reaction-diffusion on a sphere. The code will work on arbitrary meshes, since it uses the mesh Laplacian in the diffusion term. Pretty simple, but for a little while I thought I might be on to something, since it took a bit of digging before I found a paper which addressed reaction diffusion on other than regular grids. There's paper from 1991 which discusses reaction-diffusion on arbitrary surfaces, but it's very complicated and expensive. Finally, I did find a 2007 paper which uses much the same approach as I'm using here, which is super simple.

Slightly more complicated geometry:

Gray-Scott Reaction-Diffusion on the Stanford Bunny from Kevin Atkinson on Vimeo.

Denser mesh (327,680 vertices):

Gray-Scott Reaction-Diffusion on a Sphere (dense) from Kevin Atkinson on Vimeo.

2010-02-08T13:16:00.000-08:00

Virtual Ball Pit from Kevin Atkinson on Vimeo.

For them what's innerested, follow the link below for a pre-built Freeframe version of the ballpit effect. It has been used on-stage by the Killers for a year now, so I thought it was about time I released the binary. The core code is part of the jskFx framework, but I know that it has been a challenge to use my lightly documented code.

Freeframe 1.0 Ballpit Effect

I'm always curious about how people use my stuff, so I'd be tickled if anyone who is using it dropped me a line to let me know how it was received.

2009-09-15T03:20:00.000-07:00

I can't really post anything about work, though it probably wouldn't hurt to say that I've been working on an automated matte extraction program in my spare time. It uses what is supposedly a state of the art algorithm for extracting mattes from natural images. It sometimes works pretty darn well, though overall it's fair to say that green screens aren't going away any time soon.

I was grumbling about what a poor matte I was getting from this image, when it occurred to me that while it's a lousy matte, it's a rather striking artistic effect.

2009-06-08T05:45:00.000-07:00

Engine Room Audition... from Kevin Atkinson on Vimeo.

[Update: For those new to the blog, I've written a dataflow framework for real-time video effects, plus a number of effects implemented within that framework (some of which are demoed in the above video). In this post I'm announcing that I'm open-sourcing that framework]

A few months ago, I made this post on reddit.com, where I crowd-sourced my then-just-begun job search. The post went to the top of the programming page and even squeaked onto the front page of the main reddit. As a result, I got an interview with Weta Digital, and after two very long interviews, I was offered a gig there with the code group. My wife and I leave for New Zealand tomorrow. (Finally! Our visas were delayed for about six weeks, but they arrived by Fedex this morning.)

I've been vaguely intending to commercialize this work for a year, but I just don't seem to have it in me to be a software vendor, and I think it's a bit sad to seal these effects away inside closed binaries. Also, I no longer have the time.

So, I decided to open source the lot. Here's the code:

jskFx code.

The code is generally not half bad, though after a year where I've really concentrated on enhancing my coding skills (reading Andrei Alexandrescu, learning template meta-programming and such like, delving deeper into boost), it's not the way I'd do it now. It was written in six weeks, on a brutal deadline, so signs of rushing are sometimes apparent (though most of the effects themselves were developed over the previous couple of years). Also, this stuff is way overdue to be ported to the GPU.

The "flowy-blowy" effect never made it into the jsk framework, since I just ran out of time, and the code was a bit of a mess. I'm also a bit wary of releasing it as is, since it uses Jos Stam's semi-Lagrangian interpolation technique, which I believe is covered by some obnoxious patent or other. Messrs Lagrange, Navier and Stokes were kind enough to not to patent their stuff, but Mr. Stam, or perhaps just his employer, had other ideas.

In any case I'm currently rewriting it using a lattice-Boltzmann approach. Hm. Maybe I should look into the patent situation there? But then, I know that Blender's fluid sim is lattice-Boltzmann, so it should be okay.

About the name: The code was created in its current form last summer for a cool gig that a fellow named Joel Gethin Lewis (interaction designer, bon vivant, and all around jet-setting, conference-headlining man-about-town) landed us in New York. You can read about it here. For the gig, I took some video effects I had written over the previous couple of years, cleaned them up, and then wrote a node-based coding framework that they could operate uniformly within, and wrote a couple new effects besides.

A clever fellow coder named Shawn Bonkowski also created some effects for the show, though I haven't included his code in this release. I'll be in touch with him to see if he'd like his stuff included in the next release.

As a result, I used the prefix "jsk" (for Joel-Shawn-Kevin) to all the objects in the library. All the code in this release is my own, but I kept the prefix to honour the contribution of the other guys to the event, and commemorate the circumstances that gave it its birth in its current form.

2009-04-27T09:45:00.000-07:00

Wild Beasts - Brave Bulging Buoyant Clairvoyants. Dir: OneInThree from OneInThree on Vimeo.

The endlessly inventive directing duo oneinthree last year produced a visually scrumptious music video which uses the Droste effect with hypnotic results. Dudes are on their way to the big time, recently producing their first big budget commercials in Europe.

I was inspired to create a realtime version of the effect which can be downloaded here. Only for mac, currently, though if the people clamour for it, I'll recompile for windows.

Update: Here's the PC version! Unzips to a directory containing droste.exe. With any luck you have all the required dependencies. Drop me a line at kevin dot atkinson at gmail dot com if you have issues.

Update:Some Windows users may have to install the VC runtimes.

Almost forgot to mention: if you are running the app, press 'f' for fullscreen, 'w' to return to a window, and 'esc' quits.

Update:I haven't had time to do a full source release, since it is going to require a lot of time for clean up, and putting together a build, since the source files are scattered among different libraries I use. Short of that, here's a link to the file that contains the rendering code, for them as are interested in such things. There's a nice article by Jos Leys explaining the math here.

2009-04-13T16:05:00.000-07:00

I needed code for the 2D and 3D distance transform (for my dendrogen toolkit), and the only thing I could find used ITK -- lovely toolkit, but that's a big dependency I didn't want to drag in. I looked up the algorithm, and it turns out it's dead simple.

Curious thing about the distance transform is that approximate algorithms have been around for a while, but so far as I can tell, an efficient (linear in the number of pixels) and exact algorithm was only devised in 2004, by Messrs. Felzenszwalb & Huttenlocher. Their solution is also beautifully simple. The paper contains pseudocode which can be directly translated into C.

The above pic is a slice through a 3d distance transform of a set of points, and the corresponding 3d voronoi diagram.

I added the ability to optionally generate voronoi regions. The code mostly tests with points, but it will work with arbitrary regions as well. It's a VC Express project, but the code is all portable. The test code uses OpenCV just to display results, but the distance transform code itself is in a single header and has no dependencies beyond the C++ standard library.

If you look at the code, you'll notice an OpenMP directive, which sped things up by about 25% on my slow-but-dual-core laptop. The tiny amount I know about OpenMP is from a Doctor Dobb's article I read years ago, so I don't know if I'm using it correctly, except to say that the results appear correct, and it did indeed make it go faster.

2009-04-02T11:14:00.000-07:00

I'm currently making a open source software toolkit for procedural tree generation called dendrogen (I figure every open source project needs a catchy name ;-)

My plan is to create efficient, practical implementations of promising tree generation algorithms, ready for incorporation into modern CG pipelines. So far I've implemented the algorithm from Runion et al's paper Modeling Trees with a Space Colonization Algorithm, and I'm half-way through an implementation of the algorithm in Rodkaew et al's Particle Systems for Plant Modeling.

I currently have no plans to implement L-systems, since 1) it seems that despite their extraordinary power for compactly describing rich plant geometries, they are not very directible -- it's hard for an artist to end up with a tree of a desired target geometry; and 2) I believe there are already well-developed tools in that area. My hope with the tool I am building is that it will be the center of a artist-centric tool that will permit interactive sculpting of foliage envelopes.

If I'm wrong about L-systems, please let me know.

The first phase of the project is to create high quality, well-documented and thoroughly tested C++ implementations, together with python wrappers that will be written in tandem.

The next phase will be creating tools for generating the geometry of the tree itself, using the skeleton generated by the code in the first phase. The tentative plan at this point is use implicit surfaces.

The attached screenshot is from Maya, but there is no Maya dependency in the code.

I'm currently leaning towards an LGPL license. If you would like a snapshot of the current code, let me know (kevin.atkinson at the domain gmail.com).

2009-03-09T20:13:00.001-07:00

I just accepted a job at Weta Digital in New Zealand, and assuming all the visa-getting rigamarole goes as planned, Julie and I will be heading there in about 6 weeks. I will be a "CG Software Engineer" -- it is spelled out in the contract that that will be the exact text of any screen credit I might receive. So in the next couple of years, if you see a movie where Weta was an vfx vendor, and you stay until the bitter end of the closing credits, after the Key Grip and the Best Boy and the Caterer and the Parrot Wrangler, you may see my name up on the big screen, in 7 point type. Which will be as satisfying to me as a director's credit.

2009-01-25T23:15:00.000-08:00

Brandon Flowers' Head from Kevin Atkinson on Vimeo.

I did some visuals for the Killers' 2009 tour based on a live video effect I did that resembles the cover art of Day & Age, their latest CD (it's the virtual ballpit effect that's demoed here). This isn't one of tour visuals but a variant of my last post. I was going to pitch the lighting designer on using it, but I think maybe it's a bit too distortive -- you probably shouldn't make your dashing front man look like the elephant man for most of the duration of the effect.

Nonetheless, I thought it looked pretty cool....

(High-quality quicktime here.)

2009-01-23T21:49:00.000-08:00

K from Kevin Atkinson on Vimeo.

2009-01-15T08:29:00.000-08:00

Haven't posted in a bit, since I'm up to my eyeballs in various non-art programming projects. This blog was recently on the reddit front page (third time I've made it there!), and I notice while looking at the blog hits that people spend a lot of time meandering about the site looking for the cool stuff, so I thought I would post a brief list of the people's favourites.

This one was my biggest hit so far (made the front page of reddit, and got bounced around some art and design sites as well):

http://methodart.blogspot.com/2008/06/virtual-ball-pit-from-kevin-atkinson-on.html

At the bottom of that post are a few links to some of the other effects on the blog.

I had an art show last year. I was rather proud of the flyer art:

http://almach.lunarpages.com/~metho9/show_flyer.pdf

For the impatient, here's a video of most of the good stuff in one clip:

http://methodart.blogspot.com/2008/06/engine-room-audition.html

Finally, here's a bunch of experiments I did exploring novel ways of representing images through various procedural methods:

http://methodart.blogspot.com/2006_11_01_archive.html
http://methodart.blogspot.com/2007_10_01_archive.html

2008-11-12T22:43:00.000-08:00

Drawing pictures with diffusion-limited aggregation from Kevin Atkinson on Vimeo.

I've wanted to try this idea for a while, so here's a quick-and-dirty version. I'd like to revisit it and do it properly sometime.

The idea is: make a picture using diffusion-limited aggregation. The code and technique I used is the cheesiest of quick hacks, but the results are really encouraging.

The pictures are nice, but most of the fun is watching them develop. So here are some movies of the process, each with slightly different settings:

First movie.
Second movie.
Third movie.

2008-11-09T20:08:00.000-08:00

Here is the calibration target scanning code. It is a VC Express project, though all the code should be portable.

2008-11-09T16:58:00.000-08:00

Update: The checkerboard scanning code is here.

I've been working on computer-vision-y stuff rather than visual-effects/art-y stuff lately, and I thought I'd share the fruits of my labour with the geekier contingent of the 3 or so people who read this blog.

I use OpenCV a lot in my work, and it is a wonderful toolset indeed, except I've always been irritated by the limitations of its calibration target scanner. Bafflingly, it requires the entire target to be visible in the image, which makes it difficult to get good image coverage for lens distortion estimation. My hunch is that a good camera calibration requires data from all parts of the image, which is difficult to do when if you even slightly clip one corner of the target, the scan fails.

Another limitation is that the target (a black and white checkerboard) has no fiducial markings to indicate the origin of its coordinate system, which is problematic in some applications (it caused major ass pain when I was developing a vision-guided robotics application).

So I wrote a target scanner which overcomes those limitations. It will scan as much or as little of the target that is in view, and supports targets of up to 32x64 squares, which should be plenty.

I'm preparing a source release, which will be ready shortly. It will include a python script which uses pycairo to generate pdf files of the target.

The scanner knows where it is in the target coordinate system by the special codes in the centers of the squares. It's a simple little 2d code of my own devising which encodes the x,y position of the square plus a 3-bit checksum.

It's pretty quick, too: it takes about a 20th of a second to scan a 640x480 image, on my under-powered laptop.

2008-09-06T15:01:00.000-07:00

I never imagined that I would have a reason to post a picture of Mary-Kate Olsen on my blog, but life is funny that way.

I've been knocking myself out for the past six weeks writing some live video effects for a Sept 4 New York fashion week party sponsored by Dazed and Confused magazine and Mini Cooper. Hipster heroes MGMT played. Joel Gethin Lewis scored us the gig and played VJ for the night. The bugger of it was that I wasn't able to go, so I've been poking around the net looking for some pics of the effects in action, but almost all of the photos from the night are red carpet shots of the various models and starlets who were in attendance.

There's a write-up on the Mini Cooper site which mentions the video effects: MINI Rooftop Party.

And I did find a video which shows the briefest of glimpses of the software in action -- check out this link at 0:10 and 0:33:

Fashion week party video.

The final push to get the software ready was pretty brutal -- a succession of 16 to 20 hour days of coding and debugging. It only crashed once, which, considering it was essentially alpha software, is not bad at all. Joel tells me that people had great fun playing with the effects.

2008-08-20T08:56:00.000-07:00

2008-08-19T09:29:00.000-07:00

Screen caps from a new effect. Movement causes the tiles to twirl in place. Virtual torsional springs eventually restore the image to flatness.

2008-08-13T13:11:00.000-07:00

I write a lot of image processing code using the OpenCV library. I've been using this C API for years, and I've grown deeply familiar with its eccentricities. I know my way around it pretty well.

However, it is a C API, and hence rather low-level. You have to explicitly allocate and deallocate images and other objects explicitly -- lot's of clerical overhead. The code is not pretty.

Naturally, one starts to wonder if there is a Better Way. And indeed, I've attempted several times to create some kind of object-oriented layer on top of OpenCV. But I always find that the layer I create ends up getting in the way, requires too much maintenance, and ends up causing more annoying resource management issues than it's worth.

So I have always, always gone back to using the C api.

My efforts to build this easier layer usually focussed on creating an image class, encapsulating the IplImage type used by OpenCv. In my first pass many years ago, I created the image class, and then started adding all the image processing functions in OpenCV as methods. This is okay to a point, and simplifies certain types of coding appreciably, but there are too many calls in the API that don't map very well to the object.method() paradigm.

I think the basic error I made in those previous efforts was making the central object the image. Last night I had the idea of making the central object an image operator. The result is extremely clear, brief, simple, and yet still performant code. Here's a snippet:

from_file("input.png")
>> smooth(CV_GAUSSIAN, 21)
>> rotate(45, 100, 100, 2)
>> rgb_to_grey
>> resize(2)
>> threshold(127, 255, CV_THRESH_BINARY)
>> erode(1)
>> dilate(1)
>> to_file("output.png")
;

Here's the equivalent C code:

IplImage *img_from_file = cvCreateImage("input.png");
cvSmooth(img_from_file, img_from_file, CV_GAUSSIAN, 21);
double mat_stg[6];
CvMat rot_mat = cvMat(2, 3, CV_64F, mat_stg);
cv2DRotationMatrix(cvPoint2D32f(100, 100), 45, scale, &rot_mat);
cvWarpAffine(img, _img, &rot_mat);
IplImage *img_grey = cvCreateImage(cvGetSize(img_from_file), IPL_DEPTH_8U, 1);
cvCvtColor(img_from_file, img_grey, CV_BGR2GRAY);
IplImage *big_grey_img = cvCreateImage(cvSize(img_grey->width*2, img_grey->height*2), IPL_DEPTH_8U, 1);
cvThreshold(big_grey_img, big_grey_img, 127, 255, CV_THRESH_BINARY);
cvErode(big_grey_img, big_grey_img, 0, 1);
cvDilate(big_grey_img, big_grey_img, 0, 1);
cvSaveImage("output.png", big_grey_img);
(omitting necessary cleanup code to delete images)

Which code would you rather read? Which code would you rather write?

It's probably apparent that what the nice code is doing is pushing an image through a pipeline of image-processing primitives.

Now pipelines are all well and and good, but what if your processing problem can't be modelled with the simple topology of a pipeline? For instance, what if you have an operator that has two image inputs? A good example is an operator which creates a weighted sum of two images. In that case, the code looks like this:

(from_file("input.png"), rotate) >> mix(.2, .5) >> to_file("output_mix.png");

Pretty slick, if I do say so myself.

Here's how it all works: For each operator we want to add, we create a class with a Process method, an Output method, and an operator() method. The Process method accepts the data that it is to process, and the Output method returns the result of its operation. The overloaded operator() is where the user passes in parameters which affect its operation. You can think of them as "filter settings".

Here's an example of the Threshold operator:

class Threshold
{
public:

Threshold() : _img(0) {}
~Threshold() { if(_img) cvReleaseImage(&_img); }

Threshold& operator()(double thresh, double max_val, int threshold_type)
{
_thresh = thresh;
_max_val = max_val;
_threshold_type = threshold_type;
return *this;
}

IplImage *Output() { return _img; }

void Process(IplImage *img)
{
_make_images_same_size(img, &_img, IPL_DEPTH_8U, 1);
cvThreshold(img, _img, _thresh, _max_val, _threshold_type);
}

protected:

IplImage *_img;
double _thresh, _max_val;
int _threshold_type;
};

I've used an overloaded operator>>() to hook up operators. It looks like this:

template <class T_rhs, class T_lhs>
T_rhs& operator>>(T_lhs &lhs, T_rhs &rhs)
{
rhs.Process(lhs.Output());
return rhs;
}

That's all you need for a pipeline. To support the multiple-inputs idea, I had to do a bit more template legerdemain. To wit, I overloaded operator,() (I had to check that it was actually possible to do this -- who overloads the comma operator, for heaven's sake?), and create a helper class that would cache references to the two input arguments. That code looks like this:

template <class T1, class T2>
struct ArgPair
{
ArgPair(T1& arg1_, T2& arg2_) : arg1(arg1_), arg2(arg2_) {}

T1& arg1;
T2& arg2;
};

template <class T1, class T2>
ArgPair operator,(T1 &arg1, T2 &arg2)
{
return ArgPair(arg1, arg2);
}

And then I had to create another overloaded operator>> that would accept a left-hand side of type ArgPair:

template <class T1, class T2, class T_rhs>
T_rhs& operator>>(ArgPair<T1, T2> &lhs, T_rhs &rhs)
{
rhs.Process(lhs.arg1.Output(), lhs.arg2.Output());
return rhs;
}

Voila. Works like a charm. Happiness blares from every street corner. ...Exccceeept: what if I want to pass more than two arguments to an operator? 3 arguments, or possibly 4? Hm. It took a couple kicks at the can to get this going, and it's not quite as brief as the code so far, but here's what I did:

template <class T1, class T2, class T3, class T_rhs>
T_rhs& operator>>(ArgPair<ArgPair<T1, T2>, T3> &lhs, T_rhs &rhs)
{
rhs.Process(lhs.arg1.arg1.Output(), lhs.arg1.arg2.Output(), lhs.arg2.Output());
return rhs;
}

template <class T1, class T2, class T3, class T4, class T_rhs>
T_rhs& operator>>(ArgPair<ArgPair<ArgPair<T1, T2>, T3>, T4> &lhs, T_rhs &rhs)
{
rhs.Process(lhs.arg1.arg1.arg1.Output(), lhs.arg1.arg1.arg2.Output(), lhs.arg1.arg2.Output(), lhs.arg2.Output());
return rhs;
}

... continue ad infinitum. Or, till, say, 8 or 9. Sheesh, how many inputs do you need?

So I think I may have found my way out of the OpenCV C API wilderness. I have a couple computer vision projects lined up, and I am going to use this approach from start to finish. I just love that you get so much in the way of abstraction and simplicity in return for a very small amount of infrastructure code.

Here's the code. It's very preliminary, but there just isn't all that much to it, so you should be able to start hacking and adding operators right away. Also note that you don't have to use this approach for image processing -- it'll work for anything.

2008-07-11T15:06:00.000-07:00

I was frustrated with facebook's graffiti widget, because I can't draw for crap, so I wrote a hacky little program that sends fake mouse messages to the graffiti window, so it draws whatever I tell it. Silly fun. Click the "Play" button above -- it's fun to watch it draw.

2008-06-30T12:38:00.000-07:00

Engine Room Audition... from Kevin Atkinson on Vimeo.

Nothing really new here if you're familiar with the blog, but I thought I'd post it anyway, since it is a nice little compendium of most of my better stuff. And yes, it's an audition for MTV's Engine Room. Spent way too much of my weekend putting this together. Anybody know any good, cheap video editors out there? I tried Sony Vegas Platinum, but it seems to only support two video tracks which is staggeringly lame. Cheap is more important than good right now.

(Apologies for the cheesy pun at the end -- that's my oldster attempt at playing to the MTV crowd...)

2008-06-26T12:53:00.000-07:00

Some tests from series I'm working on.

2008-06-22T12:56:00.000-07:00

Virtual Ball Pit from Kevin Atkinson on Vimeo.

Update: This is effect is currently being used by the band The Killers in their onstage visuals during their current world tour. It's deeply satisfying to see it being used in a high-profile setting.

I quite like how this one turned out. I've been playing with real-time physics libraries for a while, both 3d and 2d, and I've been wanting to do something for a while, but I've found it surprisingly difficult to come up with anything that grabbed me. But a couple weeks ago I had a brainwave and wrote this in just a couple days.

For those interested in such things, I didn't use Erin Catto's Box2D, which seems the current champ in developer mindshare in this tiny niche. I started out using it, and it's quite nice, but it just wasn't fast enough when I used enough circles/pixels to generate an intelligible representation of the video stream (there're about a 1000 used in the demo above). Luckily, I chanced across Scott Lembcke's chipmunk physics library which uses some kind of fancy-pants geometric hashing to speed up collision testing, and it works quite nicely in real-time with 1000 pixels/circles.

As ever, I'm impatient with the whole documenting process, which is why these demos are a tad perfunctory and under-(non-?)rehearsed at times. So yes, if you listen close, you'll hear me say to my wife, "I just want to get this stupid thing up on the web...."

P.S. Some people have told me they have trouble with the vimeo video, so here's a link to the (ghastly, artifact-riddled) youtube version.

P.P.S. Here's quicktime of the vid.

P.P.P.S. if you liked this one, you'll probably like these as well:

The wobbly effect!
the flowy-fluid effect!
The wavy effect!
The freaky time-shifting effect!

2008-06-20T09:23:00.000-07:00

This messed me up for a bit:

IplImage *img = cvLoadImage(...
...
for(;;)
{
if(img) cvReleaseImage(&img_cap);
sprintf(buf, "\\image_folder\\%d.jpg", img_idx++);
IplImage *img = cvLoadImage(buf);
...
}

Watch it leak like a sieve. Might be obvious to some, but even though the second declaration of img comes after its first use in the nested scope, the compiler still assumed I was referring to the nested img. Which seems like a compiler bug -- why would it permit use of that variable before it is declared? The second declaration was a cut-and-paste error, btw.

2008-06-14T22:10:00.000-07:00

Revisiting some ideas and techniques and applying nice rendering styles, and adding 3D touches to 2D ideas.

I'm making several pieces based on a technique used in the above pic. Note that the tubes, or viscera, or whatever the heck you might call them, are actually a single continuous loop.

2008-06-09T06:38:00.000-07:00

The video is up at Colonel Blimp and promonews.tv. If you're arriving from there, the effect we used is demoed here:

The wobbly effect!

And if you liked that, you'll probably like these as well:

the flowy-fluid effect!
The wavy effect!
The freaky time-shifting effect!

2008-06-04T23:27:00.000-07:00

I'm having a show. Here's a flyer.

2008-05-27T06:38:00.000-07:00

Ross and Bugsy of OneInThree have posted a high quality quicktime of the Leon Jean-Marie video on their website. The more subtle wobble effects come across much better than the youtube version.

2008-05-26T16:18:00.001-07:00

Bouncy Pixels from Kevin Atkinson on Vimeo.

Bouncy Pixels Redux from Kevin Atkinson on Vimeo.

First new video effect in a while. It's quite simple, but you get a surprising diversity of behaviour and looks by playing with the half-dozen or so parameters that control it.

There are also a few enhancements I'll be making -- thresholding the perturbations to eliminate the constant low-level wiggling, using "blue noise" pixel distributions, rather than only a grid, and nicely composited pixels, maybe with feathered edges, rather than just circles which overwrite one another.

I used vimeo, since the youtube version just looked too depressingly awful, but apparently it doesn't work for everyone, so here are the youtube versions: first, second.

And here are the quicktime versions: first,
second.

Nuther one coming in a couple days. I'll try not scratching my nose half-way through this one....

2008-05-20T17:11:00.000-07:00

Here 'tis! When I have a better quality quicktime link, I'll post that. Enjoy!

2008-05-10T09:47:00.000-07:00

I'm in London working on a music video using one of my effects (the wobbly one). We shot it yesterday, and I was able to run a real-time preview on the set. It was my first time on a set of any kind, and my primary ambition was to not bump into anything expensive. I also became acquainted with the the phenomenon of "runners" -- they have people who, when you need something, will get it for you! Brilliant.

The video is being directed by the extemely decent and prodigiously talented Bugsy Steel (left, above) and Ross Cooper (right), who together form oneinthree.tv, and features a great young R&B artist named Leon Jean-Marie, who apart from having great musical chops and dashing good looks, turns out to be able to hold up his end in a conversation about string theory. I'll post some pics later.

I feel quite the hick amidst all of these stylish, prosperous and indefatigably witty Londoners. It's a long way from the lunch-bucket precincts of my home town in Canada.

(So Kert, you were right! It was indeed a music video waiting to happen!)

Update: If you're arriving from promonews, the effect we used is demoed here:

The wobbly effect!

And if you liked that, you'll probably like these as well:

the flowy-fluid effect!
The wavy effect!
The freaky time-shifting effect!

2008-03-31T06:29:00.001-07:00

Hi there, motionographer fans! Sorry for the lame blogspot format -- been meaning to upgrade to something a bit more navigable for a while. In the meantime, here are a few quick links to the most popular items: the flowy-fluid effect, the freaky time-shifting effect, the wavy effect, and the ever-popular funhouse mirror effect.

The archive links are also good for getting a quick overview of what's on the site:

archive link 1.
archive link 2.
archive link 3.

I am actively seeking interesting and/or lucrative projects, so feel free to pitch me with your idea. Any and all feedback is appreciated, so why don't you...

2007-11-23T08:56:00.000-08:00

Particles, man, its all about the particles. I haven't explored them as much as I ought to have, since I always had this vague snobbish feeling that they are too simple, too easy, and I should concentrate on harder physics, like fluids. But the incredible wealth of phenomena you can model with a point mass, a few forces, and a cheesy Euler integrator endlessly astonishes me. O particles, is there anything you can't do?

2007-11-22T11:44:00.001-08:00

For those arriving via reddit, you're probably interested in other video effects. You can check some of them out here, here, and here. If you're not arriving from reddit, the video that they saw is here.

2007-11-21T17:49:00.000-08:00

As I've mentioned in previous posts, I'm working on a sound-reactive animation. In my quest to come up with some kind of visual analog to the music I was given, I've pursued a number of dead ends, but at one point I tried a very minimalist approach, seeing how simple the base geometry could be and still be interesting. The above pic is an example. A number of the pictures I made suggest textile patterns, and avenue I may pursue later.

2007-11-21T17:35:00.000-08:00

I am just so absolutely besotted with procedural methods. I am currently playing with procedural floral patterns. This one is cooked up from about a dozen parameters -- number of petals, length, radial noise, petal width, petal attenuation function... it goes on. It's fun to explore the parameter space and see what you can come up with. It is implemented as a Renderman displacement shader.

I would really like to do the same in true 3d, though that is a much more complicated problem. I'm thinking of generating the base geometry as stream-surfaces based on particle simulations. I dug up a particle system I wrote a couple years ago, and it is pretty darn good -- fast and flexible. Finer detail could be provided through displacement shaders.

I was considering using floral patterns like this for a sound-reactive animation I am working on, though it just doesn't match the music, which is jangling and percussive. But then, maybe that would be cool.

2007-11-15T21:10:00.000-08:00

It's fun to watch the spheres gradually accumulate to fill the volume. Better quality quicktime here.

2007-11-15T17:51:00.000-08:00

A 3d equivalent to this previous post. One extra dimension proved to be a lot of trouble, and roughly 1000 times longer to compute (this had to run overnight, albeit it with a not-terribly-efficient algorithm) . Happily, what I'm am working on at work is actually somewhat related, so it didn't cut into the main focus of my extra-curricular efforts, a short, sound-reactive film, the deadline for which is approaching with terrifying rapidity....

For the physics geeks in the crowd, this is a bust of Max Planck, reluctant progenitor of the quantum theory. I used his head for the sole reason that I needed a manifold triangular mesh of a human head, and his was the first I found, but it seems fitting that it was his head of all heads that I discretized into spherical quanta.

2007-11-06T13:48:00.000-08:00

Looking for a pinched, starved shape style to contrast the puffy, cartoony style of the last post. The above is not entirely what I was going for, but the approach yielded some interesting imagery.

Some more examples: 1, 2, 3, 4.

2007-11-03T15:53:00.000-07:00

It's time to confess my immoderate love of 1) implicit surfaces; and 2) sparse convolution noise. Both can be bloody expensive in rendering time, and implicit curves and surfaces are huge memory pigs, but lordamighty you can make nice pictures with them, that you can't any other way.

Brief animation test here. (It's a zipped quicktime.)

2007-10-24T11:47:00.000-07:00

Simple experiment: distort the image, tile, then undistort -- the result is an undistorted image with distorted tile geometry. Promising beginning, but to get quality images will take some extra care.

2007-10-22T19:49:00.000-07:00

Quite addictive, this tiling thing. Click on the pics for larger versions....

2007-10-21T16:07:00.000-07:00

Revisiting my preoccupation with tiling. Click on the pics for larger versions.

2007-10-16T20:54:00.000-07:00

I was calling the last effect an "interactive funhouse mirror", which evokes for me genteel, olde-time associations of county fairs and boardwalks. Until you lip-synch a Henry Rollins song up close to the camera, that is....

2007-10-16T05:38:00.001-07:00

I had this idea a long time ago, finally got around to implementing it this weekend. The concept is... well, it doesn't really matter, you'll figure it out. A kind of interactive fun-house mirror, I guess.

I'm starting to acquire a critical mass of code and techniques so that I can implement these things very quickly. I wrote the code in one weekend and still had time to mow the lawn and go grocery shopping.

Higher quality video here. For some reason, quicktime hung while trying to encode this, so the best I could do was a bloated cinepak avi.

P.S. If you liked this, you will probably like this, this and this.

2007-10-08T21:00:00.000-07:00

A 2d wave simulation rendered as a height field, using the simple adaptive tiling scheme from the last video. Rendered in POV-RAY, a nice, free ray-tracer. Superb support for implicit surfaces. Indeed, implicits are POV-RAY's killer-app, I think.

I made a brief video of the wave action.

2007-10-03T19:16:00.001-07:00

Some stills from the video.

2007-10-02T21:40:00.000-07:00

I have a lot of ideas for adaptive tilings of images. By adaptive, I mean that the image is tiled more finely in regions of high detail. Easiest to do is rectilinear tiling as in this sample, but I'm working on a nice, organic adaptive tiling algorithm.

For them as wants a quicktime of the above, it is here.

2007-10-01T21:09:00.000-07:00

The force-field streamlines lines plug-in that I disinterred from my vfx wannabe days inspired me to reprocess the fluid sim video with the velocity streamlines drawn in. I really like the result, and it suggests to me a host of variants. For instance, I would like to trace them very densely, or perhaps visualize the velocity magnitude as a heightfield with lighting effects.

I was surprised at the way the streamline lines squiggle furiously sometimes. And while it's evident that they are responding to my movements, they also seem to be weirdly autonomous.

I kept the number of streamline sparse in this one, since when I added more, the quicktime encoder produced absolutely dreadful results -- muddy, artifact-riddled, barely legible. The youtube version is actually only marginally less ghastly. I will post a decent quicktime later.

[Later]There are a couple quicktimes of the effect here.

&lt;br>

2007-10-01T10:14:00.000-07:00

Exploring ideas for a sound-reactive piece. Been focussing on physics-based ideas, including fluid simulation, rigid-body physics, mass-and-spring systems, and implicit surfaces. Eventual renderings are planned to be very stylized. I like the idea of organic, physics-based underpinnings married to a highly stylized rendering. I was prompted to dig up some Maya plug-ins I wrote a few years ago. The screen shot above is from a plugin that traces streamlines through a Maya force field. Technically interesting in that it requires a cycle in the dependency graph. Couple more samples here and here.

2007-09-27T09:48:00.001-07:00

I hate programming. Which is to say, I love programming. Or
putting it another way, I hate programming. Gosh, words are
just so darn elusive! But what it all boils down to, what I'm
really trying to say, at the end of the day, when you cut
through all the bullshit, when all is said and done, and the
cows have come home, and the chickens are roosting, is...
that I love programming. I mean, hate it.

2007-09-23T13:48:00.000-07:00

Some fun with Messrs. Navier, Stokes, Horn and Schunk. I started this ages ago, but it was a real headache getting the fluid sim code right. The coarse youtube resolution doesn't do the effect justice -- there's a ton of fine detail that doesn't come through. Nonetheless, you can probably get the gist. Works in real-time.

P.S. if you liked this, you will probably like this and this as well.

&lt;br>

2007-09-14T19:12:00.000-07:00

Some stills from the video. I think I almost prefer the stills to the moving effect. They remind me of Lucian Freud, or possibly Francis Bacon.

2007-09-12T20:59:00.000-07:00

Been too busy to post for a while, but this was fairly quick to implement, and I dare say it's a pretty cool effect. The grotesque distortions remind me a bit of a Chris Cunningham video.

It works in (somewhat sluggish) real time. The face detection is a bit glitchy, leading to a few popping artifacts now and then, which could be easily remedied with a Kalman filter. A further improvement would be to use optical-flow-based interpolation so you wouldn't get that sort of zebra-stripe effect during rapid movements, but that would kill frame rate dead. But it would be just the thing for high-quality, offline processing.

Speaking of videos, I am actively seeking collaborators -- I've come this close a couple times to seeing some of this stuff used in high-profile broadcast work, but both times it fell through. So come on, all you big-shot producer-types, up-and-comer video directors, or art-school animators, drop me a line.

P.S. If you liked this, you might like these, as well:

The bouncy balls effect!
The wobbly effect!
the flowy-fluid effect!
The wavy effect!
The freaky time-shifting effect!

&lt;br>

2006-12-18T08:32:00.000-08:00

Sorry I haven't posted for a bit -- I had an interview at a very lively vfx company last week, and getting ready for it has consumed my attention for the last little bit. I don't think I've ever been in such a high concentration of super-bright, super-talented people. Very cool place.

At any rate, I have 3 or 4 things in the pipe, though I expect the looming holidays are going to cut into my extracurricular image-making activities.

2006-12-04T16:32:00.000-08:00

Larger version here.

2006-11-27T19:05:00.000-08:00

Larger version here.Same technique as the last image, except I use a different basis function -- in this case, a sparse convolution noise function, instead of a boring ol' sine wave. It's actually what I was originally planning with the image below -- the concept was an electroencephalograph trace actually creating a macroscopic image from the individual traces -- but the image was really hard to make out. A bit of tweaking with power functions brought it to the just -legible level, so I went ahead with the post.

2006-11-26T10:56:00.000-08:00

Larger version here.

2006-11-23T22:26:00.000-08:00

Larger version here

2006-11-19T20:01:00.000-08:00

2006-11-19T00:46:00.000-08:00

A promising start, despite the brutal streaking artifacts. Going to try a simple scheme where I adjust the line widths that should correct most of it, but it requires writing a bit more code.

[Later] Made a few empiric tweaks, tamed the worst of the artifacts. But we'll have to accept some degree of radial streaking as part of the charm of the effect.

2006-11-17T19:36:00.000-08:00

See a larger version here.

This effect would likely make for a cool animation, and in fact could be made quick enough to work in real time. I'll prepare an animation test and post it later.

2006-11-14T20:12:00.000-08:00

I mentioned Renderman and Aqsis in a previous post. This image is somewhat more conventional picture-making; in fact, I was reluctant to post it here because I didn't write the software to generate the image, in contrast to the rest of the images on this blog. (I used Aqsis, the open source Renderman compliant renderer.) Unless a shader counts as a piece of software, since I did write the shader used in the image above. So on that technicality, the above image squeaks by.

A shader is a gobbet of code that executes at every point on the surface of an object being rendered, and it informs the renderer how the object should look at that point. The base geometry is a simple donut shape, and I've attached a simple procedural shader to the surface -- a displacement shader, as a matter of fact. I call it my Henry Moore shader. You can check some more of my shaders here. As you will see, I am very partial to displacement shaders.

(For those waiting for more whiz-bang interactive video effects, I'm working on something pretty cool. Should be ready in 2-3 days. Thought it'd be ready by now, but the book-keeping when dealing with staggered grids can be a headache.)

2006-11-12T09:15:00.000-08:00

Same technique as last post, except with vertical and horizontal squiggles composited together.

NOTE: I really want to encourage people to blur their eyes a bit and step back from the monitor to look at this image. Up close, of course, it just looks like a garbled grid. But as you step back, the image in its full fidelity really jumps out. You have to filter out that high frequency energy that prickles your eyeballs when you're up close.

2006-11-10T13:22:00.000-08:00

Please check out my profile. Also, apologies to anyone who tried to contact me at the email address in the blog, since it was wrong. It is now correct: contact me

2006-11-10T11:41:00.000-08:00

An interesting variant of the line-halftoning idea is to constrain the ways in which the lines can move. In the above image, a set of vertical parallel lines are allowed to squiggle sideways so that
together they approximate the local grayscale of the image. You might have to blur your eyes a bit and step back from the monitor to get the effect.

This approach is a bit dicey, since the average grayscale of any given line is constant, so it tends to wash out the image. And it fails (though sometimes in visually interesting ways) on high contrast images.

Nuther one here.

I'm planning to use the lines as base geometry for more fanciful Renderman-based images -- one thought I had was to mimic wood grain, so it would look like the image of Lena was revealed in a sawn log. Hm. Maybe a picture of the Virgin Mary would be more thematically appropriate....

2006-11-10T09:10:00.000-08:00

Here's a brief animation test using the scribbly half-tone technique. The compression artifacts really take a toll, but I think you can get the gist.

2006-11-04T07:11:00.000-08:00

I work with video as well as still imagery. Stick it out till at least 0:28, where it gets interesting.

If you liked this, you will probably like this, this, and this.

P.S. Yes, my presentation skills need work....

2006-11-01T20:26:00.000-08:00

When implementing some of these image representation ideas, sometimes they turn out exactly as I expected, sometimes better, and some are complete duds. The above pic was an example where I got something that I expected would look cool, but I didn't expect it that it would look like... coiled viscera, or brains or something. It's not entirely successful in that it's pretty hard to make out what it is representing (it's the Mona Lisa). Needs some tweaking to convey contrast better. Also, the intestine-y look invites a nice, gooey, glistening rendering style. So it's time to break out the Renderman.

Renderman, of course, is the 3d rendering technology created by Pixar. I can't affort the 12 grand or whatever for their flagship renderer, but thankfully there is a superb knockoff called 3Delight that's quite nice indeed, and the first license is free. There are also a couple quite passable open source Renderman-compliant renderers out there, notably Aqsis, which I have used quite a bit.

Renderman is a 3d renderer, but there's nothing to prevent it from being used to make 2d images. And the Method Artist just loves the procedural shader model. So watch this space for some 2.5D procedural madness.

P.S. If you liked this, you might also like this!

2006-11-01T19:08:00.000-08:00

Nuther variant on the line-half-toning idea.

2006-11-01T18:43:00.000-08:00

While trying to figure out ways to half-tone an image with a continuous line, I had the brainwave that traversing stipple points in Travelling Salesman Problem order might be an interesting way to do it. The travelling salesman problem is a famous optimization problem, famous for being famous, and famous for being computationally intractable. It's also famous for being easy to state as it is hard to solve: given a set of cities, what is the shortest route that goes through each of them? My thought was that the geometrically optimal line which joined all my stipple pts might also be aesthetically optimal.

So I went poking about the net for TSP software, and found out that a fellow named Craig S. Kaplan published a paper on this very technique about a year ago. You can check out the link here. I was a bit bummed to find someone had beaten me to the punch, but I wrote an implementation anyway. The pic above is a typical example. Enjoy. The effect avoids the lattice artifacts of the Sierpinski approach (though perhaps that's part of the charm?), and looks smoother overall.

2006-11-01T18:28:00.000-08:00

Been on a kick where I am looking for ways for a continuous curve (in this case, a piecewise linear curve) creates a half-tone effect by bunching up tightly in dark areas, and spreading out in lighter ones.

There are a bunch of ways to do this. One cheap and cheerful method is to stipple the image, and then traverse the stipple points in Sierpinski curve order. If it was earlier in the evening, and I was less bagged from work, I would be more inclined to go into detail, which might not be a good thing.

From the Method Artist

2006-11-01T14:41:00.000-08:00

This site is my first stab at showcasing some of the procedural image-making I have been working on lately. I become quite compulsive about it, and I am starting to accumulate a nice grab-bag of techniques and source code, and I am eager to get some feedback.

Above is an example of one of my latest. Hodge-podge of different techniques, turned out pretty good. Some pretty heavy number crunching involved, takes a couple minutes for medium size image on a recent model PC. And yes, it's a processed photograph of Marilyn Monroe. With any luck, I won't get in trouble for pillaging a copyrighted image.

I have ambitions to "monetize" my work, as we say in my biz, which is the biz of software development. I am casting about for a business model, which might consist of selling plug-ins for Photoshop so that others can make stuff like this, or possibly selling preposterously over-priced one-offs to wealthy Manhattanites, or maybe executing some of my ideas in welded steel on a massive scale to decorate some soaring corporate atrium or other. Suggestions are welcome.

One thing I won't be doing is open-sourcing the code, so don't ask. At least, I won't be doing it before my daughter is out of college. I love open source, and I am deeply philosophically committed to the GPL when it comes to public computing infrastructure -- OS's, compilers, network stacks and such like -- and I plan to contribute in future to an open source project where my skills apply and my personal solvency permits. But I'm also okay with selling proprietary, closed-source software. As Linus says, the person who wrote the code gets to decide what to do with it, and for now, this stuff is for my eyes only.

Expect to see a new image every couple days or so. Typically what is involved is 1) having an idea (and they are coming thick and fast these days); 2) writing some code; and 3) making some images.

P.S. Please forgive the pretension and mystery surrounding my self-appellation. I want to keep blog this anonymous for now.